203 lines
7.2 KiB
C++
203 lines
7.2 KiB
C++
//===-- sanitizer_common_libcdep.cpp --------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file is shared between AddressSanitizer and ThreadSanitizer
|
|
// run-time libraries.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "sanitizer_allocator_interface.h"
|
|
#include "sanitizer_common.h"
|
|
#include "sanitizer_flags.h"
|
|
#include "sanitizer_procmaps.h"
|
|
|
|
|
|
namespace __sanitizer {
|
|
|
|
static void (*SoftRssLimitExceededCallback)(bool exceeded);
|
|
void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded)) {
|
|
CHECK_EQ(SoftRssLimitExceededCallback, nullptr);
|
|
SoftRssLimitExceededCallback = Callback;
|
|
}
|
|
|
|
#if (SANITIZER_LINUX || SANITIZER_NETBSD) && !SANITIZER_GO
|
|
// Weak default implementation for when sanitizer_stackdepot is not linked in.
|
|
SANITIZER_WEAK_ATTRIBUTE StackDepotStats *StackDepotGetStats() {
|
|
return nullptr;
|
|
}
|
|
|
|
void *BackgroundThread(void *arg) {
|
|
const uptr hard_rss_limit_mb = common_flags()->hard_rss_limit_mb;
|
|
const uptr soft_rss_limit_mb = common_flags()->soft_rss_limit_mb;
|
|
const bool heap_profile = common_flags()->heap_profile;
|
|
uptr prev_reported_rss = 0;
|
|
uptr prev_reported_stack_depot_size = 0;
|
|
bool reached_soft_rss_limit = false;
|
|
uptr rss_during_last_reported_profile = 0;
|
|
while (true) {
|
|
SleepForMillis(100);
|
|
const uptr current_rss_mb = GetRSS() >> 20;
|
|
if (Verbosity()) {
|
|
// If RSS has grown 10% since last time, print some information.
|
|
if (prev_reported_rss * 11 / 10 < current_rss_mb) {
|
|
Printf("%s: RSS: %zdMb\n", SanitizerToolName, current_rss_mb);
|
|
prev_reported_rss = current_rss_mb;
|
|
}
|
|
// If stack depot has grown 10% since last time, print it too.
|
|
StackDepotStats *stack_depot_stats = StackDepotGetStats();
|
|
if (stack_depot_stats) {
|
|
if (prev_reported_stack_depot_size * 11 / 10 <
|
|
stack_depot_stats->allocated) {
|
|
Printf("%s: StackDepot: %zd ids; %zdM allocated\n",
|
|
SanitizerToolName,
|
|
stack_depot_stats->n_uniq_ids,
|
|
stack_depot_stats->allocated >> 20);
|
|
prev_reported_stack_depot_size = stack_depot_stats->allocated;
|
|
}
|
|
}
|
|
}
|
|
// Check RSS against the limit.
|
|
if (hard_rss_limit_mb && hard_rss_limit_mb < current_rss_mb) {
|
|
Report("%s: hard rss limit exhausted (%zdMb vs %zdMb)\n",
|
|
SanitizerToolName, hard_rss_limit_mb, current_rss_mb);
|
|
DumpProcessMap();
|
|
Die();
|
|
}
|
|
if (soft_rss_limit_mb) {
|
|
if (soft_rss_limit_mb < current_rss_mb && !reached_soft_rss_limit) {
|
|
reached_soft_rss_limit = true;
|
|
Report("%s: soft rss limit exhausted (%zdMb vs %zdMb)\n",
|
|
SanitizerToolName, soft_rss_limit_mb, current_rss_mb);
|
|
if (SoftRssLimitExceededCallback)
|
|
SoftRssLimitExceededCallback(true);
|
|
} else if (soft_rss_limit_mb >= current_rss_mb &&
|
|
reached_soft_rss_limit) {
|
|
reached_soft_rss_limit = false;
|
|
if (SoftRssLimitExceededCallback)
|
|
SoftRssLimitExceededCallback(false);
|
|
}
|
|
}
|
|
if (heap_profile &&
|
|
current_rss_mb > rss_during_last_reported_profile * 1.1) {
|
|
Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb);
|
|
__sanitizer_print_memory_profile(90, 20);
|
|
rss_during_last_reported_profile = current_rss_mb;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void WriteToSyslog(const char *msg) {
|
|
InternalScopedString msg_copy(kErrorMessageBufferSize);
|
|
msg_copy.append("%s", msg);
|
|
char *p = msg_copy.data();
|
|
char *q;
|
|
|
|
// Print one line at a time.
|
|
// syslog, at least on Android, has an implicit message length limit.
|
|
while ((q = internal_strchr(p, '\n'))) {
|
|
*q = '\0';
|
|
WriteOneLineToSyslog(p);
|
|
p = q + 1;
|
|
}
|
|
// Print remaining characters, if there are any.
|
|
// Note that this will add an extra newline at the end.
|
|
// FIXME: buffer extra output. This would need a thread-local buffer, which
|
|
// on Android requires plugging into the tools (ex. ASan's) Thread class.
|
|
if (*p)
|
|
WriteOneLineToSyslog(p);
|
|
}
|
|
|
|
void MaybeStartBackgroudThread() {
|
|
#if (SANITIZER_LINUX || SANITIZER_NETBSD) && \
|
|
!SANITIZER_GO // Need to implement/test on other platforms.
|
|
// Start the background thread if one of the rss limits is given.
|
|
if (!common_flags()->hard_rss_limit_mb &&
|
|
!common_flags()->soft_rss_limit_mb &&
|
|
!common_flags()->heap_profile) return;
|
|
if (!&real_pthread_create) return; // Can't spawn the thread anyway.
|
|
internal_start_thread(BackgroundThread, nullptr);
|
|
#endif
|
|
}
|
|
|
|
static void (*sandboxing_callback)();
|
|
void SetSandboxingCallback(void (*f)()) {
|
|
sandboxing_callback = f;
|
|
}
|
|
|
|
uptr ReservedAddressRange::InitAligned(uptr size, uptr align,
|
|
const char *name) {
|
|
CHECK(IsPowerOfTwo(align));
|
|
if (align <= GetPageSizeCached())
|
|
return Init(size, name);
|
|
uptr start = Init(size + align, name);
|
|
start += align - (start & (align - 1));
|
|
return start;
|
|
}
|
|
|
|
#if !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
|
|
|
|
// Reserve memory range [beg, end].
|
|
// We need to use inclusive range because end+1 may not be representable.
|
|
void ReserveShadowMemoryRange(uptr beg, uptr end, const char *name,
|
|
bool madvise_shadow) {
|
|
CHECK_EQ((beg % GetMmapGranularity()), 0);
|
|
CHECK_EQ(((end + 1) % GetMmapGranularity()), 0);
|
|
uptr size = end - beg + 1;
|
|
DecreaseTotalMmap(size); // Don't count the shadow against mmap_limit_mb.
|
|
if (madvise_shadow ? !MmapFixedSuperNoReserve(beg, size, name)
|
|
: !MmapFixedNoReserve(beg, size, name)) {
|
|
Report(
|
|
"ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
|
|
"Perhaps you're using ulimit -v\n",
|
|
size);
|
|
Abort();
|
|
}
|
|
if (madvise_shadow && common_flags()->use_madv_dontdump)
|
|
DontDumpShadowMemory(beg, size);
|
|
}
|
|
|
|
void ProtectGap(uptr addr, uptr size, uptr zero_base_shadow_start,
|
|
uptr zero_base_max_shadow_start) {
|
|
if (!size)
|
|
return;
|
|
void *res = MmapFixedNoAccess(addr, size, "shadow gap");
|
|
if (addr == (uptr)res)
|
|
return;
|
|
// A few pages at the start of the address space can not be protected.
|
|
// But we really want to protect as much as possible, to prevent this memory
|
|
// being returned as a result of a non-FIXED mmap().
|
|
if (addr == zero_base_shadow_start) {
|
|
uptr step = GetMmapGranularity();
|
|
while (size > step && addr < zero_base_max_shadow_start) {
|
|
addr += step;
|
|
size -= step;
|
|
void *res = MmapFixedNoAccess(addr, size, "shadow gap");
|
|
if (addr == (uptr)res)
|
|
return;
|
|
}
|
|
}
|
|
|
|
Report(
|
|
"ERROR: Failed to protect the shadow gap. "
|
|
"%s cannot proceed correctly. ABORTING.\n",
|
|
SanitizerToolName);
|
|
DumpProcessMap();
|
|
Die();
|
|
}
|
|
|
|
#endif // !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
|
|
|
|
} // namespace __sanitizer
|
|
|
|
SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify,
|
|
__sanitizer_sandbox_arguments *args) {
|
|
__sanitizer::PlatformPrepareForSandboxing(args);
|
|
if (__sanitizer::sandboxing_callback)
|
|
__sanitizer::sandboxing_callback();
|
|
}
|