|
111
|
1 //===-- asan_thread.h -------------------------------------------*- C++ -*-===//
|
|
|
2 //
|
|
145
|
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
|
|
111
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8 //
|
|
|
9 // This file is a part of AddressSanitizer, an address sanity checker.
|
|
|
10 //
|
|
145
|
11 // ASan-private header for asan_thread.cpp.
|
|
111
|
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
|
|
131
|
92 // Returns a pointer to the start of the stack variable's shadow memory.
|
|
|
93 uptr GetStackVariableShadowStart(uptr addr);
|
|
|
94
|
|
111
|
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
|
|
145
|
133 void *extra_spill_area() { return &extra_spill_area_; }
|
|
|
134
|
|
111
|
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_;
|
|
145
|
170 uptr extra_spill_area_;
|
|
111
|
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
|
