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