1 //=-- lsan_interceptors.cpp -----------------------------------------------===//
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 LeakSanitizer.
10 // Interceptors for standalone LSan.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "interception/interception.h"
15 #include "sanitizer_common/sanitizer_allocator.h"
16 #include "sanitizer_common/sanitizer_allocator_dlsym.h"
17 #include "sanitizer_common/sanitizer_allocator_report.h"
18 #include "sanitizer_common/sanitizer_atomic.h"
19 #include "sanitizer_common/sanitizer_common.h"
20 #include "sanitizer_common/sanitizer_flags.h"
21 #include "sanitizer_common/sanitizer_internal_defs.h"
22 #include "sanitizer_common/sanitizer_linux.h"
23 #include "sanitizer_common/sanitizer_platform_interceptors.h"
24 #include "sanitizer_common/sanitizer_platform_limits_netbsd.h"
25 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
26 #if SANITIZER_POSIX
27 #include "sanitizer_common/sanitizer_posix.h"
28 #endif
29 #include "sanitizer_common/sanitizer_tls_get_addr.h"
30 #include "lsan.h"
31 #include "lsan_allocator.h"
32 #include "lsan_common.h"
33 #include "lsan_thread.h"
34
35 #include <stddef.h>
36
37 using namespace __lsan;
38
39 extern "C" {
40 int pthread_attr_init(void *attr);
41 int pthread_attr_destroy(void *attr);
42 int pthread_attr_getdetachstate(void *attr, int *v);
43 int pthread_key_create(unsigned *key, void (*destructor)(void* v));
44 int pthread_setspecific(unsigned key, const void *v);
45 }
46
47 struct DlsymAlloc : DlSymAllocator<DlsymAlloc> {
UseImplDlsymAlloc48 static bool UseImpl() { return lsan_init_is_running; }
OnAllocateDlsymAlloc49 static void OnAllocate(const void *ptr, uptr size) {
50 #if CAN_SANITIZE_LEAKS
51 // Suppress leaks from dlerror(). Previously dlsym hack on global array was
52 // used by leak sanitizer as a root region.
53 __lsan_register_root_region(ptr, size);
54 #endif
55 }
OnFreeDlsymAlloc56 static void OnFree(const void *ptr, uptr size) {
57 #if CAN_SANITIZE_LEAKS
58 __lsan_unregister_root_region(ptr, size);
59 #endif
60 }
61 };
62
63 ///// Malloc/free interceptors. /////
64
65 namespace std {
66 struct nothrow_t;
67 enum class align_val_t: size_t;
68 }
69
70 #if !SANITIZER_MAC
INTERCEPTOR(void *,malloc,uptr size)71 INTERCEPTOR(void*, malloc, uptr size) {
72 if (DlsymAlloc::Use())
73 return DlsymAlloc::Allocate(size);
74 ENSURE_LSAN_INITED;
75 GET_STACK_TRACE_MALLOC;
76 return lsan_malloc(size, stack);
77 }
78
INTERCEPTOR(void,free,void * p)79 INTERCEPTOR(void, free, void *p) {
80 if (DlsymAlloc::PointerIsMine(p))
81 return DlsymAlloc::Free(p);
82 ENSURE_LSAN_INITED;
83 lsan_free(p);
84 }
85
INTERCEPTOR(void *,calloc,uptr nmemb,uptr size)86 INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
87 if (DlsymAlloc::Use())
88 return DlsymAlloc::Callocate(nmemb, size);
89 ENSURE_LSAN_INITED;
90 GET_STACK_TRACE_MALLOC;
91 return lsan_calloc(nmemb, size, stack);
92 }
93
INTERCEPTOR(void *,realloc,void * ptr,uptr size)94 INTERCEPTOR(void *, realloc, void *ptr, uptr size) {
95 if (DlsymAlloc::Use() || DlsymAlloc::PointerIsMine(ptr))
96 return DlsymAlloc::Realloc(ptr, size);
97 ENSURE_LSAN_INITED;
98 GET_STACK_TRACE_MALLOC;
99 return lsan_realloc(ptr, size, stack);
100 }
101
INTERCEPTOR(void *,reallocarray,void * q,uptr nmemb,uptr size)102 INTERCEPTOR(void*, reallocarray, void *q, uptr nmemb, uptr size) {
103 ENSURE_LSAN_INITED;
104 GET_STACK_TRACE_MALLOC;
105 return lsan_reallocarray(q, nmemb, size, stack);
106 }
107
INTERCEPTOR(int,posix_memalign,void ** memptr,uptr alignment,uptr size)108 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
109 ENSURE_LSAN_INITED;
110 GET_STACK_TRACE_MALLOC;
111 return lsan_posix_memalign(memptr, alignment, size, stack);
112 }
113
INTERCEPTOR(void *,valloc,uptr size)114 INTERCEPTOR(void*, valloc, uptr size) {
115 ENSURE_LSAN_INITED;
116 GET_STACK_TRACE_MALLOC;
117 return lsan_valloc(size, stack);
118 }
119 #endif // !SANITIZER_MAC
120
121 #if SANITIZER_INTERCEPT_MEMALIGN
INTERCEPTOR(void *,memalign,uptr alignment,uptr size)122 INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
123 ENSURE_LSAN_INITED;
124 GET_STACK_TRACE_MALLOC;
125 return lsan_memalign(alignment, size, stack);
126 }
127 #define LSAN_MAYBE_INTERCEPT_MEMALIGN INTERCEPT_FUNCTION(memalign)
128 #else
129 #define LSAN_MAYBE_INTERCEPT_MEMALIGN
130 #endif // SANITIZER_INTERCEPT_MEMALIGN
131
132 #if SANITIZER_INTERCEPT___LIBC_MEMALIGN
INTERCEPTOR(void *,__libc_memalign,uptr alignment,uptr size)133 INTERCEPTOR(void *, __libc_memalign, uptr alignment, uptr size) {
134 ENSURE_LSAN_INITED;
135 GET_STACK_TRACE_MALLOC;
136 void *res = lsan_memalign(alignment, size, stack);
137 DTLS_on_libc_memalign(res, size);
138 return res;
139 }
140 #define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN INTERCEPT_FUNCTION(__libc_memalign)
141 #else
142 #define LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN
143 #endif // SANITIZER_INTERCEPT___LIBC_MEMALIGN
144
145 #if SANITIZER_INTERCEPT_ALIGNED_ALLOC
INTERCEPTOR(void *,aligned_alloc,uptr alignment,uptr size)146 INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
147 ENSURE_LSAN_INITED;
148 GET_STACK_TRACE_MALLOC;
149 return lsan_aligned_alloc(alignment, size, stack);
150 }
151 #define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC INTERCEPT_FUNCTION(aligned_alloc)
152 #else
153 #define LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC
154 #endif
155
156 #if SANITIZER_INTERCEPT_MALLOC_USABLE_SIZE
INTERCEPTOR(uptr,malloc_usable_size,void * ptr)157 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
158 ENSURE_LSAN_INITED;
159 return GetMallocUsableSize(ptr);
160 }
161 #define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE \
162 INTERCEPT_FUNCTION(malloc_usable_size)
163 #else
164 #define LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE
165 #endif
166
167 #if SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
168 struct fake_mallinfo {
169 int x[10];
170 };
171
INTERCEPTOR(struct fake_mallinfo,mallinfo,void)172 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
173 struct fake_mallinfo res;
174 internal_memset(&res, 0, sizeof(res));
175 return res;
176 }
177 #define LSAN_MAYBE_INTERCEPT_MALLINFO INTERCEPT_FUNCTION(mallinfo)
178
INTERCEPTOR(int,mallopt,int cmd,int value)179 INTERCEPTOR(int, mallopt, int cmd, int value) {
180 return 0;
181 }
182 #define LSAN_MAYBE_INTERCEPT_MALLOPT INTERCEPT_FUNCTION(mallopt)
183 #else
184 #define LSAN_MAYBE_INTERCEPT_MALLINFO
185 #define LSAN_MAYBE_INTERCEPT_MALLOPT
186 #endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
187
188 #if SANITIZER_INTERCEPT_PVALLOC
INTERCEPTOR(void *,pvalloc,uptr size)189 INTERCEPTOR(void*, pvalloc, uptr size) {
190 ENSURE_LSAN_INITED;
191 GET_STACK_TRACE_MALLOC;
192 return lsan_pvalloc(size, stack);
193 }
194 #define LSAN_MAYBE_INTERCEPT_PVALLOC INTERCEPT_FUNCTION(pvalloc)
195 #else
196 #define LSAN_MAYBE_INTERCEPT_PVALLOC
197 #endif // SANITIZER_INTERCEPT_PVALLOC
198
199 #if SANITIZER_INTERCEPT_CFREE
200 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
201 #define LSAN_MAYBE_INTERCEPT_CFREE INTERCEPT_FUNCTION(cfree)
202 #else
203 #define LSAN_MAYBE_INTERCEPT_CFREE
204 #endif // SANITIZER_INTERCEPT_CFREE
205
206 #if SANITIZER_INTERCEPT_MCHECK_MPROBE
INTERCEPTOR(int,mcheck,void (* abortfunc)(int mstatus))207 INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) {
208 return 0;
209 }
210
INTERCEPTOR(int,mcheck_pedantic,void (* abortfunc)(int mstatus))211 INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) {
212 return 0;
213 }
214
INTERCEPTOR(int,mprobe,void * ptr)215 INTERCEPTOR(int, mprobe, void *ptr) {
216 return 0;
217 }
218 #endif // SANITIZER_INTERCEPT_MCHECK_MPROBE
219
220
221 // TODO(alekseys): throw std::bad_alloc instead of dying on OOM.
222 #define OPERATOR_NEW_BODY(nothrow)\
223 ENSURE_LSAN_INITED;\
224 GET_STACK_TRACE_MALLOC;\
225 void *res = lsan_malloc(size, stack);\
226 if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
227 return res;
228 #define OPERATOR_NEW_BODY_ALIGN(nothrow)\
229 ENSURE_LSAN_INITED;\
230 GET_STACK_TRACE_MALLOC;\
231 void *res = lsan_memalign((uptr)align, size, stack);\
232 if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
233 return res;
234
235 #define OPERATOR_DELETE_BODY\
236 ENSURE_LSAN_INITED;\
237 lsan_free(ptr);
238
239 // On OS X it's not enough to just provide our own 'operator new' and
240 // 'operator delete' implementations, because they're going to be in the runtime
241 // dylib, and the main executable will depend on both the runtime dylib and
242 // libstdc++, each of has its implementation of new and delete.
243 // To make sure that C++ allocation/deallocation operators are overridden on
244 // OS X we need to intercept them using their mangled names.
245 #if !SANITIZER_MAC
246
247 INTERCEPTOR_ATTRIBUTE
operator new(size_t size)248 void *operator new(size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
249 INTERCEPTOR_ATTRIBUTE
operator new[](size_t size)250 void *operator new[](size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); }
251 INTERCEPTOR_ATTRIBUTE
operator new(size_t size,std::nothrow_t const &)252 void *operator new(size_t size, std::nothrow_t const&)
253 { OPERATOR_NEW_BODY(true /*nothrow*/); }
254 INTERCEPTOR_ATTRIBUTE
operator new[](size_t size,std::nothrow_t const &)255 void *operator new[](size_t size, std::nothrow_t const&)
256 { OPERATOR_NEW_BODY(true /*nothrow*/); }
257 INTERCEPTOR_ATTRIBUTE
operator new(size_t size,std::align_val_t align)258 void *operator new(size_t size, std::align_val_t align)
259 { OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
260 INTERCEPTOR_ATTRIBUTE
operator new[](size_t size,std::align_val_t align)261 void *operator new[](size_t size, std::align_val_t align)
262 { OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); }
263 INTERCEPTOR_ATTRIBUTE
operator new(size_t size,std::align_val_t align,std::nothrow_t const &)264 void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&)
265 { OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }
266 INTERCEPTOR_ATTRIBUTE
operator new[](size_t size,std::align_val_t align,std::nothrow_t const &)267 void *operator new[](size_t size, std::align_val_t align, std::nothrow_t const&)
268 { OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); }
269
270 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr)271 void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
272 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr)273 void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
274 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr,std::nothrow_t const &)275 void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
276 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr,std::nothrow_t const &)277 void operator delete[](void *ptr, std::nothrow_t const &)
278 { OPERATOR_DELETE_BODY; }
279 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr,size_t size)280 void operator delete(void *ptr, size_t size) NOEXCEPT
281 { OPERATOR_DELETE_BODY; }
282 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr,size_t size)283 void operator delete[](void *ptr, size_t size) NOEXCEPT
284 { OPERATOR_DELETE_BODY; }
285 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr,std::align_val_t)286 void operator delete(void *ptr, std::align_val_t) NOEXCEPT
287 { OPERATOR_DELETE_BODY; }
288 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr,std::align_val_t)289 void operator delete[](void *ptr, std::align_val_t) NOEXCEPT
290 { OPERATOR_DELETE_BODY; }
291 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr,std::align_val_t,std::nothrow_t const &)292 void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&)
293 { OPERATOR_DELETE_BODY; }
294 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr,std::align_val_t,std::nothrow_t const &)295 void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&)
296 { OPERATOR_DELETE_BODY; }
297 INTERCEPTOR_ATTRIBUTE
operator delete(void * ptr,size_t size,std::align_val_t)298 void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT
299 { OPERATOR_DELETE_BODY; }
300 INTERCEPTOR_ATTRIBUTE
operator delete[](void * ptr,size_t size,std::align_val_t)301 void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT
302 { OPERATOR_DELETE_BODY; }
303
304 #else // SANITIZER_MAC
305
INTERCEPTOR(void *,_Znwm,size_t size)306 INTERCEPTOR(void *, _Znwm, size_t size)
307 { OPERATOR_NEW_BODY(false /*nothrow*/); }
INTERCEPTOR(void *,_Znam,size_t size)308 INTERCEPTOR(void *, _Znam, size_t size)
309 { OPERATOR_NEW_BODY(false /*nothrow*/); }
INTERCEPTOR(void *,_ZnwmRKSt9nothrow_t,size_t size,std::nothrow_t const &)310 INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&)
311 { OPERATOR_NEW_BODY(true /*nothrow*/); }
INTERCEPTOR(void *,_ZnamRKSt9nothrow_t,size_t size,std::nothrow_t const &)312 INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&)
313 { OPERATOR_NEW_BODY(true /*nothrow*/); }
314
INTERCEPTOR(void,_ZdlPv,void * ptr)315 INTERCEPTOR(void, _ZdlPv, void *ptr)
316 { OPERATOR_DELETE_BODY; }
INTERCEPTOR(void,_ZdaPv,void * ptr)317 INTERCEPTOR(void, _ZdaPv, void *ptr)
318 { OPERATOR_DELETE_BODY; }
INTERCEPTOR(void,_ZdlPvRKSt9nothrow_t,void * ptr,std::nothrow_t const &)319 INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
320 { OPERATOR_DELETE_BODY; }
INTERCEPTOR(void,_ZdaPvRKSt9nothrow_t,void * ptr,std::nothrow_t const &)321 INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&)
322 { OPERATOR_DELETE_BODY; }
323
324 #endif // !SANITIZER_MAC
325
326
327 ///// Thread initialization and finalization. /////
328
329 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD && !SANITIZER_FUCHSIA
330 static unsigned g_thread_finalize_key;
331
thread_finalize(void * v)332 static void thread_finalize(void *v) {
333 uptr iter = (uptr)v;
334 if (iter > 1) {
335 if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
336 Report("LeakSanitizer: failed to set thread key.\n");
337 Die();
338 }
339 return;
340 }
341 ThreadFinish();
342 }
343 #endif
344
345 #if SANITIZER_NETBSD
INTERCEPTOR(void,_lwp_exit)346 INTERCEPTOR(void, _lwp_exit) {
347 ENSURE_LSAN_INITED;
348 ThreadFinish();
349 REAL(_lwp_exit)();
350 }
351 #define LSAN_MAYBE_INTERCEPT__LWP_EXIT INTERCEPT_FUNCTION(_lwp_exit)
352 #else
353 #define LSAN_MAYBE_INTERCEPT__LWP_EXIT
354 #endif
355
356 #if SANITIZER_INTERCEPT_THR_EXIT
INTERCEPTOR(void,thr_exit,tid_t * state)357 INTERCEPTOR(void, thr_exit, tid_t *state) {
358 ENSURE_LSAN_INITED;
359 ThreadFinish();
360 REAL(thr_exit)(state);
361 }
362 #define LSAN_MAYBE_INTERCEPT_THR_EXIT INTERCEPT_FUNCTION(thr_exit)
363 #else
364 #define LSAN_MAYBE_INTERCEPT_THR_EXIT
365 #endif
366
367 #if SANITIZER_INTERCEPT___CXA_ATEXIT
INTERCEPTOR(int,__cxa_atexit,void (* func)(void *),void * arg,void * dso_handle)368 INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
369 void *dso_handle) {
370 __lsan::ScopedInterceptorDisabler disabler;
371 return REAL(__cxa_atexit)(func, arg, dso_handle);
372 }
373 #define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT INTERCEPT_FUNCTION(__cxa_atexit)
374 #else
375 #define LSAN_MAYBE_INTERCEPT___CXA_ATEXIT
376 #endif
377
378 #if SANITIZER_INTERCEPT_ATEXIT
INTERCEPTOR(int,atexit,void (* f)())379 INTERCEPTOR(int, atexit, void (*f)()) {
380 __lsan::ScopedInterceptorDisabler disabler;
381 return REAL(__cxa_atexit)((void (*)(void *a))f, 0, 0);
382 }
383 #define LSAN_MAYBE_INTERCEPT_ATEXIT INTERCEPT_FUNCTION(atexit)
384 #else
385 #define LSAN_MAYBE_INTERCEPT_ATEXIT
386 #endif
387
388 #if SANITIZER_INTERCEPT_PTHREAD_ATFORK
389 extern "C" {
390 extern int _pthread_atfork(void (*prepare)(), void (*parent)(),
391 void (*child)());
392 };
393
INTERCEPTOR(int,pthread_atfork,void (* prepare)(),void (* parent)(),void (* child)())394 INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(),
395 void (*child)()) {
396 __lsan::ScopedInterceptorDisabler disabler;
397 // REAL(pthread_atfork) cannot be called due to symbol indirections at least
398 // on NetBSD
399 return _pthread_atfork(prepare, parent, child);
400 }
401 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK INTERCEPT_FUNCTION(pthread_atfork)
402 #else
403 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK
404 #endif
405
406 #if SANITIZER_INTERCEPT_STRERROR
INTERCEPTOR(char *,strerror,int errnum)407 INTERCEPTOR(char *, strerror, int errnum) {
408 __lsan::ScopedInterceptorDisabler disabler;
409 return REAL(strerror)(errnum);
410 }
411 #define LSAN_MAYBE_INTERCEPT_STRERROR INTERCEPT_FUNCTION(strerror)
412 #else
413 #define LSAN_MAYBE_INTERCEPT_STRERROR
414 #endif
415
416 #if SANITIZER_POSIX
417
418 struct ThreadParam {
419 void *(*callback)(void *arg);
420 void *param;
421 atomic_uintptr_t tid;
422 };
423
__lsan_thread_start_func(void * arg)424 extern "C" void *__lsan_thread_start_func(void *arg) {
425 ThreadParam *p = (ThreadParam*)arg;
426 void* (*callback)(void *arg) = p->callback;
427 void *param = p->param;
428 // Wait until the last iteration to maximize the chance that we are the last
429 // destructor to run.
430 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
431 if (pthread_setspecific(g_thread_finalize_key,
432 (void*)GetPthreadDestructorIterations())) {
433 Report("LeakSanitizer: failed to set thread key.\n");
434 Die();
435 }
436 #endif
437 int tid = 0;
438 while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
439 internal_sched_yield();
440 ThreadStart(tid, GetTid());
441 atomic_store(&p->tid, 0, memory_order_release);
442 return callback(param);
443 }
444
INTERCEPTOR(int,pthread_create,void * th,void * attr,void * (* callback)(void *),void * param)445 INTERCEPTOR(int, pthread_create, void *th, void *attr,
446 void *(*callback)(void *), void *param) {
447 ENSURE_LSAN_INITED;
448 EnsureMainThreadIDIsCorrect();
449 __sanitizer_pthread_attr_t myattr;
450 if (!attr) {
451 pthread_attr_init(&myattr);
452 attr = &myattr;
453 }
454 AdjustStackSize(attr);
455 int detached = 0;
456 pthread_attr_getdetachstate(attr, &detached);
457 ThreadParam p;
458 p.callback = callback;
459 p.param = param;
460 atomic_store(&p.tid, 0, memory_order_relaxed);
461 int res;
462 {
463 // Ignore all allocations made by pthread_create: thread stack/TLS may be
464 // stored by pthread for future reuse even after thread destruction, and
465 // the linked list it's stored in doesn't even hold valid pointers to the
466 // objects, the latter are calculated by obscure pointer arithmetic.
467 ScopedInterceptorDisabler disabler;
468 res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
469 }
470 if (res == 0) {
471 int tid = ThreadCreate(GetCurrentThread(), *(uptr *)th,
472 IsStateDetached(detached));
473 CHECK_NE(tid, kMainTid);
474 atomic_store(&p.tid, tid, memory_order_release);
475 while (atomic_load(&p.tid, memory_order_acquire) != 0)
476 internal_sched_yield();
477 }
478 if (attr == &myattr)
479 pthread_attr_destroy(&myattr);
480 return res;
481 }
482
INTERCEPTOR(int,pthread_join,void * th,void ** ret)483 INTERCEPTOR(int, pthread_join, void *th, void **ret) {
484 ENSURE_LSAN_INITED;
485 int tid = ThreadTid((uptr)th);
486 int res = REAL(pthread_join)(th, ret);
487 if (res == 0)
488 ThreadJoin(tid);
489 return res;
490 }
491
INTERCEPTOR(int,pthread_detach,void * th)492 INTERCEPTOR(int, pthread_detach, void *th) {
493 ENSURE_LSAN_INITED;
494 int tid = ThreadTid((uptr)th);
495 int res = REAL(pthread_detach)(th);
496 if (res == 0)
497 ThreadDetach(tid);
498 return res;
499 }
500
INTERCEPTOR(void,_exit,int status)501 INTERCEPTOR(void, _exit, int status) {
502 if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode;
503 REAL(_exit)(status);
504 }
505
506 #define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name)
507 #include "sanitizer_common/sanitizer_signal_interceptors.inc"
508
509 #endif // SANITIZER_POSIX
510
511 namespace __lsan {
512
InitializeInterceptors()513 void InitializeInterceptors() {
514 // Fuchsia doesn't use interceptors that require any setup.
515 #if !SANITIZER_FUCHSIA
516 InitializeSignalInterceptors();
517
518 INTERCEPT_FUNCTION(malloc);
519 INTERCEPT_FUNCTION(free);
520 LSAN_MAYBE_INTERCEPT_CFREE;
521 INTERCEPT_FUNCTION(calloc);
522 INTERCEPT_FUNCTION(realloc);
523 LSAN_MAYBE_INTERCEPT_MEMALIGN;
524 LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN;
525 LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
526 INTERCEPT_FUNCTION(posix_memalign);
527 INTERCEPT_FUNCTION(valloc);
528 LSAN_MAYBE_INTERCEPT_PVALLOC;
529 LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE;
530 LSAN_MAYBE_INTERCEPT_MALLINFO;
531 LSAN_MAYBE_INTERCEPT_MALLOPT;
532 INTERCEPT_FUNCTION(pthread_create);
533 INTERCEPT_FUNCTION(pthread_detach);
534 INTERCEPT_FUNCTION(pthread_join);
535 INTERCEPT_FUNCTION(_exit);
536
537 LSAN_MAYBE_INTERCEPT__LWP_EXIT;
538 LSAN_MAYBE_INTERCEPT_THR_EXIT;
539
540 LSAN_MAYBE_INTERCEPT___CXA_ATEXIT;
541 LSAN_MAYBE_INTERCEPT_ATEXIT;
542 LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK;
543
544 LSAN_MAYBE_INTERCEPT_STRERROR;
545
546 #if !SANITIZER_NETBSD && !SANITIZER_FREEBSD
547 if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
548 Report("LeakSanitizer: failed to create thread key.\n");
549 Die();
550 }
551 #endif
552
553 #endif // !SANITIZER_FUCHSIA
554 }
555
556 } // namespace __lsan
557