1 //===-- asan_thread.cc ----------------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is a part of AddressSanitizer, an address sanity checker.
10 // Thread-related code.
11 //===----------------------------------------------------------------------===//
12 #include "asan_allocator.h"
13 #include "asan_interceptors.h"
14 #include "asan_poisoning.h"
15 #include "asan_stack.h"
16 #include "asan_thread.h"
17 #include "asan_mapping.h"
18 #include "sanitizer_common/sanitizer_common.h"
19 #include "sanitizer_common/sanitizer_placement_new.h"
20 #include "sanitizer_common/sanitizer_stackdepot.h"
21 #include "sanitizer_common/sanitizer_tls_get_addr.h"
22 #include "lsan/lsan_common.h"
26 // AsanThreadContext implementation.
28 void AsanThreadContext::OnCreated(void *arg
) {
29 CreateThreadContextArgs
*args
= static_cast<CreateThreadContextArgs
*>(arg
);
31 stack_id
= StackDepotPut(args
->stack
->trace
, args
->stack
->size
);
32 thread
= args
->thread
;
33 thread
->set_context(this);
36 void AsanThreadContext::OnFinished() {
37 // Drop the link to the AsanThread object.
41 // MIPS requires aligned address
42 static ALIGNED(16) char thread_registry_placeholder
[sizeof(ThreadRegistry
)];
43 static ThreadRegistry
*asan_thread_registry
;
45 static BlockingMutex
mu_for_thread_context(LINKER_INITIALIZED
);
46 static LowLevelAllocator allocator_for_thread_context
;
48 static ThreadContextBase
*GetAsanThreadContext(u32 tid
) {
49 BlockingMutexLock
lock(&mu_for_thread_context
);
50 return new(allocator_for_thread_context
) AsanThreadContext(tid
);
53 ThreadRegistry
&asanThreadRegistry() {
54 static bool initialized
;
55 // Don't worry about thread_safety - this should be called when there is
58 // Never reuse ASan threads: we store pointer to AsanThreadContext
59 // in TSD and can't reliably tell when no more TSD destructors will
60 // be called. It would be wrong to reuse AsanThreadContext for another
61 // thread before all TSD destructors will be called for it.
62 asan_thread_registry
= new(thread_registry_placeholder
) ThreadRegistry(
63 GetAsanThreadContext
, kMaxNumberOfThreads
, kMaxNumberOfThreads
);
66 return *asan_thread_registry
;
69 AsanThreadContext
*GetThreadContextByTidLocked(u32 tid
) {
70 return static_cast<AsanThreadContext
*>(
71 asanThreadRegistry().GetThreadLocked(tid
));
74 // AsanThread implementation.
76 AsanThread
*AsanThread::Create(thread_callback_t start_routine
,
78 uptr PageSize
= GetPageSizeCached();
79 uptr size
= RoundUpTo(sizeof(AsanThread
), PageSize
);
80 AsanThread
*thread
= (AsanThread
*)MmapOrDie(size
, __func__
);
81 thread
->start_routine_
= start_routine
;
87 void AsanThread::TSDDtor(void *tsd
) {
88 AsanThreadContext
*context
= (AsanThreadContext
*)tsd
;
89 VReport(1, "T%d TSDDtor\n", context
->tid
);
91 context
->thread
->Destroy();
94 void AsanThread::Destroy() {
95 int tid
= this->tid();
96 VReport(1, "T%d exited\n", tid
);
98 malloc_storage().CommitBack();
99 if (common_flags()->use_sigaltstack
) UnsetAlternateSignalStack();
100 asanThreadRegistry().FinishThread(tid
);
101 FlushToDeadThreadStats(&stats_
);
102 // We also clear the shadow on thread destruction because
103 // some code may still be executing in later TSD destructors
104 // and we don't want it to have any poisoned stack.
105 ClearShadowForThreadStackAndTLS();
106 DeleteFakeStack(tid
);
107 uptr size
= RoundUpTo(sizeof(AsanThread
), GetPageSizeCached());
108 UnmapOrDie(this, size
);
112 // We want to create the FakeStack lazyly on the first use, but not eralier
113 // than the stack size is known and the procedure has to be async-signal safe.
114 FakeStack
*AsanThread::AsyncSignalSafeLazyInitFakeStack() {
115 uptr stack_size
= this->stack_size();
116 if (stack_size
== 0) // stack_size is not yet available, don't use FakeStack.
119 // fake_stack_ has 3 states:
120 // 0 -- not initialized
121 // 1 -- being initialized
122 // ptr -- initialized
123 // This CAS checks if the state was 0 and if so changes it to state 1,
124 // if that was successful, it initializes the pointer.
125 if (atomic_compare_exchange_strong(
126 reinterpret_cast<atomic_uintptr_t
*>(&fake_stack_
), &old_val
, 1UL,
127 memory_order_relaxed
)) {
128 uptr stack_size_log
= Log2(RoundUpToPowerOfTwo(stack_size
));
129 CHECK_LE(flags()->min_uar_stack_size_log
, flags()->max_uar_stack_size_log
);
131 Min(stack_size_log
, static_cast<uptr
>(flags()->max_uar_stack_size_log
));
133 Max(stack_size_log
, static_cast<uptr
>(flags()->min_uar_stack_size_log
));
134 fake_stack_
= FakeStack::Create(stack_size_log
);
135 SetTLSFakeStack(fake_stack_
);
141 void AsanThread::Init() {
142 SetThreadStackAndTls();
143 CHECK(AddrIsInMem(stack_bottom_
));
144 CHECK(AddrIsInMem(stack_top_
- 1));
145 ClearShadowForThreadStackAndTLS();
147 VReport(1, "T%d: stack [%p,%p) size 0x%zx; local=%p\n", tid(),
148 (void *)stack_bottom_
, (void *)stack_top_
, stack_top_
- stack_bottom_
,
150 fake_stack_
= 0; // Will be initialized lazily if needed.
151 AsanPlatformThreadInit();
154 thread_return_t
AsanThread::ThreadStart(uptr os_id
) {
156 asanThreadRegistry().StartThread(tid(), os_id
, 0);
157 if (common_flags()->use_sigaltstack
) SetAlternateSignalStack();
159 if (!start_routine_
) {
160 // start_routine_ == 0 if we're on the main thread or on one of the
161 // OS X libdispatch worker threads. But nobody is supposed to call
162 // ThreadStart() for the worker threads.
167 thread_return_t res
= start_routine_(arg_
);
169 // On POSIX systems we defer this to the TSD destructor. LSan will consider
170 // the thread's memory as non-live from the moment we call Destroy(), even
171 // though that memory might contain pointers to heap objects which will be
172 // cleaned up by a user-defined TSD destructor. Thus, calling Destroy() before
173 // the TSD destructors have run might cause false positives in LSan.
174 if (!SANITIZER_POSIX
)
180 void AsanThread::SetThreadStackAndTls() {
182 GetThreadStackAndTls(tid() == 0, &stack_bottom_
, &stack_size_
, &tls_begin_
,
184 stack_top_
= stack_bottom_
+ stack_size_
;
185 tls_end_
= tls_begin_
+ tls_size
;
188 CHECK(AddrIsInStack((uptr
)&local
));
191 void AsanThread::ClearShadowForThreadStackAndTLS() {
192 PoisonShadow(stack_bottom_
, stack_top_
- stack_bottom_
, 0);
193 if (tls_begin_
!= tls_end_
)
194 PoisonShadow(tls_begin_
, tls_end_
- tls_begin_
, 0);
197 const char *AsanThread::GetFrameNameByAddr(uptr addr
, uptr
*offset
,
200 if (AddrIsInStack(addr
)) {
201 bottom
= stack_bottom();
202 } else if (has_fake_stack()) {
203 bottom
= fake_stack()->AddrIsInFakeStack(addr
);
205 *offset
= addr
- bottom
;
206 *frame_pc
= ((uptr
*)bottom
)[2];
207 return (const char *)((uptr
*)bottom
)[1];
209 uptr aligned_addr
= addr
& ~(SANITIZER_WORDSIZE
/8 - 1); // align addr.
210 u8
*shadow_ptr
= (u8
*)MemToShadow(aligned_addr
);
211 u8
*shadow_bottom
= (u8
*)MemToShadow(bottom
);
213 while (shadow_ptr
>= shadow_bottom
&&
214 *shadow_ptr
!= kAsanStackLeftRedzoneMagic
) {
218 while (shadow_ptr
>= shadow_bottom
&&
219 *shadow_ptr
== kAsanStackLeftRedzoneMagic
) {
223 if (shadow_ptr
< shadow_bottom
) {
228 uptr
* ptr
= (uptr
*)SHADOW_TO_MEM((uptr
)(shadow_ptr
+ 1));
229 CHECK(ptr
[0] == kCurrentStackFrameMagic
);
230 *offset
= addr
- (uptr
)ptr
;
232 return (const char*)ptr
[1];
235 static bool ThreadStackContainsAddress(ThreadContextBase
*tctx_base
,
237 AsanThreadContext
*tctx
= static_cast<AsanThreadContext
*>(tctx_base
);
238 AsanThread
*t
= tctx
->thread
;
239 if (!t
) return false;
240 if (t
->AddrIsInStack((uptr
)addr
)) return true;
241 if (t
->has_fake_stack() && t
->fake_stack()->AddrIsInFakeStack((uptr
)addr
))
246 AsanThread
*GetCurrentThread() {
247 AsanThreadContext
*context
=
248 reinterpret_cast<AsanThreadContext
*>(AsanTSDGet());
250 if (SANITIZER_ANDROID
) {
251 // On Android, libc constructor is called _after_ asan_init, and cleans up
252 // TSD. Try to figure out if this is still the main thread by the stack
253 // address. We are not entirely sure that we have correct main thread
254 // limits, so only do this magic on Android, and only if the found thread
255 // is the main thread.
256 AsanThreadContext
*tctx
= GetThreadContextByTidLocked(0);
257 if (ThreadStackContainsAddress(tctx
, &context
)) {
258 SetCurrentThread(tctx
->thread
);
264 return context
->thread
;
267 void SetCurrentThread(AsanThread
*t
) {
269 VReport(2, "SetCurrentThread: %p for thread %p\n", t
->context(),
270 (void *)GetThreadSelf());
271 // Make sure we do not reset the current AsanThread.
272 CHECK_EQ(0, AsanTSDGet());
273 AsanTSDSet(t
->context());
274 CHECK_EQ(t
->context(), AsanTSDGet());
277 u32
GetCurrentTidOrInvalid() {
278 AsanThread
*t
= GetCurrentThread();
279 return t
? t
->tid() : kInvalidTid
;
282 AsanThread
*FindThreadByStackAddress(uptr addr
) {
283 asanThreadRegistry().CheckLocked();
284 AsanThreadContext
*tctx
= static_cast<AsanThreadContext
*>(
285 asanThreadRegistry().FindThreadContextLocked(ThreadStackContainsAddress
,
287 return tctx
? tctx
->thread
: 0;
290 void EnsureMainThreadIDIsCorrect() {
291 AsanThreadContext
*context
=
292 reinterpret_cast<AsanThreadContext
*>(AsanTSDGet());
293 if (context
&& (context
->tid
== 0))
294 context
->os_id
= GetTid();
297 __asan::AsanThread
*GetAsanThreadByOsIDLocked(uptr os_id
) {
298 __asan::AsanThreadContext
*context
= static_cast<__asan::AsanThreadContext
*>(
299 __asan::asanThreadRegistry().FindThreadContextByOsIDLocked(os_id
));
300 if (!context
) return 0;
301 return context
->thread
;
303 } // namespace __asan
305 // --- Implementation of LSan-specific functions --- {{{1
307 bool GetThreadRangesLocked(uptr os_id
, uptr
*stack_begin
, uptr
*stack_end
,
308 uptr
*tls_begin
, uptr
*tls_end
,
309 uptr
*cache_begin
, uptr
*cache_end
) {
310 __asan::AsanThread
*t
= __asan::GetAsanThreadByOsIDLocked(os_id
);
311 if (!t
) return false;
312 *stack_begin
= t
->stack_bottom();
313 *stack_end
= t
->stack_top();
314 *tls_begin
= t
->tls_begin();
315 *tls_end
= t
->tls_end();
316 // ASan doesn't keep allocator caches in TLS, so these are unused.
322 void ForEachExtraStackRange(uptr os_id
, RangeIteratorCallback callback
,
324 __asan::AsanThread
*t
= __asan::GetAsanThreadByOsIDLocked(os_id
);
325 if (t
&& t
->has_fake_stack())
326 t
->fake_stack()->ForEachFakeFrame(callback
, arg
);
329 void LockThreadRegistry() {
330 __asan::asanThreadRegistry().Lock();
333 void UnlockThreadRegistry() {
334 __asan::asanThreadRegistry().Unlock();
337 void EnsureMainThreadIDIsCorrect() {
338 __asan::EnsureMainThreadIDIsCorrect();
340 } // namespace __lsan