src/compiler-rt/lib/sanitizer_common/sanitizer_common_libcdep.cc

   1 //===-- sanitizer_common_libcdep.cc ---------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is shared between AddressSanitizer and ThreadSanitizer
  11 // run-time libraries.
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "sanitizer_common.h"
  15 #include "sanitizer_flags.h"
  16 #include "sanitizer_stackdepot.h"
  17 #include "sanitizer_stacktrace.h"
  18 #include "sanitizer_symbolizer.h"
  19
  20 #if SANITIZER_POSIX
  21 #include "sanitizer_posix.h"
  22 #endif
  23
  24 namespace __sanitizer {
  25
  26 bool ReportFile::SupportsColors() {
  27   SpinMutexLock l(mu);
  28   ReopenIfNecessary();
  29   return SupportsColoredOutput(fd);
  30 }
  31
  32 bool ColorizeReports() {
  33   // FIXME: Add proper Windows support to AnsiColorDecorator and re-enable color
  34   // printing on Windows.
  35   if (SANITIZER_WINDOWS)
  36     return false;
  37
  38   const char *flag = common_flags()->color;
  39   return internal_strcmp(flag, "always") == 0 ||
  40          (internal_strcmp(flag, "auto") == 0 && report_file.SupportsColors());
  41 }
  42
  43 static void (*sandboxing_callback)();
  44 void SetSandboxingCallback(void (*f)()) {
  45   sandboxing_callback = f;
  46 }
  47
  48 void ReportErrorSummary(const char *error_type, StackTrace *stack) {
  49   if (!common_flags()->print_summary)
  50     return;
  51   if (stack->size == 0) {
  52     ReportErrorSummary(error_type);
  53     return;
  54   }
  55   // Currently, we include the first stack frame into the report summary.
  56   // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc).
  57   uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
  58   SymbolizedStack *frame = Symbolizer::GetOrInit()->SymbolizePC(pc);
  59   ReportErrorSummary(error_type, frame->info);
  60   frame->ClearAll();
  61 }
  62
  63 static void (*SoftRssLimitExceededCallback)(bool exceeded);
  64 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) {
  65   CHECK_EQ(SoftRssLimitExceededCallback, nullptr);
  66   SoftRssLimitExceededCallback = Callback;
  67 }
  68
  69 void BackgroundThread(void *arg) {
  70   uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb;
  71   uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb;
  72   uptr prev_reported_rss = 0;
  73   uptr prev_reported_stack_depot_size = 0;
  74   bool reached_soft_rss_limit = false;
  75   while (true) {
  76     SleepForMillis(100);
  77     uptr current_rss_mb = GetRSS() >> 20;
  78     if (Verbosity()) {
  79       // If RSS has grown 10% since last time, print some information.
  80       if (prev_reported_rss * 11 / 10 < current_rss_mb) {
  81         Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
  82         prev_reported_rss = current_rss_mb;
  83       }
  84       // If stack depot has grown 10% since last time, print it too.
  85       StackDepotStats *stack_depot_stats = StackDepotGetStats();
  86       if (prev_reported_stack_depot_size * 11 / 10 <
  87           stack_depot_stats->allocated) {
  88         Printf("%s: StackDepot: %zd ids; %zdM allocated\n",
  89                SanitizerToolName,
  90                stack_depot_stats->n_uniq_ids,
  91                stack_depot_stats->allocated >> 20);
  92         prev_reported_stack_depot_size = stack_depot_stats->allocated;
  93       }
  94     }
  95     // Check RSS against the limit.
  96     if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) {
  97       Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n",
  98              SanitizerToolName, hard_rss_limit_mb, current_rss_mb);
  99       DumpProcessMap();
 100       Die();
 101     }
 102     if (soft_rss_limit_mb) {
 103       if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) {
 104         reached_soft_rss_limit = true;
 105         Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n",
 106                SanitizerToolName, soft_rss_limit_mb, current_rss_mb);
 107         if (SoftRssLimitExceededCallback)
 108           SoftRssLimitExceededCallback(true);
 109       } else if (soft_rss_limit_mb >= current_rss_mb &&
 110                  reached_soft_rss_limit) {
 111         reached_soft_rss_limit = false;
 112         if (SoftRssLimitExceededCallback)
 113           SoftRssLimitExceededCallback(false);
 114       }
 115     }
 116   }
 117 }
 118
 119 void MaybeStartBackgroudThread() {
 120 #if SANITIZER_LINUX  // Need to implement/test on other platforms.
 121   // Start the background thread if one of the rss limits is given.
 122   if (!common_flags()->hard_rss_limit_mb &&
 123       !common_flags()->soft_rss_limit_mb) return;
 124   if (!&real_pthread_create) return;  // Can't spawn the thread anyway.
 125   internal_start_thread(BackgroundThread, nullptr);
 126 #endif
 127 }
 128
 129 }  // namespace __sanitizer
 130
 131 void NOINLINE
 132 __sanitizer_sandbox_on_notify(__sanitizer_sandbox_arguments *args) {
 133   PrepareForSandboxing(args);
 134   if (sandboxing_callback)
 135     sandboxing_callback();
 136 }