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