1 //===-- sanitizer_common_libcdep.cc ---------------------------------------===// 2 // 3 // This file is distributed under the University of Illinois Open Source 4 // License. See LICENSE.TXT for details. 5 // 6 //===----------------------------------------------------------------------===// 7 // 8 // This file is shared between AddressSanitizer and ThreadSanitizer 9 // run-time libraries. 10 //===----------------------------------------------------------------------===// 11 12 #include "sanitizer_allocator_interface.h" 13 #include "sanitizer_common.h" 14 #include "sanitizer_flags.h" 15 #include "sanitizer_procmaps.h" 16 17 18 namespace __sanitizer { 19 20 static void (*SoftRssLimitExceededCallback)(bool exceeded); 21 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) { 22 CHECK_EQ(SoftRssLimitExceededCallback, nullptr); 23 SoftRssLimitExceededCallback = Callback; 24 } 25 26 #if SANITIZER_LINUX && !SANITIZER_GO 27 // Weak default implementation for when sanitizer_stackdepot is not linked in. 28 SANITIZER_WEAK_ATTRIBUTE StackDepotStats *StackDepotGetStats() { 29 return nullptr; 30 } 31 32 void BackgroundThread(void *arg) { 33 const uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb; 34 const uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb; 35 const bool heap_profile = common_flags()->heap_profile; 36 uptr prev_reported_rss = 0; 37 uptr prev_reported_stack_depot_size = 0; 38 bool reached_soft_rss_limit = false; 39 uptr rss_during_last_reported_profile = 0; 40 while (true) { 41 SleepForMillis(100); 42 const uptr current_rss_mb = GetRSS() >> 20; 43 if (Verbosity()) { 44 // If RSS has grown 10% since last time, print some information. 45 if (prev_reported_rss * 11 / 10 < current_rss_mb) { 46 Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb); 47 prev_reported_rss = current_rss_mb; 48 } 49 // If stack depot has grown 10% since last time, print it too. 50 StackDepotStats *stack_depot_stats = StackDepotGetStats(); 51 if (stack_depot_stats) { 52 if (prev_reported_stack_depot_size * 11 / 10 < 53 stack_depot_stats->allocated) { 54 Printf("%s: StackDepot: %zd ids; %zdM allocated\n", 55 SanitizerToolName, 56 stack_depot_stats->n_uniq_ids, 57 stack_depot_stats->allocated >> 20); 58 prev_reported_stack_depot_size = stack_depot_stats->allocated; 59 } 60 } 61 } 62 // Check RSS against the limit. 63 if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) { 64 Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n", 65 SanitizerToolName, hard_rss_limit_mb, current_rss_mb); 66 DumpProcessMap(); 67 Die(); 68 } 69 if (soft_rss_limit_mb) { 70 if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) { 71 reached_soft_rss_limit = true; 72 Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n", 73 SanitizerToolName, soft_rss_limit_mb, current_rss_mb); 74 if (SoftRssLimitExceededCallback) 75 SoftRssLimitExceededCallback(true); 76 } else if (soft_rss_limit_mb >= current_rss_mb && 77 reached_soft_rss_limit) { 78 reached_soft_rss_limit = false; 79 if (SoftRssLimitExceededCallback) 80 SoftRssLimitExceededCallback(false); 81 } 82 } 83 if (heap_profile && 84 current_rss_mb > rss_during_last_reported_profile * 1.1) { 85 Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb); 86 __sanitizer_print_memory_profile(90, 20); 87 rss_during_last_reported_profile = current_rss_mb; 88 } 89 } 90 } 91 #endif 92 93 void WriteToSyslog(const char *msg) { 94 InternalScopedString msg_copy(kErrorMessageBufferSize); 95 msg_copy.append("%s", msg); 96 char *p = msg_copy.data(); 97 char *q; 98 99 // Print one line at a time. 100 // syslog, at least on Android, has an implicit message length limit. 101 while ((q = internal_strchr(p, '\n'))) { 102 *q = '\0'; 103 WriteOneLineToSyslog(p); 104 p = q + 1; 105 } 106 // Print remaining characters, if there are any. 107 // Note that this will add an extra newline at the end. 108 // FIXME: buffer extra output. This would need a thread-local buffer, which 109 // on Android requires plugging into the tools (ex. ASan's) Thread class. 110 if (*p) 111 WriteOneLineToSyslog(p); 112 } 113 114 void MaybeStartBackgroudThread() { 115 #if SANITIZER_LINUX && \ 116 !SANITIZER_GO // Need to implement/test on other platforms. 117 // Start the background thread if one of the rss limits is given. 118 if (!common_flags()->hard_rss_limit_mb && 119 !common_flags()->soft_rss_limit_mb && 120 !common_flags()->heap_profile) return; 121 if (!&real_pthread_create) return; // Can't spawn the thread anyway. 122 internal_start_thread(BackgroundThread, nullptr); 123 #endif 124 } 125 126 static void (*sandboxing_callback)(); 127 void SetSandboxingCallback(void (*f)()) { 128 sandboxing_callback = f; 129 } 130 131 } // namespace __sanitizer 132 133 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify, 134 __sanitizer_sandbox_arguments *args) { 135 __sanitizer::PlatformPrepareForSandboxing(args); 136 if (__sanitizer::sandboxing_callback) 137 __sanitizer::sandboxing_callback(); 138 } 139