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 37using namespace __lsan; 38 39extern "C" { 40int pthread_attr_init(void *attr); 41int pthread_attr_destroy(void *attr); 42int pthread_attr_getdetachstate(void *attr, int *v); 43int pthread_key_create(unsigned *key, void (*destructor)(void* v)); 44int pthread_setspecific(unsigned key, const void *v); 45} 46 47struct DlsymAlloc : DlSymAllocator<DlsymAlloc> { 48 static bool UseImpl() { return lsan_init_is_running; } 49 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 } 56 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 65namespace std { 66 struct nothrow_t; 67 enum class align_val_t: size_t; 68} 69 70#if !SANITIZER_APPLE 71INTERCEPTOR(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 79INTERCEPTOR(void, free, void *p) { 80 if (DlsymAlloc::PointerIsMine(p)) 81 return DlsymAlloc::Free(p); 82 ENSURE_LSAN_INITED; 83 lsan_free(p); 84} 85 86INTERCEPTOR(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 94INTERCEPTOR(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 102INTERCEPTOR(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 108INTERCEPTOR(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 114INTERCEPTOR(void*, valloc, uptr size) { 115 ENSURE_LSAN_INITED; 116 GET_STACK_TRACE_MALLOC; 117 return lsan_valloc(size, stack); 118} 119#endif // !SANITIZER_APPLE 120 121#if SANITIZER_INTERCEPT_MEMALIGN 122INTERCEPTOR(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 133INTERCEPTOR(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 146INTERCEPTOR(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 157INTERCEPTOR(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 168struct fake_mallinfo { 169 int x[10]; 170}; 171 172INTERCEPTOR(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 179INTERCEPTOR(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 189INTERCEPTOR(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 200INTERCEPTOR(void, cfree, void *p) ALIAS(WRAP(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 207INTERCEPTOR(int, mcheck, void (*abortfunc)(int mstatus)) { 208 return 0; 209} 210 211INTERCEPTOR(int, mcheck_pedantic, void (*abortfunc)(int mstatus)) { 212 return 0; 213} 214 215INTERCEPTOR(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_APPLE 246 247INTERCEPTOR_ATTRIBUTE 248void *operator new(size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); } 249INTERCEPTOR_ATTRIBUTE 250void *operator new[](size_t size) { OPERATOR_NEW_BODY(false /*nothrow*/); } 251INTERCEPTOR_ATTRIBUTE 252void *operator new(size_t size, std::nothrow_t const&) 253{ OPERATOR_NEW_BODY(true /*nothrow*/); } 254INTERCEPTOR_ATTRIBUTE 255void *operator new[](size_t size, std::nothrow_t const&) 256{ OPERATOR_NEW_BODY(true /*nothrow*/); } 257INTERCEPTOR_ATTRIBUTE 258void *operator new(size_t size, std::align_val_t align) 259{ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); } 260INTERCEPTOR_ATTRIBUTE 261void *operator new[](size_t size, std::align_val_t align) 262{ OPERATOR_NEW_BODY_ALIGN(false /*nothrow*/); } 263INTERCEPTOR_ATTRIBUTE 264void *operator new(size_t size, std::align_val_t align, std::nothrow_t const&) 265{ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); } 266INTERCEPTOR_ATTRIBUTE 267void *operator new[](size_t size, std::align_val_t align, std::nothrow_t const&) 268{ OPERATOR_NEW_BODY_ALIGN(true /*nothrow*/); } 269 270INTERCEPTOR_ATTRIBUTE 271void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; } 272INTERCEPTOR_ATTRIBUTE 273void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; } 274INTERCEPTOR_ATTRIBUTE 275void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; } 276INTERCEPTOR_ATTRIBUTE 277void operator delete[](void *ptr, std::nothrow_t const &) 278{ OPERATOR_DELETE_BODY; } 279INTERCEPTOR_ATTRIBUTE 280void operator delete(void *ptr, size_t size) NOEXCEPT 281{ OPERATOR_DELETE_BODY; } 282INTERCEPTOR_ATTRIBUTE 283void operator delete[](void *ptr, size_t size) NOEXCEPT 284{ OPERATOR_DELETE_BODY; } 285INTERCEPTOR_ATTRIBUTE 286void operator delete(void *ptr, std::align_val_t) NOEXCEPT 287{ OPERATOR_DELETE_BODY; } 288INTERCEPTOR_ATTRIBUTE 289void operator delete[](void *ptr, std::align_val_t) NOEXCEPT 290{ OPERATOR_DELETE_BODY; } 291INTERCEPTOR_ATTRIBUTE 292void operator delete(void *ptr, std::align_val_t, std::nothrow_t const&) 293{ OPERATOR_DELETE_BODY; } 294INTERCEPTOR_ATTRIBUTE 295void operator delete[](void *ptr, std::align_val_t, std::nothrow_t const&) 296{ OPERATOR_DELETE_BODY; } 297INTERCEPTOR_ATTRIBUTE 298void operator delete(void *ptr, size_t size, std::align_val_t) NOEXCEPT 299{ OPERATOR_DELETE_BODY; } 300INTERCEPTOR_ATTRIBUTE 301void operator delete[](void *ptr, size_t size, std::align_val_t) NOEXCEPT 302{ OPERATOR_DELETE_BODY; } 303 304#else // SANITIZER_APPLE 305 306INTERCEPTOR(void *, _Znwm, size_t size) 307{ OPERATOR_NEW_BODY(false /*nothrow*/); } 308INTERCEPTOR(void *, _Znam, size_t size) 309{ OPERATOR_NEW_BODY(false /*nothrow*/); } 310INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&) 311{ OPERATOR_NEW_BODY(true /*nothrow*/); } 312INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) 313{ OPERATOR_NEW_BODY(true /*nothrow*/); } 314 315INTERCEPTOR(void, _ZdlPv, void *ptr) 316{ OPERATOR_DELETE_BODY; } 317INTERCEPTOR(void, _ZdaPv, void *ptr) 318{ OPERATOR_DELETE_BODY; } 319INTERCEPTOR(void, _ZdlPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) 320{ OPERATOR_DELETE_BODY; } 321INTERCEPTOR(void, _ZdaPvRKSt9nothrow_t, void *ptr, std::nothrow_t const&) 322{ OPERATOR_DELETE_BODY; } 323 324#endif // !SANITIZER_APPLE 325 326 327///// Thread initialization and finalization. ///// 328 329#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD && !SANITIZER_FUCHSIA 330static unsigned g_thread_finalize_key; 331 332static 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 346INTERCEPTOR(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 357INTERCEPTOR(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 368INTERCEPTOR(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 379INTERCEPTOR(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 389extern "C" { 390extern int _pthread_atfork(void (*prepare)(), void (*parent)(), 391 void (*child)()); 392}; 393 394INTERCEPTOR(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 407INTERCEPTOR(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 418template <bool Detached> 419static void *ThreadStartFunc(void *arg) { 420 u32 parent_tid = (uptr)arg; 421 uptr tid = ThreadCreate(parent_tid, Detached); 422 // Wait until the last iteration to maximize the chance that we are the last 423 // destructor to run. 424#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD 425 if (pthread_setspecific(g_thread_finalize_key, 426 (void*)GetPthreadDestructorIterations())) { 427 Report("LeakSanitizer: failed to set thread key.\n"); 428 Die(); 429 } 430# endif 431 ThreadStart(tid, GetTid()); 432 auto self = GetThreadSelf(); 433 auto args = GetThreadArgRetval().GetArgs(self); 434 void *retval = (*args.routine)(args.arg_retval); 435 GetThreadArgRetval().Finish(self, retval); 436 return retval; 437} 438 439INTERCEPTOR(int, pthread_create, void *th, void *attr, 440 void *(*callback)(void *), void *param) { 441 ENSURE_LSAN_INITED; 442 EnsureMainThreadIDIsCorrect(); 443 444 bool detached = [attr]() { 445 int d = 0; 446 return attr && !pthread_attr_getdetachstate(attr, &d) && IsStateDetached(d); 447 }(); 448 449 __sanitizer_pthread_attr_t myattr; 450 if (!attr) { 451 pthread_attr_init(&myattr); 452 attr = &myattr; 453 } 454 AdjustStackSize(attr); 455 uptr this_tid = GetCurrentThreadId(); 456 int result; 457 { 458 // Ignore all allocations made by pthread_create: thread stack/TLS may be 459 // stored by pthread for future reuse even after thread destruction, and 460 // the linked list it's stored in doesn't even hold valid pointers to the 461 // objects, the latter are calculated by obscure pointer arithmetic. 462 ScopedInterceptorDisabler disabler; 463 GetThreadArgRetval().Create(detached, {callback, param}, [&]() -> uptr { 464 result = REAL(pthread_create)( 465 th, attr, detached ? ThreadStartFunc<true> : ThreadStartFunc<false>, 466 (void *)this_tid); 467 return result ? 0 : *(uptr *)(th); 468 }); 469 } 470 if (attr == &myattr) 471 pthread_attr_destroy(&myattr); 472 return result; 473} 474 475INTERCEPTOR(int, pthread_join, void *thread, void **retval) { 476 int result; 477 GetThreadArgRetval().Join((uptr)thread, [&]() { 478 result = REAL(pthread_join)(thread, retval); 479 return !result; 480 }); 481 return result; 482} 483 484INTERCEPTOR(int, pthread_detach, void *thread) { 485 int result; 486 GetThreadArgRetval().Detach((uptr)thread, [&]() { 487 result = REAL(pthread_detach)(thread); 488 return !result; 489 }); 490 return result; 491} 492 493INTERCEPTOR(void, pthread_exit, void *retval) { 494 GetThreadArgRetval().Finish(GetThreadSelf(), retval); 495 REAL(pthread_exit)(retval); 496} 497 498# if SANITIZER_INTERCEPT_TRYJOIN 499INTERCEPTOR(int, pthread_tryjoin_np, void *thread, void **ret) { 500 int result; 501 GetThreadArgRetval().Join((uptr)thread, [&]() { 502 result = REAL(pthread_tryjoin_np)(thread, ret); 503 return !result; 504 }); 505 return result; 506} 507# define LSAN_MAYBE_INTERCEPT_TRYJOIN INTERCEPT_FUNCTION(pthread_tryjoin_np) 508# else 509# define LSAN_MAYBE_INTERCEPT_TRYJOIN 510# endif // SANITIZER_INTERCEPT_TRYJOIN 511 512# if SANITIZER_INTERCEPT_TIMEDJOIN 513INTERCEPTOR(int, pthread_timedjoin_np, void *thread, void **ret, 514 const struct timespec *abstime) { 515 int result; 516 GetThreadArgRetval().Join((uptr)thread, [&]() { 517 result = REAL(pthread_timedjoin_np)(thread, ret, abstime); 518 return !result; 519 }); 520 return result; 521} 522# define LSAN_MAYBE_INTERCEPT_TIMEDJOIN \ 523 INTERCEPT_FUNCTION(pthread_timedjoin_np) 524# else 525# define LSAN_MAYBE_INTERCEPT_TIMEDJOIN 526# endif // SANITIZER_INTERCEPT_TIMEDJOIN 527 528DEFINE_REAL_PTHREAD_FUNCTIONS 529 530INTERCEPTOR(void, _exit, int status) { 531 if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode; 532 REAL(_exit)(status); 533} 534 535#define COMMON_INTERCEPT_FUNCTION(name) INTERCEPT_FUNCTION(name) 536#define SIGNAL_INTERCEPTOR_ENTER() ENSURE_LSAN_INITED 537#include "sanitizer_common/sanitizer_signal_interceptors.inc" 538 539#endif // SANITIZER_POSIX 540 541namespace __lsan { 542 543void InitializeInterceptors() { 544 // Fuchsia doesn't use interceptors that require any setup. 545#if !SANITIZER_FUCHSIA 546 InitializeSignalInterceptors(); 547 548 INTERCEPT_FUNCTION(malloc); 549 INTERCEPT_FUNCTION(free); 550 LSAN_MAYBE_INTERCEPT_CFREE; 551 INTERCEPT_FUNCTION(calloc); 552 INTERCEPT_FUNCTION(realloc); 553 LSAN_MAYBE_INTERCEPT_MEMALIGN; 554 LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN; 555 LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC; 556 INTERCEPT_FUNCTION(posix_memalign); 557 INTERCEPT_FUNCTION(valloc); 558 LSAN_MAYBE_INTERCEPT_PVALLOC; 559 LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE; 560 LSAN_MAYBE_INTERCEPT_MALLINFO; 561 LSAN_MAYBE_INTERCEPT_MALLOPT; 562 INTERCEPT_FUNCTION(pthread_create); 563 INTERCEPT_FUNCTION(pthread_join); 564 INTERCEPT_FUNCTION(pthread_detach); 565 INTERCEPT_FUNCTION(pthread_exit); 566 LSAN_MAYBE_INTERCEPT_TIMEDJOIN; 567 LSAN_MAYBE_INTERCEPT_TRYJOIN; 568 INTERCEPT_FUNCTION(_exit); 569 570 LSAN_MAYBE_INTERCEPT__LWP_EXIT; 571 LSAN_MAYBE_INTERCEPT_THR_EXIT; 572 573 LSAN_MAYBE_INTERCEPT___CXA_ATEXIT; 574 LSAN_MAYBE_INTERCEPT_ATEXIT; 575 LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK; 576 577 LSAN_MAYBE_INTERCEPT_STRERROR; 578 579#if !SANITIZER_NETBSD && !SANITIZER_FREEBSD 580 if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) { 581 Report("LeakSanitizer: failed to create thread key.\n"); 582 Die(); 583 } 584#endif 585 586#endif // !SANITIZER_FUCHSIA 587} 588 589} // namespace __lsan 590