| 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.h" |
| 14 |
#include "sanitizer_allocator_interface.h" |
| 15 |
#include "sanitizer_common.h" |
| 16 |
#include "sanitizer_flags.h" |
| 17 |
#include "sanitizer_interface_internal.h" |
| 18 |
#include "sanitizer_procmaps.h" |
| 19 |
#include "sanitizer_stackdepot.h" |
| 20 |
|
| 21 |
namespace __sanitizer { |
| 22 |
|
| 23 |
#if (SANITIZER_LINUX || SANITIZER_NETBSD) && !SANITIZER_GO |
| 24 |
// Weak default implementation for when sanitizer_stackdepot is not linked in. |
| 25 |
SANITIZER_WEAK_ATTRIBUTE StackDepotStats StackDepotGetStats() { return {}; } |
| 26 |
|
| 27 |
void *BackgroundThread(void *arg) { |
| 28 |
VPrintf(1, "%s: Started BackgroundThread\n", SanitizerToolName); |
| 29 |
const uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb; |
| 30 |
const uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb; |
| 31 |
const bool heap_profile = common_flags()->heap_profile; |
| 32 |
uptr prev_reported_rss = 0; |
| 33 |
uptr prev_reported_stack_depot_size = 0; |
| 34 |
bool reached_soft_rss_limit = false; |
| 35 |
uptr rss_during_last_reported_profile = 0; |
| 36 |
while (true) { |
| 37 |
SleepForMillis(100); |
| 38 |
const uptr current_rss_mb = GetRSS() >> 20; |
| 39 |
if (Verbosity()) { |
| 40 |
// If RSS has grown 10% since last time, print some information. |
| 41 |
if (prev_reported_rss * 11 / 10 < current_rss_mb) { |
| 42 |
Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb); |
| 43 |
prev_reported_rss = current_rss_mb; |
| 44 |
} |
| 45 |
// If stack depot has grown 10% since last time, print it too. |
| 46 |
StackDepotStats stack_depot_stats = StackDepotGetStats(); |
| 47 |
if (prev_reported_stack_depot_size * 11 / 10 < |
| 48 |
stack_depot_stats.allocated) { |
| 49 |
Printf("%s: StackDepot: %zd ids; %zdM allocated\n", SanitizerToolName, |
| 50 |
stack_depot_stats.n_uniq_ids, stack_depot_stats.allocated >> 20); |
| 51 |
prev_reported_stack_depot_size = stack_depot_stats.allocated; |
| 52 |
} |
| 53 |
} |
| 54 |
// Check RSS against the limit. |
| 55 |
if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) { |
| 56 |
Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n", |
| 57 |
SanitizerToolName, hard_rss_limit_mb, current_rss_mb); |
| 58 |
DumpProcessMap(); |
| 59 |
Die(); |
| 60 |
} |
| 61 |
if (soft_rss_limit_mb) { |
| 62 |
if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) { |
| 63 |
reached_soft_rss_limit = true; |
| 64 |
Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n", |
| 65 |
SanitizerToolName, soft_rss_limit_mb, current_rss_mb); |
| 66 |
SetRssLimitExceeded(true); |
| 67 |
} else if (soft_rss_limit_mb >= current_rss_mb && |
| 68 |
reached_soft_rss_limit) { |
| 69 |
reached_soft_rss_limit = false; |
| 70 |
Report("%s: soft rss limit unexhausted (%zdMb vs %zdMb)\n", |
| 71 |
SanitizerToolName, soft_rss_limit_mb, current_rss_mb); |
| 72 |
SetRssLimitExceeded(false); |
| 73 |
} |
| 74 |
} |
| 75 |
if (heap_profile && |
| 76 |
current_rss_mb > rss_during_last_reported_profile * 1.1) { |
| 77 |
Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb); |
| 78 |
__sanitizer_print_memory_profile(90, 20); |
| 79 |
rss_during_last_reported_profile = current_rss_mb; |
| 80 |
} |
| 81 |
} |
| 82 |
} |
| 83 |
|
| 84 |
void MaybeStartBackgroudThread() { |
| 85 |
// Need to implement/test on other platforms. |
| 86 |
// Start the background thread if one of the rss limits is given. |
| 87 |
if (!common_flags()->hard_rss_limit_mb && |
| 88 |
!common_flags()->soft_rss_limit_mb && |
| 89 |
!common_flags()->heap_profile) return; |
| 90 |
if (!&internal_pthread_create) { |
| 91 |
VPrintf(1, "%s: internal_pthread_create undefined\n", SanitizerToolName); |
| 92 |
return; // Can't spawn the thread anyway. |
| 93 |
} |
| 94 |
|
| 95 |
static bool started = false; |
| 96 |
if (!started) { |
| 97 |
started = true; |
| 98 |
internal_start_thread(BackgroundThread, nullptr); |
| 99 |
} |
| 100 |
} |
| 101 |
|
| 102 |
# if !SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL |
| 103 |
# ifdef __clang__ |
| 104 |
# pragma clang diagnostic push |
| 105 |
// We avoid global-constructors to be sure that globals are ready when |
| 106 |
// sanitizers need them. This can happend before global constructors executed. |
| 107 |
// Here we don't mind if thread is started on later stages. |
| 108 |
# pragma clang diagnostic ignored "-Wglobal-constructors" |
| 109 |
# endif |
| 110 |
static struct BackgroudThreadStarted { |
| 111 |
BackgroudThreadStarted() { MaybeStartBackgroudThread(); } |
| 112 |
} background_thread_strarter UNUSED; |
| 113 |
# ifdef __clang__ |
| 114 |
# pragma clang diagnostic pop |
| 115 |
# endif |
| 116 |
# endif |
| 117 |
#else |
| 118 |
void MaybeStartBackgroudThread() {} |
| 119 |
#endif |
| 120 |
|
| 121 |
void WriteToSyslog(const char *msg) { |
| 122 |
if (!msg) |
| 123 |
return; |
| 124 |
InternalScopedString msg_copy; |
| 125 |
msg_copy.Append(msg); |
| 126 |
const char *p = msg_copy.data(); |
| 127 |
|
| 128 |
// Print one line at a time. |
| 129 |
// syslog, at least on Android, has an implicit message length limit. |
| 130 |
while (char* q = internal_strchr(p, '\n')) { |
| 131 |
*q = '\0'; |
| 132 |
WriteOneLineToSyslog(p); |
| 133 |
p = q + 1; |
| 134 |
} |
| 135 |
// Print remaining characters, if there are any. |
| 136 |
// Note that this will add an extra newline at the end. |
| 137 |
// FIXME: buffer extra output. This would need a thread-local buffer, which |
| 138 |
// on Android requires plugging into the tools (ex. ASan's) Thread class. |
| 139 |
if (*p) |
| 140 |
WriteOneLineToSyslog(p); |
| 141 |
} |
| 142 |
|
| 143 |
static void (*sandboxing_callback)(); |
| 144 |
void SetSandboxingCallback(void (*f)()) { |
| 145 |
sandboxing_callback = f; |
| 146 |
} |
| 147 |
|
| 148 |
uptr ReservedAddressRange::InitAligned(uptr size, uptr align, |
| 149 |
const char *name) { |
| 150 |
CHECK(IsPowerOfTwo(align)); |
| 151 |
if (align <= GetPageSizeCached()) |
| 152 |
return Init(size, name); |
| 153 |
uptr start = Init(size + align, name); |
| 154 |
start += align - (start & (align - 1)); |
| 155 |
return start; |
| 156 |
} |
| 157 |
|
| 158 |
#if !SANITIZER_FUCHSIA |
| 159 |
|
| 160 |
// Reserve memory range [beg, end]. |
| 161 |
// We need to use inclusive range because end+1 may not be representable. |
| 162 |
void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name, |
| 163 |
bool madvise_shadow) { |
| 164 |
CHECK_EQ((beg % GetMmapGranularity()), 0); |
| 165 |
CHECK_EQ(((end + 1) % GetMmapGranularity()), 0); |
| 166 |
uptr size = end - beg + 1; |
| 167 |
DecreaseTotalMmap(size); // Don't count the shadow against mmap_limit_mb. |
| 168 |
if (madvise_shadow ? !MmapFixedSuperNoReserve(beg, size, name) |
| 169 |
: !MmapFixedNoReserve(beg, size, name)) { |
| 170 |
Report( |
| 171 |
"ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. " |
| 172 |
"Perhaps you're using ulimit -v or ulimit -d\n", |
| 173 |
size); |
| 174 |
Die(); |
| 175 |
} |
| 176 |
if (madvise_shadow && common_flags()->use_madv_dontdump) |
| 177 |
DontDumpShadowMemory(beg, size); |
| 178 |
} |
| 179 |
|
| 180 |
void ProtectGap(uptr addr, uptr size, uptr zero_base_shadow_start, |
| 181 |
uptr zero_base_max_shadow_start) { |
| 182 |
if (!size) |
| 183 |
return; |
| 184 |
void *res = MmapFixedNoAccess(addr, size, "shadow gap"); |
| 185 |
if (addr == (uptr)res) |
| 186 |
return; |
| 187 |
// A few pages at the start of the address space can not be protected. |
| 188 |
// But we really want to protect as much as possible, to prevent this memory |
| 189 |
// being returned as a result of a non-FIXED mmap(). |
| 190 |
if (addr == zero_base_shadow_start) { |
| 191 |
uptr step = GetMmapGranularity(); |
| 192 |
while (size > step && addr < zero_base_max_shadow_start) { |
| 193 |
addr += step; |
| 194 |
size -= step; |
| 195 |
void *res = MmapFixedNoAccess(addr, size, "shadow gap"); |
| 196 |
if (addr == (uptr)res) |
| 197 |
return; |
| 198 |
} |
| 199 |
} |
| 200 |
|
| 201 |
Report( |
| 202 |
"ERROR: Failed to protect the shadow gap. " |
| 203 |
"%s cannot proceed correctly. ABORTING.\n", |
| 204 |
SanitizerToolName); |
| 205 |
DumpProcessMap(); |
| 206 |
Die(); |
| 207 |
} |
| 208 |
|
| 209 |
#endif // !SANITIZER_FUCHSIA |
| 210 |
|
| 211 |
#if !SANITIZER_WINDOWS && !SANITIZER_GO |
| 212 |
// Weak default implementation for when sanitizer_stackdepot is not linked in. |
| 213 |
SANITIZER_WEAK_ATTRIBUTE void StackDepotStopBackgroundThread() {} |
| 214 |
static void StopStackDepotBackgroundThread() { |
| 215 |
StackDepotStopBackgroundThread(); |
| 216 |
} |
| 217 |
#else |
| 218 |
// SANITIZER_WEAK_ATTRIBUTE is unsupported. |
| 219 |
static void StopStackDepotBackgroundThread() {} |
| 220 |
#endif |
| 221 |
|
| 222 |
void MemCpyAccessible(void *dest, const void *src, uptr n) { |
| 223 |
if (TryMemCpy(dest, src, n)) |
| 224 |
return; |
| 225 |
|
| 226 |
const uptr page_size = GetPageSize(); |
| 227 |
uptr b = reinterpret_cast<uptr>(src); |
| 228 |
uptr b_up = RoundUpTo(b, page_size); |
| 229 |
|
| 230 |
uptr e = reinterpret_cast<uptr>(src) + n; |
| 231 |
uptr e_down = RoundDownTo(e, page_size); |
| 232 |
|
| 233 |
auto copy_or_zero = [dest, src](uptr beg, uptr end) { |
| 234 |
const uptr udest = reinterpret_cast<uptr>(dest); |
| 235 |
const uptr usrc = reinterpret_cast<uptr>(src); |
| 236 |
void *d = reinterpret_cast<void *>(udest + (beg - usrc)); |
| 237 |
const uptr size = end - beg; |
| 238 |
if (!TryMemCpy(d, reinterpret_cast<void *>(beg), size)) |
| 239 |
internal_memset(d, 0, size); |
| 240 |
}; |
| 241 |
|
| 242 |
copy_or_zero(b, b_up); |
| 243 |
for (uptr p = b_up; p < e_down; p += page_size) |
| 244 |
copy_or_zero(p, p + page_size); |
| 245 |
copy_or_zero(e_down, e); |
| 246 |
} |
| 247 |
|
| 248 |
} // namespace __sanitizer |
| 249 |
|
| 250 |
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify, |
| 251 |
__sanitizer_sandbox_arguments *args) { |
| 252 |
__sanitizer::StopStackDepotBackgroundThread(); |
| 253 |
__sanitizer::PlatformPrepareForSandboxing(args); |
| 254 |
if (__sanitizer::sandboxing_callback) |
| 255 |
__sanitizer::sandboxing_callback(); |
| 256 |
} |