1 //===-- sanitizer_common_libcdep.cpp --------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file is shared between AddressSanitizer and ThreadSanitizer
10 // run-time libraries.
11 //===----------------------------------------------------------------------===//
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"
21 namespace __sanitizer
{
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 {}; }
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;
38 const uptr current_rss_mb
= GetRSS() >> 20;
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
;
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
;
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
);
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 SetRssLimitExceeded(false);
74 current_rss_mb
> rss_during_last_reported_profile
* 1.1) {
75 Printf("\n\nHEAP PROFILE at RSS %zdMb\n", current_rss_mb
);
76 __sanitizer_print_memory_profile(90, 20);
77 rss_during_last_reported_profile
= current_rss_mb
;
82 void MaybeStartBackgroudThread() {
83 // Need to implement/test on other platforms.
84 // Start the background thread if one of the rss limits is given.
85 if (!common_flags()->hard_rss_limit_mb
&&
86 !common_flags()->soft_rss_limit_mb
&&
87 !common_flags()->heap_profile
) return;
88 if (!&real_pthread_create
) {
89 VPrintf(1, "%s: real_pthread_create undefined\n", SanitizerToolName
);
90 return; // Can't spawn the thread anyway.
93 static bool started
= false;
96 internal_start_thread(BackgroundThread
, nullptr);
100 # if !SANITIZER_START_BACKGROUND_THREAD_IN_ASAN_INTERNAL
102 # pragma clang diagnostic push
103 // We avoid global-constructors to be sure that globals are ready when
104 // sanitizers need them. This can happend before global constructors executed.
105 // Here we don't mind if thread is started on later stages.
106 # pragma clang diagnostic ignored "-Wglobal-constructors"
108 static struct BackgroudThreadStarted
{
109 BackgroudThreadStarted() { MaybeStartBackgroudThread(); }
110 } background_thread_strarter UNUSED
;
112 # pragma clang diagnostic pop
116 void MaybeStartBackgroudThread() {}
119 void WriteToSyslog(const char *msg
) {
120 InternalScopedString msg_copy
;
121 msg_copy
.append("%s", msg
);
122 const char *p
= msg_copy
.data();
124 // Print one line at a time.
125 // syslog, at least on Android, has an implicit message length limit.
126 while (char* q
= internal_strchr(p
, '\n')) {
128 WriteOneLineToSyslog(p
);
131 // Print remaining characters, if there are any.
132 // Note that this will add an extra newline at the end.
133 // FIXME: buffer extra output. This would need a thread-local buffer, which
134 // on Android requires plugging into the tools (ex. ASan's) Thread class.
136 WriteOneLineToSyslog(p
);
139 static void (*sandboxing_callback
)();
140 void SetSandboxingCallback(void (*f
)()) {
141 sandboxing_callback
= f
;
144 uptr
ReservedAddressRange::InitAligned(uptr size
, uptr align
,
146 CHECK(IsPowerOfTwo(align
));
147 if (align
<= GetPageSizeCached())
148 return Init(size
, name
);
149 uptr start
= Init(size
+ align
, name
);
150 start
+= align
- (start
& (align
- 1));
154 #if !SANITIZER_FUCHSIA
156 // Reserve memory range [beg, end].
157 // We need to use inclusive range because end+1 may not be representable.
158 void ReserveShadowMemoryRange(uptr beg
, uptr end
, const char *name
,
159 bool madvise_shadow
) {
160 CHECK_EQ((beg
% GetMmapGranularity()), 0);
161 CHECK_EQ(((end
+ 1) % GetMmapGranularity()), 0);
162 uptr size
= end
- beg
+ 1;
163 DecreaseTotalMmap(size
); // Don't count the shadow against mmap_limit_mb.
164 if (madvise_shadow
? !MmapFixedSuperNoReserve(beg
, size
, name
)
165 : !MmapFixedNoReserve(beg
, size
, name
)) {
167 "ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
168 "Perhaps you're using ulimit -v\n",
172 if (madvise_shadow
&& common_flags()->use_madv_dontdump
)
173 DontDumpShadowMemory(beg
, size
);
176 void ProtectGap(uptr addr
, uptr size
, uptr zero_base_shadow_start
,
177 uptr zero_base_max_shadow_start
) {
180 void *res
= MmapFixedNoAccess(addr
, size
, "shadow gap");
181 if (addr
== (uptr
)res
)
183 // A few pages at the start of the address space can not be protected.
184 // But we really want to protect as much as possible, to prevent this memory
185 // being returned as a result of a non-FIXED mmap().
186 if (addr
== zero_base_shadow_start
) {
187 uptr step
= GetMmapGranularity();
188 while (size
> step
&& addr
< zero_base_max_shadow_start
) {
191 void *res
= MmapFixedNoAccess(addr
, size
, "shadow gap");
192 if (addr
== (uptr
)res
)
198 "ERROR: Failed to protect the shadow gap. "
199 "%s cannot proceed correctly. ABORTING.\n",
205 #endif // !SANITIZER_FUCHSIA
207 #if !SANITIZER_WINDOWS && !SANITIZER_GO
208 // Weak default implementation for when sanitizer_stackdepot is not linked in.
209 SANITIZER_WEAK_ATTRIBUTE
void StackDepotStopBackgroundThread() {}
210 static void StopStackDepotBackgroundThread() {
211 StackDepotStopBackgroundThread();
214 // SANITIZER_WEAK_ATTRIBUTE is unsupported.
215 static void StopStackDepotBackgroundThread() {}
218 } // namespace __sanitizer
220 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_sandbox_on_notify
,
221 __sanitizer_sandbox_arguments
*args
) {
222 __sanitizer::StopStackDepotBackgroundThread();
223 __sanitizer::PlatformPrepareForSandboxing(args
);
224 if (__sanitizer::sandboxing_callback
)
225 __sanitizer::sandboxing_callback();