Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 1 | //===-- asan_fake_stack.cc ------------------------------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file is a part of AddressSanitizer, an address sanity checker. |
| 11 | // |
| 12 | // FakeStack is used to detect use-after-return bugs. |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | #include "asan_allocator.h" |
Alexey Samsonov | 7e84349 | 2013-03-28 15:42:43 +0000 | [diff] [blame] | 15 | #include "asan_poisoning.h" |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 16 | #include "asan_thread.h" |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 17 | |
| 18 | namespace __asan { |
| 19 | |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 20 | void FakeStack::PoisonAll(u8 magic) { |
| 21 | PoisonShadow(reinterpret_cast<uptr>(this), RequiredSize(stack_size_log()), |
| 22 | magic); |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 23 | } |
| 24 | |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 25 | FakeFrame *FakeStack::Allocate(uptr stack_size_log, uptr class_id, |
| 26 | uptr real_stack) { |
| 27 | CHECK_LT(class_id, kNumberOfSizeClasses); |
| 28 | uptr &hint_position = hint_position_[class_id]; |
| 29 | const int num_iter = NumberOfFrames(stack_size_log, class_id); |
| 30 | u8 *flags = GetFlags(stack_size_log, class_id); |
| 31 | for (int i = 0; i < num_iter; i++) { |
| 32 | uptr pos = ModuloNumberOfFrames(stack_size_log, class_id, hint_position++); |
| 33 | if (flags[pos]) continue; |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 34 | // FIXME: this does not have to be thread-safe, just async-signal-safe. |
Kostya Serebryany | 86b88b8 | 2013-09-12 07:28:42 +0000 | [diff] [blame] | 35 | if (0 == atomic_exchange((atomic_uint8_t *)&flags[pos], 1, |
| 36 | memory_order_relaxed)) { |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 37 | FakeFrame *res = reinterpret_cast<FakeFrame *>( |
| 38 | GetFrame(stack_size_log, class_id, pos)); |
| 39 | res->real_stack = real_stack; |
| 40 | res->class_id = class_id; |
| 41 | return res; |
| 42 | } |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 43 | } |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 44 | CHECK(0 && "Failed to allocate a fake stack frame"); |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 45 | return 0; |
| 46 | } |
| 47 | |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 48 | void FakeStack::Deallocate(FakeFrame *ff, uptr stack_size_log, uptr class_id, |
| 49 | uptr real_stack) { |
| 50 | u8 *base = GetFrame(stack_size_log, class_id, 0); |
| 51 | u8 *cur = reinterpret_cast<u8 *>(ff); |
| 52 | CHECK_LE(base, cur); |
| 53 | CHECK_LT(cur, base + (1UL << stack_size_log)); |
| 54 | uptr pos = (cur - base) >> (kMinStackFrameSizeLog + class_id); |
| 55 | u8 *flags = GetFlags(stack_size_log, class_id); |
| 56 | CHECK_EQ(flags[pos], 1); |
| 57 | flags[pos] = 0; |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 58 | } |
| 59 | |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 60 | uptr FakeStack::AddrIsInFakeStack(uptr ptr) { |
| 61 | uptr stack_size_log = this->stack_size_log(); |
| 62 | uptr beg = reinterpret_cast<uptr>(GetFrame(stack_size_log, 0, 0)); |
| 63 | uptr end = reinterpret_cast<uptr>(this) + RequiredSize(stack_size_log); |
| 64 | if (ptr < beg || ptr >= end) return 0; |
| 65 | uptr class_id = (ptr - beg) >> stack_size_log; |
| 66 | uptr base = beg + (class_id << stack_size_log); |
| 67 | CHECK_LE(base, ptr); |
| 68 | CHECK_LT(ptr, base + (1UL << stack_size_log)); |
| 69 | uptr pos = (ptr - base) >> (kMinStackFrameSizeLog + class_id); |
| 70 | return base + pos * BytesInSizeClass(class_id); |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 71 | } |
| 72 | |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 73 | ALWAYS_INLINE uptr OnMalloc(uptr class_id, uptr size, uptr real_stack) { |
| 74 | AsanThread *t = GetCurrentThread(); |
| 75 | if (!t) return real_stack; |
| 76 | FakeStack *fs = t->fake_stack(); |
| 77 | FakeFrame *ff = fs->Allocate(fs->stack_size_log(), class_id, real_stack); |
| 78 | uptr ptr = reinterpret_cast<uptr>(ff); |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 79 | PoisonShadow(ptr, size, 0); |
| 80 | return ptr; |
| 81 | } |
| 82 | |
Kostya Serebryany | 34e3ed1 | 2013-09-10 13:16:26 +0000 | [diff] [blame] | 83 | ALWAYS_INLINE void OnFree(uptr ptr, uptr class_id, uptr size, uptr real_stack) { |
Kostya Serebryany | ac3ae5d | 2013-09-12 07:11:58 +0000 | [diff] [blame] | 84 | if (ptr == real_stack) |
| 85 | return; |
| 86 | AsanThread *t = GetCurrentThread(); |
| 87 | if (!t) return; |
| 88 | FakeStack *fs = t->fake_stack(); |
| 89 | FakeFrame *ff = reinterpret_cast<FakeFrame *>(ptr); |
| 90 | fs->Deallocate(ff, fs->stack_size_log(), class_id, real_stack); |
| 91 | PoisonShadow(ptr, size, kAsanStackAfterReturnMagic); |
Kostya Serebryany | 2679f19 | 2012-12-10 14:19:15 +0000 | [diff] [blame] | 92 | } |
Kostya Serebryany | 34e3ed1 | 2013-09-10 13:16:26 +0000 | [diff] [blame] | 93 | |
| 94 | } // namespace __asan |
| 95 | |
| 96 | // ---------------------- Interface ---------------- {{{1 |
| 97 | #define DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(class_id) \ |
| 98 | extern "C" SANITIZER_INTERFACE_ATTRIBUTE uptr \ |
| 99 | __asan_stack_malloc_##class_id(uptr size, uptr real_stack) { \ |
| 100 | return __asan::OnMalloc(class_id, size, real_stack); \ |
| 101 | } \ |
| 102 | extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __asan_stack_free_##class_id( \ |
| 103 | uptr ptr, uptr size, uptr real_stack) { \ |
| 104 | __asan::OnFree(ptr, class_id, size, real_stack); \ |
| 105 | } |
| 106 | |
| 107 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(0) |
| 108 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(1) |
| 109 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(2) |
| 110 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(3) |
| 111 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(4) |
| 112 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(5) |
| 113 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(6) |
| 114 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(7) |
| 115 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(8) |
| 116 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(9) |
| 117 | DEFINE_STACK_MALLOC_FREE_WITH_CLASS_ID(10) |