contrib/compiler-rt/lib/lsan/lsan_interceptors.cc

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