1 //===-- asan_thread.h -------------------------------------------*- C++ -*-===// 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 // ASan-private header for asan_thread.cpp. 12 //===----------------------------------------------------------------------===// 13 14 #ifndef ASAN_THREAD_H 15 #define ASAN_THREAD_H 16 17 #include "asan_allocator.h" 18 #include "asan_internal.h" 19 #include "asan_fake_stack.h" 20 #include "asan_stats.h" 21 #include "sanitizer_common/sanitizer_common.h" 22 #include "sanitizer_common/sanitizer_libc.h" 23 #include "sanitizer_common/sanitizer_thread_registry.h" 24 25 namespace __sanitizer { 26 struct DTLS; 27 } // namespace __sanitizer 28 29 namespace __asan { 30 31 const u32 kInvalidTid = 0xffffff; // Must fit into 24 bits. 32 const u32 kMaxNumberOfThreads = (1 << 22); // 4M 33 34 class AsanThread; 35 36 // These objects are created for every thread and are never deleted, 37 // so we can find them by tid even if the thread is long dead. 38 class AsanThreadContext : public ThreadContextBase { 39 public: 40 explicit AsanThreadContext(int tid) 41 : ThreadContextBase(tid), announced(false), 42 destructor_iterations(GetPthreadDestructorIterations()), stack_id(0), 43 thread(nullptr) {} 44 bool announced; 45 u8 destructor_iterations; 46 u32 stack_id; 47 AsanThread *thread; 48 49 void OnCreated(void *arg) override; 50 void OnFinished() override; 51 52 struct CreateThreadContextArgs { 53 AsanThread *thread; 54 StackTrace *stack; 55 }; 56 }; 57 58 // AsanThreadContext objects are never freed, so we need many of them. 59 COMPILER_CHECK(sizeof(AsanThreadContext) <= 256); 60 61 // AsanThread are stored in TSD and destroyed when the thread dies. 62 class AsanThread { 63 public: 64 static AsanThread *Create(thread_callback_t start_routine, void *arg, 65 u32 parent_tid, StackTrace *stack, bool detached); 66 static void TSDDtor(void *tsd); 67 void Destroy(); 68 69 struct InitOptions; 70 void Init(const InitOptions *options = nullptr); 71 72 thread_return_t ThreadStart(tid_t os_id, 73 atomic_uintptr_t *signal_thread_is_registered); 74 75 uptr stack_top(); 76 uptr stack_bottom(); 77 uptr stack_size(); 78 uptr tls_begin() { return tls_begin_; } 79 uptr tls_end() { return tls_end_; } 80 DTLS *dtls() { return dtls_; } 81 u32 tid() { return context_->tid; } 82 AsanThreadContext *context() { return context_; } 83 void set_context(AsanThreadContext *context) { context_ = context; } 84 85 struct StackFrameAccess { 86 uptr offset; 87 uptr frame_pc; 88 const char *frame_descr; 89 }; 90 bool GetStackFrameAccessByAddr(uptr addr, StackFrameAccess *access); 91 92 // Returns a pointer to the start of the stack variable's shadow memory. 93 uptr GetStackVariableShadowStart(uptr addr); 94 95 bool AddrIsInStack(uptr addr); 96 97 void DeleteFakeStack(int tid) { 98 if (!fake_stack_) return; 99 FakeStack *t = fake_stack_; 100 fake_stack_ = nullptr; 101 SetTLSFakeStack(nullptr); 102 t->Destroy(tid); 103 } 104 105 void StartSwitchFiber(FakeStack **fake_stack_save, uptr bottom, uptr size); 106 void FinishSwitchFiber(FakeStack *fake_stack_save, uptr *bottom_old, 107 uptr *size_old); 108 109 bool has_fake_stack() { 110 return !atomic_load(&stack_switching_, memory_order_relaxed) && 111 (reinterpret_cast<uptr>(fake_stack_) > 1); 112 } 113 114 FakeStack *fake_stack() { 115 if (!__asan_option_detect_stack_use_after_return) 116 return nullptr; 117 if (atomic_load(&stack_switching_, memory_order_relaxed)) 118 return nullptr; 119 if (!has_fake_stack()) 120 return AsyncSignalSafeLazyInitFakeStack(); 121 return fake_stack_; 122 } 123 124 // True is this thread is currently unwinding stack (i.e. collecting a stack 125 // trace). Used to prevent deadlocks on platforms where libc unwinder calls 126 // malloc internally. See PR17116 for more details. 127 bool isUnwinding() const { return unwinding_; } 128 void setUnwinding(bool b) { unwinding_ = b; } 129 130 AsanThreadLocalMallocStorage &malloc_storage() { return malloc_storage_; } 131 AsanStats &stats() { return stats_; } 132 133 void *extra_spill_area() { return &extra_spill_area_; } 134 135 private: 136 // NOTE: There is no AsanThread constructor. It is allocated 137 // via mmap() and *must* be valid in zero-initialized state. 138 139 void SetThreadStackAndTls(const InitOptions *options); 140 141 void ClearShadowForThreadStackAndTLS(); 142 FakeStack *AsyncSignalSafeLazyInitFakeStack(); 143 144 struct StackBounds { 145 uptr bottom; 146 uptr top; 147 }; 148 StackBounds GetStackBounds() const; 149 150 AsanThreadContext *context_; 151 thread_callback_t start_routine_; 152 void *arg_; 153 154 uptr stack_top_; 155 uptr stack_bottom_; 156 // these variables are used when the thread is about to switch stack 157 uptr next_stack_top_; 158 uptr next_stack_bottom_; 159 // true if switching is in progress 160 atomic_uint8_t stack_switching_; 161 162 uptr tls_begin_; 163 uptr tls_end_; 164 DTLS *dtls_; 165 166 FakeStack *fake_stack_; 167 AsanThreadLocalMallocStorage malloc_storage_; 168 AsanStats stats_; 169 bool unwinding_; 170 uptr extra_spill_area_; 171 }; 172 173 // Returns a single instance of registry. 174 ThreadRegistry &asanThreadRegistry(); 175 176 // Must be called under ThreadRegistryLock. 177 AsanThreadContext *GetThreadContextByTidLocked(u32 tid); 178 179 // Get the current thread. May return 0. 180 AsanThread *GetCurrentThread(); 181 void SetCurrentThread(AsanThread *t); 182 u32 GetCurrentTidOrInvalid(); 183 AsanThread *FindThreadByStackAddress(uptr addr); 184 185 // Used to handle fork(). 186 void EnsureMainThreadIDIsCorrect(); 187 } // namespace __asan 188 189 #endif // ASAN_THREAD_H 190