Home | History | Annotate | Download | only in lsan 
      1 //=-- lsan_interceptors.cc ------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file is a part of LeakSanitizer.
     11 // Interceptors for standalone LSan.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "interception/interception.h"
     16 #include "sanitizer_common/sanitizer_allocator.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_limits_posix.h"
     23 #include "lsan.h"
     24 #include "lsan_allocator.h"
     25 #include "lsan_thread.h"
     26 
     27 using namespace __lsan;
     28 
     29 extern "C" {
     30 int pthread_attr_init(void *attr);
     31 int pthread_attr_destroy(void *attr);
     32 int pthread_attr_getdetachstate(void *attr, int *v);
     33 int pthread_key_create(unsigned *key, void (*destructor)(void* v));
     34 int pthread_setspecific(unsigned key, const void *v);
     35 }
     36 
     37 #define ENSURE_LSAN_INITED do {   \
     38   CHECK(!lsan_init_is_running);   \
     39   if (!lsan_inited)               \
     40     __lsan_init();                \
     41 } while (0)
     42 
     43 ///// Malloc/free interceptors. /////
     44 
     45 const bool kAlwaysClearMemory = true;
     46 
     47 namespace std {
     48   struct nothrow_t;
     49 }
     50 
     51 INTERCEPTOR(void*, malloc, uptr size) {
     52   ENSURE_LSAN_INITED;
     53   GET_STACK_TRACE_MALLOC;
     54   return Allocate(stack, size, 1, kAlwaysClearMemory);
     55 }
     56 
     57 INTERCEPTOR(void, free, void *p) {
     58   ENSURE_LSAN_INITED;
     59   Deallocate(p);
     60 }
     61 
     62 INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
     63   if (lsan_init_is_running) {
     64     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
     65     const uptr kCallocPoolSize = 1024;
     66     static uptr calloc_memory_for_dlsym[kCallocPoolSize];
     67     static uptr allocated;
     68     uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
     69     void *mem = (void*)&calloc_memory_for_dlsym[allocated];
     70     allocated += size_in_words;
     71     CHECK(allocated < kCallocPoolSize);
     72     return mem;
     73   }
     74   if (CallocShouldReturnNullDueToOverflow(size, nmemb)) return nullptr;
     75   ENSURE_LSAN_INITED;
     76   GET_STACK_TRACE_MALLOC;
     77   size *= nmemb;
     78   return Allocate(stack, size, 1, true);
     79 }
     80 
     81 INTERCEPTOR(void*, realloc, void *q, uptr size) {
     82   ENSURE_LSAN_INITED;
     83   GET_STACK_TRACE_MALLOC;
     84   return Reallocate(stack, q, size, 1);
     85 }
     86 
     87 INTERCEPTOR(void*, memalign, uptr alignment, uptr size) {
     88   ENSURE_LSAN_INITED;
     89   GET_STACK_TRACE_MALLOC;
     90   return Allocate(stack, size, alignment, kAlwaysClearMemory);
     91 }
     92 
     93 INTERCEPTOR(void*, aligned_alloc, uptr alignment, uptr size) {
     94   ENSURE_LSAN_INITED;
     95   GET_STACK_TRACE_MALLOC;
     96   return Allocate(stack, size, alignment, kAlwaysClearMemory);
     97 }
     98 
     99 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
    100   ENSURE_LSAN_INITED;
    101   GET_STACK_TRACE_MALLOC;
    102   *memptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
    103   // FIXME: Return ENOMEM if user requested more than max alloc size.
    104   return 0;
    105 }
    106 
    107 INTERCEPTOR(void*, valloc, uptr size) {
    108   ENSURE_LSAN_INITED;
    109   GET_STACK_TRACE_MALLOC;
    110   if (size == 0)
    111     size = GetPageSizeCached();
    112   return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
    113 }
    114 
    115 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
    116   ENSURE_LSAN_INITED;
    117   return GetMallocUsableSize(ptr);
    118 }
    119 
    120 struct fake_mallinfo {
    121   int x[10];
    122 };
    123 
    124 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
    125   struct fake_mallinfo res;
    126   internal_memset(&res, 0, sizeof(res));
    127   return res;
    128 }
    129 
    130 INTERCEPTOR(int, mallopt, int cmd, int value) {
    131   return -1;
    132 }
    133 
    134 INTERCEPTOR(void*, pvalloc, uptr size) {
    135   ENSURE_LSAN_INITED;
    136   GET_STACK_TRACE_MALLOC;
    137   uptr PageSize = GetPageSizeCached();
    138   size = RoundUpTo(size, PageSize);
    139   if (size == 0) {
    140     // pvalloc(0) should allocate one page.
    141     size = PageSize;
    142   }
    143   return Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory);
    144 }
    145 
    146 INTERCEPTOR(void, cfree, void *p) ALIAS(WRAPPER_NAME(free));
    147 
    148 #define OPERATOR_NEW_BODY                              \
    149   ENSURE_LSAN_INITED;                                  \
    150   GET_STACK_TRACE_MALLOC;                              \
    151   return Allocate(stack, size, 1, kAlwaysClearMemory);
    152 
    153 INTERCEPTOR_ATTRIBUTE
    154 void *operator new(uptr size) { OPERATOR_NEW_BODY; }
    155 INTERCEPTOR_ATTRIBUTE
    156 void *operator new[](uptr size) { OPERATOR_NEW_BODY; }
    157 INTERCEPTOR_ATTRIBUTE
    158 void *operator new(uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
    159 INTERCEPTOR_ATTRIBUTE
    160 void *operator new[](uptr size, std::nothrow_t const&) { OPERATOR_NEW_BODY; }
    161 
    162 #define OPERATOR_DELETE_BODY \
    163   ENSURE_LSAN_INITED;        \
    164   Deallocate(ptr);
    165 
    166 INTERCEPTOR_ATTRIBUTE
    167 void operator delete(void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
    168 INTERCEPTOR_ATTRIBUTE
    169 void operator delete[](void *ptr) NOEXCEPT { OPERATOR_DELETE_BODY; }
    170 INTERCEPTOR_ATTRIBUTE
    171 void operator delete(void *ptr, std::nothrow_t const&) { OPERATOR_DELETE_BODY; }
    172 INTERCEPTOR_ATTRIBUTE
    173 void operator delete[](void *ptr, std::nothrow_t const &) {
    174   OPERATOR_DELETE_BODY;
    175 }
    176 
    177 // We need this to intercept the __libc_memalign calls that are used to
    178 // allocate dynamic TLS space in ld-linux.so.
    179 INTERCEPTOR(void *, __libc_memalign, uptr align, uptr s)
    180     ALIAS(WRAPPER_NAME(memalign));
    181 
    182 ///// Thread initialization and finalization. /////
    183 
    184 static unsigned g_thread_finalize_key;
    185 
    186 static void thread_finalize(void *v) {
    187   uptr iter = (uptr)v;
    188   if (iter > 1) {
    189     if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
    190       Report("LeakSanitizer: failed to set thread key.\n");
    191       Die();
    192     }
    193     return;
    194   }
    195   ThreadFinish();
    196 }
    197 
    198 struct ThreadParam {
    199   void *(*callback)(void *arg);
    200   void *param;
    201   atomic_uintptr_t tid;
    202 };
    203 
    204 extern "C" void *__lsan_thread_start_func(void *arg) {
    205   ThreadParam *p = (ThreadParam*)arg;
    206   void* (*callback)(void *arg) = p->callback;
    207   void *param = p->param;
    208   // Wait until the last iteration to maximize the chance that we are the last
    209   // destructor to run.
    210   if (pthread_setspecific(g_thread_finalize_key,
    211                           (void*)GetPthreadDestructorIterations())) {
    212     Report("LeakSanitizer: failed to set thread key.\n");
    213     Die();
    214   }
    215   int tid = 0;
    216   while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
    217     internal_sched_yield();
    218   SetCurrentThread(tid);
    219   ThreadStart(tid, GetTid());
    220   atomic_store(&p->tid, 0, memory_order_release);
    221   return callback(param);
    222 }
    223 
    224 INTERCEPTOR(int, pthread_create, void *th, void *attr,
    225             void *(*callback)(void *), void *param) {
    226   ENSURE_LSAN_INITED;
    227   EnsureMainThreadIDIsCorrect();
    228   __sanitizer_pthread_attr_t myattr;
    229   if (!attr) {
    230     pthread_attr_init(&myattr);
    231     attr = &myattr;
    232   }
    233   AdjustStackSize(attr);
    234   int detached = 0;
    235   pthread_attr_getdetachstate(attr, &detached);
    236   ThreadParam p;
    237   p.callback = callback;
    238   p.param = param;
    239   atomic_store(&p.tid, 0, memory_order_relaxed);
    240   int res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
    241   if (res == 0) {
    242     int tid = ThreadCreate(GetCurrentThread(), *(uptr *)th, detached);
    243     CHECK_NE(tid, 0);
    244     atomic_store(&p.tid, tid, memory_order_release);
    245     while (atomic_load(&p.tid, memory_order_acquire) != 0)
    246       internal_sched_yield();
    247   }
    248   if (attr == &myattr)
    249     pthread_attr_destroy(&myattr);
    250   return res;
    251 }
    252 
    253 INTERCEPTOR(int, pthread_join, void *th, void **ret) {
    254   ENSURE_LSAN_INITED;
    255   int tid = ThreadTid((uptr)th);
    256   int res = REAL(pthread_join)(th, ret);
    257   if (res == 0)
    258     ThreadJoin(tid);
    259   return res;
    260 }
    261 
    262 namespace __lsan {
    263 
    264 void InitializeInterceptors() {
    265   INTERCEPT_FUNCTION(malloc);
    266   INTERCEPT_FUNCTION(free);
    267   INTERCEPT_FUNCTION(cfree);
    268   INTERCEPT_FUNCTION(calloc);
    269   INTERCEPT_FUNCTION(realloc);
    270   INTERCEPT_FUNCTION(memalign);
    271   INTERCEPT_FUNCTION(posix_memalign);
    272   INTERCEPT_FUNCTION(__libc_memalign);
    273   INTERCEPT_FUNCTION(valloc);
    274   INTERCEPT_FUNCTION(pvalloc);
    275   INTERCEPT_FUNCTION(malloc_usable_size);
    276   INTERCEPT_FUNCTION(mallinfo);
    277   INTERCEPT_FUNCTION(mallopt);
    278   INTERCEPT_FUNCTION(pthread_create);
    279   INTERCEPT_FUNCTION(pthread_join);
    280 
    281   if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
    282     Report("LeakSanitizer: failed to create thread key.\n");
    283     Die();
    284   }
    285 }
    286 
    287 } // namespace __lsan
    288