1//===-- asan_fake_stack.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 a part of AddressSanitizer, an address sanity checker.
10//
11// FakeStack is used to detect use-after-return bugs.
12//===----------------------------------------------------------------------===//
13
14#include "asan_allocator.h"
15#include "asan_poisoning.h"
16#include "asan_thread.h"
17
18namespace __asan {
19
20static const u64 kMagic1 = kAsanStackAfterReturnMagic;
21static const u64 kMagic2 = (kMagic1 << 8) | kMagic1;
22static const u64 kMagic4 = (kMagic2 << 16) | kMagic2;
23static const u64 kMagic8 = (kMagic4 << 32) | kMagic4;
24
25static const u64 kAllocaRedzoneSize = 32UL;
26static const u64 kAllocaRedzoneMask = 31UL;
27
28// For small size classes inline PoisonShadow for better performance.
29ALWAYS_INLINE void SetShadow(uptr ptr, uptr size, uptr class_id, u64 magic) {
30 CHECK(AddrIsAlignedByGranularity(ptr + size));
31 u64* shadow = reinterpret_cast<u64*>(MemToShadow(p: ptr));
32 if (ASAN_SHADOW_SCALE == 3 && class_id <= 6) {
33 // This code expects ASAN_SHADOW_SCALE=3.
34 for (uptr i = 0; i < (((uptr)1) << class_id); i++) {
35 shadow[i] = magic;
36 // Make sure this does not become memset.
37 SanitizerBreakOptimization(arg: nullptr);
38 }
39 } else {
40 // The size class is too big, it's cheaper to poison only size bytes.
41 PoisonShadow(addr: ptr, size, value: static_cast<u8>(magic));
42 }
43
44 if (magic == 0) {
45 uptr redzone_size = FakeStack::BytesInSizeClass(class_id) - size;
46 PoisonShadow(addr: ptr + size, size: redzone_size, value: kAsanStackRightRedzoneMagic);
47 }
48}
49
50FakeStack* FakeStack::Create(uptr stack_size_log) {
51 static uptr kMinStackSizeLog = 16;
52 static uptr kMaxStackSizeLog = FIRST_32_SECOND_64(24, 28);
53 if (stack_size_log < kMinStackSizeLog)
54 stack_size_log = kMinStackSizeLog;
55 if (stack_size_log > kMaxStackSizeLog)
56 stack_size_log = kMaxStackSizeLog;
57 CHECK_LE(kMaxStackFrameSizeLog, stack_size_log);
58 uptr size = RequiredSize(stack_size_log);
59 uptr padded_size = size + kMaxStackFrameSize;
60 void* true_res = reinterpret_cast<void*>(
61 flags()->uar_noreserve ? MmapNoReserveOrDie(size: padded_size, mem_type: "FakeStack")
62 : MmapOrDie(size: padded_size, mem_type: "FakeStack"));
63 // GetFrame() requires the property that
64 // (res + kFlagsOffset + SizeRequiredForFlags(stack_size_log)) is aligned to
65 // kMaxStackFrameSize.
66 // We didn't use MmapAlignedOrDieOnFatalError, because it requires that the
67 // *size* is a power of 2, which is an overly strong condition.
68 static_assert(alignof(FakeStack) <= kMaxStackFrameSize);
69 FakeStack* res = reinterpret_cast<FakeStack*>(
70 RoundUpTo(
71 size: (uptr)true_res + kFlagsOffset + SizeRequiredForFlags(stack_size_log),
72 boundary: kMaxStackFrameSize) -
73 kFlagsOffset - SizeRequiredForFlags(stack_size_log));
74 res->true_start = true_res;
75 res->stack_size_log_ = stack_size_log;
76 u8* p = reinterpret_cast<u8*>(res);
77 VReport(1,
78 "T%d: FakeStack created: %p -- %p stack_size_log: %zd; "
79 "mmapped %zdK, noreserve=%d, true_start: %p, start of first frame: "
80 "%p\n",
81 GetCurrentTidOrInvalid(), (void*)p,
82 (void*)(p + FakeStack::RequiredSize(stack_size_log)), stack_size_log,
83 size >> 10, flags()->uar_noreserve, res->true_start,
84 (void*)res->GetFrame(stack_size_log, /*class_id*/ 0, /*pos*/ 0));
85 return res;
86}
87
88void FakeStack::Destroy(int tid) {
89 PoisonAll(magic: 0);
90 if (Verbosity() >= 2) {
91 InternalScopedString str;
92 for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++)
93 str.AppendF(format: "%zd: %zd/%zd; ", class_id, hint_position_[class_id],
94 NumberOfFrames(stack_size_log: stack_size_log(), class_id));
95 Report(format: "T%d: FakeStack destroyed: %s\n", tid, str.data());
96 }
97 uptr size = RequiredSize(stack_size_log: stack_size_log_);
98 uptr padded_size = size + kMaxStackFrameSize;
99 FlushUnneededASanShadowMemory(p: reinterpret_cast<uptr>(true_start),
100 size: padded_size);
101 UnmapOrDie(addr: true_start, size: padded_size);
102}
103
104void FakeStack::PoisonAll(u8 magic) {
105 PoisonShadow(addr: reinterpret_cast<uptr>(this), size: RequiredSize(stack_size_log: stack_size_log()),
106 value: magic);
107}
108
109#if !defined(_MSC_VER) || defined(__clang__)
110ALWAYS_INLINE USED
111#endif
112 FakeFrame* FakeStack::Allocate(uptr stack_size_log, uptr class_id,
113 uptr real_stack) {
114 CHECK_LT(class_id, kNumberOfSizeClasses);
115 if (needs_gc_)
116 GC(real_stack);
117 uptr& hint_position = hint_position_[class_id];
118 const int num_iter = NumberOfFrames(stack_size_log, class_id);
119 u8* flags = GetFlags(stack_size_log, class_id);
120 for (int i = 0; i < num_iter; i++) {
121 uptr pos = ModuloNumberOfFrames(stack_size_log, class_id, n: hint_position++);
122 // This part is tricky. On one hand, checking and setting flags[pos]
123 // should be atomic to ensure async-signal safety. But on the other hand,
124 // if the signal arrives between checking and setting flags[pos], the
125 // signal handler's fake stack will start from a different hint_position
126 // and so will not touch this particular byte. So, it is safe to do this
127 // with regular non-atomic load and store (at least I was not able to make
128 // this code crash).
129 if (flags[pos])
130 continue;
131 flags[pos] = 1;
132 FakeFrame* res =
133 reinterpret_cast<FakeFrame*>(GetFrame(stack_size_log, class_id, pos));
134 res->real_stack = real_stack;
135 *SavedFlagPtr(x: reinterpret_cast<uptr>(res), class_id) = &flags[pos];
136 return res;
137 }
138 return nullptr; // We are out of fake stack.
139}
140
141uptr FakeStack::AddrIsInFakeStack(uptr ptr, uptr* frame_beg, uptr* frame_end) {
142 uptr stack_size_log = this->stack_size_log();
143 uptr beg = reinterpret_cast<uptr>(GetFrame(stack_size_log, class_id: 0, pos: 0));
144 uptr end = reinterpret_cast<uptr>(this) + RequiredSize(stack_size_log);
145 if (ptr < beg || ptr >= end)
146 return 0;
147 uptr class_id = (ptr - beg) >> stack_size_log;
148 uptr base = beg + (class_id << stack_size_log);
149 CHECK_LE(base, ptr);
150 CHECK_LT(ptr, base + (((uptr)1) << stack_size_log));
151 uptr pos = (ptr - base) >> (kMinStackFrameSizeLog + class_id);
152 uptr res = base + pos * BytesInSizeClass(class_id);
153 *frame_end = res + BytesInSizeClass(class_id);
154 *frame_beg = res + sizeof(FakeFrame);
155 return res;
156}
157
158void FakeStack::HandleNoReturn() { needs_gc_ = true; }
159
160// Calls fn(frame, class_id, flag) for every frame whose allocation flag is set.
161template <typename Fn>
162ALWAYS_INLINE void FakeStack::ForEachAllocatedFrame(Fn fn) {
163 for (uptr class_id = 0; class_id < kNumberOfSizeClasses; class_id++) {
164 u8* flags = GetFlags(stack_size_log: stack_size_log(), class_id);
165 const uptr n = NumberOfFrames(stack_size_log: stack_size_log(), class_id);
166 for (uptr i = 0; i < n; i++) {
167 // Most flags are usually clear: skip 8 at once.
168 if (i + sizeof(u64) <= n && IsAligned(a: (uptr)&flags[i], alignment: sizeof(u64)) &&
169 *reinterpret_cast<u64*>(&flags[i]) == 0) {
170 i += sizeof(u64) - 1;
171 continue;
172 }
173 if (!flags[i])
174 continue;
175 u8* frame = GetFrame(stack_size_log: stack_size_log(), class_id, pos: i);
176 fn(reinterpret_cast<FakeFrame*>(frame), class_id, &flags[i]);
177 }
178 }
179}
180
181// Hack: The statement below is not true if we take into account sigaltstack or
182// makecontext. It should be possible to make GC to discard wrong stack frame if
183// we use these tools. For now, let's support the simplest case and allow GC to
184// discard only frames from the default stack, assuming there is no buffer on
185// the stack which is used for makecontext or sigaltstack.
186//
187// When throw, longjmp or some such happens we don't call OnFree() and
188// as the result may leak one or more fake frames, but the good news is that
189// we are notified about all such events by HandleNoReturn().
190// If we recently had such no-return event we need to collect garbage frames.
191// We do it based on their 'real_stack' values -- everything that is lower
192// than the current real_stack is garbage.
193NOINLINE void FakeStack::GC(uptr real_stack) {
194 AsanThread* curr_thread = GetCurrentThread();
195 if (!curr_thread)
196 return; // Try again when we have a thread.
197 auto top = curr_thread->stack_top();
198 auto bottom = curr_thread->stack_bottom();
199 if (real_stack < bottom || real_stack > top)
200 return; // Not the default stack.
201
202 ForEachAllocatedFrame(fn: [&](FakeFrame* ff, uptr class_id, u8* flag) {
203 // GC only on the default stack.
204 if (bottom < ff->real_stack && ff->real_stack < real_stack) {
205 *flag = 0;
206 // Poison the frame, so any access will be reported as UAR.
207 SetShadow(ptr: reinterpret_cast<uptr>(ff), size: BytesInSizeClass(class_id),
208 class_id, magic: kMagic8);
209 }
210 });
211 needs_gc_ = false;
212}
213
214void FakeStack::ForEachFakeFrame(RangeIteratorCallback callback, void* arg) {
215 ForEachAllocatedFrame(fn: [&](FakeFrame* ff, uptr class_id, u8*) {
216 uptr begin = reinterpret_cast<uptr>(ff);
217 callback(begin, begin + BytesInSizeClass(class_id), arg);
218 });
219}
220
221#if (SANITIZER_LINUX && !SANITIZER_ANDROID) || SANITIZER_FUCHSIA
222static THREADLOCAL FakeStack* fake_stack_tls;
223
224static FakeStack* GetTLSFakeStack() { return fake_stack_tls; }
225static void SetTLSFakeStack(FakeStack* fs) { fake_stack_tls = fs; }
226void ResetTLSFakeStack() { fake_stack_tls = nullptr; }
227#else
228static FakeStack* GetTLSFakeStack() { return nullptr; }
229static void SetTLSFakeStack(FakeStack*) {}
230void ResetTLSFakeStack() {}
231#endif // (SANITIZER_LINUX && !SANITIZER_ANDROID) || SANITIZER_FUCHSIA
232
233static void SuppressFakeStack() {
234 AsanThread* t = GetCurrentThread();
235 if (t) {
236 t->SuppressFakeStack();
237 }
238}
239
240static void UnsuppressFakeStack() {
241 AsanThread* t = GetCurrentThread();
242 if (t) {
243 t->UnsuppressFakeStack();
244 }
245}
246
247static FakeStack* GetFakeStack() {
248 AsanThread* t = GetCurrentThread();
249 if (!t || t->IsFakeStackSuppressed())
250 return nullptr;
251 return t->get_or_create_fake_stack();
252}
253
254static FakeStack* GetFakeStackFast() {
255 FakeStack* fs = GetTLSFakeStack();
256 if (LIKELY(fs))
257 return fs;
258 if (!__asan_option_detect_stack_use_after_return)
259 return nullptr;
260 fs = GetFakeStack();
261 if (LIKELY(fs))
262 SetTLSFakeStack(fs);
263 return fs;
264}
265
266static FakeStack* GetFakeStackFastAlways() {
267 FakeStack* fs = GetTLSFakeStack();
268 if (LIKELY(fs))
269 return fs;
270 fs = GetFakeStack();
271 if (LIKELY(fs))
272 SetTLSFakeStack(fs);
273 return fs;
274}
275
276static ALWAYS_INLINE uptr OnMalloc(uptr class_id, uptr size) {
277 FakeStack* fs = GetFakeStackFast();
278 if (!fs)
279 return 0;
280 FakeFrame* ff =
281 fs->Allocate(stack_size_log: fs->stack_size_log(), class_id, GET_CURRENT_FRAME());
282 if (!ff)
283 return 0; // Out of fake stack.
284 uptr ptr = reinterpret_cast<uptr>(ff);
285 SetShadow(ptr, size, class_id, magic: 0);
286 return ptr;
287}
288
289static ALWAYS_INLINE uptr OnMallocAlways(uptr class_id, uptr size) {
290 FakeStack* fs = GetFakeStackFastAlways();
291 if (!fs)
292 return 0;
293 FakeFrame* ff =
294 fs->Allocate(stack_size_log: fs->stack_size_log(), class_id, GET_CURRENT_FRAME());
295 if (!ff)
296 return 0; // Out of fake stack.
297 uptr ptr = reinterpret_cast<uptr>(ff);
298 SetShadow(ptr, size, class_id, magic: 0);
299 return ptr;
300}
301
302static ALWAYS_INLINE void OnFree(uptr ptr, uptr class_id, uptr size) {
303 FakeStack::Deallocate(x: ptr, class_id);
304 SetShadow(ptr, size, class_id, magic: kMagic8);
305}
306
307} // namespace __asan
308
309// ---------------------- Interface ---------------- {{{1
310using namespace __asan;
311#define DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(class_id) \
312 extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr \
313 __asan_stack_malloc_##class_id(uptr size) { \
314 return OnMalloc(class_id, size); \
315 } \
316 extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr \
317 __asan_stack_malloc_always_##class_id(uptr size) { \
318 return OnMallocAlways(class_id, size); \
319 } \
320 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __asan_stack_free_##class_id( \
321 uptr ptr, uptr size) { \
322 OnFree(ptr, class_id, size); \
323 }
324
325DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(0)
326DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(1)
327DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(2)
328DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(3)
329DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(4)
330DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(5)
331DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(6)
332DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(7)
333DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(8)
334DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(9)
335DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(10)
336
337extern "C" {
338// TODO: remove this method and fix tests that use it by setting
339// -asan-use-after-return=never, after modal UAR flag lands
340// (https://github.com/google/sanitizers/issues/1394)
341SANITIZER_INTERFACE_ATTRIBUTE
342void* __asan_get_current_fake_stack() { return GetFakeStackFast(); }
343
344SANITIZER_INTERFACE_ATTRIBUTE
345void* __asan_addr_is_in_fake_stack(void* fake_stack, void* addr, void** beg,
346 void** end) {
347 FakeStack* fs = reinterpret_cast<FakeStack*>(fake_stack);
348 if (!fs)
349 return nullptr;
350 uptr frame_beg, frame_end;
351 FakeFrame* frame = reinterpret_cast<FakeFrame*>(fs->AddrIsInFakeStack(
352 ptr: reinterpret_cast<uptr>(addr), frame_beg: &frame_beg, frame_end: &frame_end));
353 if (!frame)
354 return nullptr;
355 if (frame->magic != kCurrentStackFrameMagic)
356 return nullptr;
357 if (beg)
358 *beg = reinterpret_cast<void*>(frame_beg);
359 if (end)
360 *end = reinterpret_cast<void*>(frame_end);
361 return reinterpret_cast<void*>(frame->real_stack);
362}
363
364SANITIZER_INTERFACE_ATTRIBUTE
365void __asan_alloca_poison(uptr addr, uptr size) {
366 uptr LeftRedzoneAddr = addr - kAllocaRedzoneSize;
367 uptr PartialRzAddr = addr + size;
368 uptr RightRzAddr = (PartialRzAddr + kAllocaRedzoneMask) & ~kAllocaRedzoneMask;
369 uptr PartialRzAligned = PartialRzAddr & ~(ASAN_SHADOW_GRANULARITY - 1);
370 FastPoisonShadow(aligned_beg: LeftRedzoneAddr, aligned_size: kAllocaRedzoneSize, value: kAsanAllocaLeftMagic);
371 FastPoisonShadowPartialRightRedzone(
372 aligned_addr: PartialRzAligned, size: PartialRzAddr % ASAN_SHADOW_GRANULARITY,
373 redzone_size: RightRzAddr - PartialRzAligned, value: kAsanAllocaRightMagic);
374 FastPoisonShadow(aligned_beg: RightRzAddr, aligned_size: kAllocaRedzoneSize, value: kAsanAllocaRightMagic);
375}
376
377SANITIZER_INTERFACE_ATTRIBUTE
378void __asan_allocas_unpoison(uptr top, uptr bottom) {
379 if ((!top) || (top > bottom))
380 return;
381 REAL(memset)(reinterpret_cast<void*>(MemToShadow(p: top)), 0,
382 (bottom - top) / ASAN_SHADOW_GRANULARITY);
383}
384
385SANITIZER_INTERFACE_ATTRIBUTE
386void __asan_suppress_fake_stack() { return SuppressFakeStack(); }
387SANITIZER_INTERFACE_ATTRIBUTE
388void __asan_unsuppress_fake_stack() { return UnsuppressFakeStack(); }
389} // extern "C"
390