contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc

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