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