libsanitizer/sanitizer_common/sanitizer_common_libcdep.cpp

   1 //===-- sanitizer_common_libcdep.cpp --------------------------------------===//
   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() { return {}; }
  30
  31 void *BackgroundThread(void *arg) {
  32   const uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb;
  33   const uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb;
  34   const bool heap_profile = common_flags()->heap_profile;
  35   uptr prev_reported_rss = 0;
  36   uptr prev_reported_stack_depot_size = 0;
  37   bool reached_soft_rss_limit = false;
  38   uptr rss_during_last_reported_profile = 0;
  39   while (true) {
  40     SleepForMillis(100);
  41     const uptr current_rss_mb = GetRSS() >> 20;
  42     if (Verbosity()) {
  43       // If RSS has grown 10% since last time, print some information.
  44       if (prev_reported_rss * 11 / 10 < current_rss_mb) {
  45         Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
  46         prev_reported_rss = current_rss_mb;
  47       }
  48       // If stack depot has grown 10% since last time, print it too.
  49       StackDepotStats stack_depot_stats = StackDepotGetStats();
  50       if (prev_reported_stack_depot_size * 11 / 10 <
  51           stack_depot_stats.allocated) {
  52         Printf("%s: StackDepot: %zd ids; %zdM allocated\n", SanitizerToolName,
  53                stack_depot_stats.n_uniq_ids, stack_depot_stats.allocated >> 20);
  54         prev_reported_stack_depot_size = stack_depot_stats.allocated;
  55       }
  56     }
  57     // Check RSS against the limit.
  58     if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) {
  59       Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n",
  60              SanitizerToolName, hard_rss_limit_mb, current_rss_mb);
  61       DumpProcessMap();
  62       Die();
  63     }
  64     if (soft_rss_limit_mb) {
  65       if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) {
  66         reached_soft_rss_limit = true;
  67         Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n",
  68                SanitizerToolName, soft_rss_limit_mb, current_rss_mb);
  69         if (SoftRssLimitExceededCallback)
  70           SoftRssLimitExceededCallback(true);
  71       } else if (soft_rss_limit_mb >= current_rss_mb &&
  72                  reached_soft_rss_limit) {
  73         reached_soft_rss_limit = false;
  74         if (SoftRssLimitExceededCallback)
  75           SoftRssLimitExceededCallback(false);
  76       }
  77     }
  78     if (heap_profile &&
  79         current_rss_mb > rss_during_last_reported_profile * 1.1) {
  80       Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb);
  81       __sanitizer_print_memory_profile(90, 20);
  82       rss_during_last_reported_profile = current_rss_mb;
  83     }
  84   }
  85 }
  86 #endif
  87
  88 void WriteToSyslog(const char *msg) {
  89   InternalScopedString msg_copy;
  90   msg_copy.append("%s", msg);
  91   const char *p = msg_copy.data();
  92
  93   // Print one line at a time.
  94   // syslog, at least on Android, has an implicit message length limit.
  95   while (char* q = internal_strchr(p, '\n')) {
  96     *q = '\0';
  97     WriteOneLineToSyslog(p);
  98     p = q + 1;
  99   }
 100   // Print remaining characters, if there are any.
 101   // Note that this will add an extra newline at the end.
 102   // FIXME: buffer extra output. This would need a thread-local buffer, which
 103   // on Android requires plugging into the tools (ex. ASan's) Thread class.
 104   if (*p)
 105     WriteOneLineToSyslog(p);
 106 }
 107
 108 void MaybeStartBackgroudThread() {
 109 #if (SANITIZER_LINUX || SANITIZER_NETBSD) && \
 110     !SANITIZER_GO  // Need to implement/test on other platforms.
 111   // Start the background thread if one of the rss limits is given.
 112   if (!common_flags()->hard_rss_limit_mb &&
 113       !common_flags()->soft_rss_limit_mb &&
 114       !common_flags()->heap_profile) return;
 115   if (!&real_pthread_create) return;  // Can't spawn the thread anyway.
 116   internal_start_thread(BackgroundThread, nullptr);
 117 #endif
 118 }
 119
 120 static void (*sandboxing_callback)();
 121 void SetSandboxingCallback(void (*f)()) {
 122   sandboxing_callback = f;
 123 }
 124
 125 uptr ReservedAddressRange::InitAligned(uptr size, uptr align,
 126                                        const char *name) {
 127   CHECK(IsPowerOfTwo(align));
 128   if (align <= GetPageSizeCached())
 129     return Init(size, name);
 130   uptr start = Init(size + align, name);
 131   start += align - (start & (align - 1));
 132   return start;
 133 }
 134
 135 #if !SANITIZER_FUCHSIA
 136
 137 // Reserve memory range [beg, end].
 138 // We need to use inclusive range because end+1 may not be representable.
 139 void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name,
 140                               bool madvise_shadow) {
 141   CHECK_EQ((beg % GetMmapGranularity()), 0);
 142   CHECK_EQ(((end + 1) % GetMmapGranularity()), 0);
 143   uptr size = end - beg + 1;
 144   DecreaseTotalMmap(size);  // Don't count the shadow against mmap_limit_mb.
 145   if (madvise_shadow ? !MmapFixedSuperNoReserve(beg, size, name)
 146                      : !MmapFixedNoReserve(beg, size, name)) {
 147     Report(
 148         "ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
 149         "Perhaps you're using ulimit -v\n",
 150         size);
 151     Abort();
 152   }
 153   if (madvise_shadow && common_flags()->use_madv_dontdump)
 154     DontDumpShadowMemory(beg, size);
 155 }
 156
 157 void ProtectGap(uptr addr, uptr size, uptr zero_base_shadow_start,
 158                 uptr zero_base_max_shadow_start) {
 159   if (!size)
 160     return;
 161   void *res = MmapFixedNoAccess(addr, size, "shadow gap");
 162   if (addr == (uptr)res)
 163     return;
 164   // A few pages at the start of the address space can not be protected.
 165   // But we really want to protect as much as possible, to prevent this memory
 166   // being returned as a result of a non-FIXED mmap().
 167   if (addr == zero_base_shadow_start) {
 168     uptr step = GetMmapGranularity();
 169     while (size > step && addr < zero_base_max_shadow_start) {
 170       addr += step;
 171       size -= step;
 172       void *res = MmapFixedNoAccess(addr, size, "shadow gap");
 173       if (addr == (uptr)res)
 174         return;
 175     }
 176   }
 177
 178   Report(
 179       "ERROR: Failed to protect the shadow gap. "
 180       "%s cannot proceed correctly. ABORTING.\n",
 181       SanitizerToolName);
 182   DumpProcessMap();
 183   Die();
 184 }
 185
 186 #endif  // !SANITIZER_FUCHSIA
 187
 188 }  // namespace __sanitizer
 189
 190 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify,
 191                              __sanitizer_sandbox_arguments *args) {
 192   __sanitizer::PlatformPrepareForSandboxing(args);
 193   if (__sanitizer::sandboxing_callback)
 194     __sanitizer::sandboxing_callback();
 195 }