contrib/compiler-rt/lib/asan/asan_malloc_linux.cc

   1 //===-- asan_malloc_linux.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 AddressSanitizer, an address sanity checker.
  11 //
  12 // Linux-specific malloc interception.
  13 // We simply define functions like malloc, free, realloc, etc.
  14 // They will replace the corresponding libc functions automagically.
  15 //===----------------------------------------------------------------------===//
  16
  17 #include "sanitizer_common/sanitizer_platform.h"
  18 #if SANITIZER_FREEBSD || SANITIZER_LINUX
  19
  20 #include "sanitizer_common/sanitizer_tls_get_addr.h"
  21 #include "asan_allocator.h"
  22 #include "asan_interceptors.h"
  23 #include "asan_internal.h"
  24 #include "asan_stack.h"
  25
  26 // ---------------------- Replacement functions ---------------- {{{1
  27 using namespace __asan;  // NOLINT
  28
  29 static uptr allocated_for_dlsym;
  30 static const uptr kDlsymAllocPoolSize = 1024;
  31 static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
  32
  33 static bool IsInDlsymAllocPool(const void *ptr) {
  34   uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
  35   return off < sizeof(alloc_memory_for_dlsym);
  36 }
  37
  38 static void *AllocateFromLocalPool(uptr size_in_bytes) {
  39   uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
  40   void *mem = (void*)&alloc_memory_for_dlsym[allocated_for_dlsym];
  41   allocated_for_dlsym += size_in_words;
  42   CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
  43   return mem;
  44 }
  45
  46 INTERCEPTOR(void, free, void *ptr) {
  47   GET_STACK_TRACE_FREE;
  48   if (UNLIKELY(IsInDlsymAllocPool(ptr)))
  49     return;
  50   asan_free(ptr, &stack, FROM_MALLOC);
  51 }
  52
  53 INTERCEPTOR(void, cfree, void *ptr) {
  54   GET_STACK_TRACE_FREE;
  55   if (UNLIKELY(IsInDlsymAllocPool(ptr)))
  56     return;
  57   asan_free(ptr, &stack, FROM_MALLOC);
  58 }
  59
  60 INTERCEPTOR(void*, malloc, uptr size) {
  61   if (UNLIKELY(!asan_inited))
  62     // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym.
  63     return AllocateFromLocalPool(size);
  64   GET_STACK_TRACE_MALLOC;
  65   return asan_malloc(size, &stack);
  66 }
  67
  68 INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
  69   if (UNLIKELY(!asan_inited))
  70     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
  71     return AllocateFromLocalPool(nmemb * size);
  72   GET_STACK_TRACE_MALLOC;
  73   return asan_calloc(nmemb, size, &stack);
  74 }
  75
  76 INTERCEPTOR(void*, realloc, void *ptr, uptr size) {
  77   GET_STACK_TRACE_MALLOC;
  78   if (UNLIKELY(IsInDlsymAllocPool(ptr))) {
  79     uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
  80     uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
  81     void *new_ptr = asan_malloc(size, &stack);
  82     internal_memcpy(new_ptr, ptr, copy_size);
  83     return new_ptr;
  84   }
  85   return asan_realloc(ptr, size, &stack);
  86 }
  87
  88 INTERCEPTOR(void*, memalign, uptr boundary, uptr size) {
  89   GET_STACK_TRACE_MALLOC;
  90   return asan_memalign(boundary, size, &stack, FROM_MALLOC);
  91 }
  92
  93 INTERCEPTOR(void*, aligned_alloc, uptr boundary, uptr size) {
  94   GET_STACK_TRACE_MALLOC;
  95   return asan_memalign(boundary, size, &stack, FROM_MALLOC);
  96 }
  97
  98 INTERCEPTOR(void*, __libc_memalign, uptr boundary, uptr size) {
  99   GET_STACK_TRACE_MALLOC;
 100   void *res = asan_memalign(boundary, size, &stack, FROM_MALLOC);
 101   DTLS_on_libc_memalign(res, size);
 102   return res;
 103 }
 104
 105 INTERCEPTOR(uptr, malloc_usable_size, void *ptr) {
 106   GET_CURRENT_PC_BP_SP;
 107   (void)sp;
 108   return asan_malloc_usable_size(ptr, pc, bp);
 109 }
 110
 111 // We avoid including malloc.h for portability reasons.
 112 // man mallinfo says the fields are "long", but the implementation uses int.
 113 // It doesn't matter much -- we just need to make sure that the libc's mallinfo
 114 // is not called.
 115 struct fake_mallinfo {
 116   int x[10];
 117 };
 118
 119 INTERCEPTOR(struct fake_mallinfo, mallinfo, void) {
 120   struct fake_mallinfo res;
 121   REAL(memset)(&res, 0, sizeof(res));
 122   return res;
 123 }
 124
 125 INTERCEPTOR(int, mallopt, int cmd, int value) {
 126   return -1;
 127 }
 128
 129 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
 130   GET_STACK_TRACE_MALLOC;
 131   // Printf("posix_memalign: %zx %zu\n", alignment, size);
 132   return asan_posix_memalign(memptr, alignment, size, &stack);
 133 }
 134
 135 INTERCEPTOR(void*, valloc, uptr size) {
 136   GET_STACK_TRACE_MALLOC;
 137   return asan_valloc(size, &stack);
 138 }
 139
 140 INTERCEPTOR(void*, pvalloc, uptr size) {
 141   GET_STACK_TRACE_MALLOC;
 142   return asan_pvalloc(size, &stack);
 143 }
 144
 145 INTERCEPTOR(void, malloc_stats, void) {
 146   __asan_print_accumulated_stats();
 147 }
 148
 149 #if SANITIZER_ANDROID
 150 // Format of __libc_malloc_dispatch has changed in Android L.
 151 // While we are moving towards a solution that does not depend on bionic
 152 // internals, here is something to support both K* and L releases.
 153 struct MallocDebugK {
 154   void *(*malloc)(uptr bytes);
 155   void (*free)(void *mem);
 156   void *(*calloc)(uptr n_elements, uptr elem_size);
 157   void *(*realloc)(void *oldMem, uptr bytes);
 158   void *(*memalign)(uptr alignment, uptr bytes);
 159   uptr (*malloc_usable_size)(void *mem);
 160 };
 161
 162 struct MallocDebugL {
 163   void *(*calloc)(uptr n_elements, uptr elem_size);
 164   void (*free)(void *mem);
 165   fake_mallinfo (*mallinfo)(void);
 166   void *(*malloc)(uptr bytes);
 167   uptr (*malloc_usable_size)(void *mem);
 168   void *(*memalign)(uptr alignment, uptr bytes);
 169   int (*posix_memalign)(void **memptr, uptr alignment, uptr size);
 170   void* (*pvalloc)(uptr size);
 171   void *(*realloc)(void *oldMem, uptr bytes);
 172   void* (*valloc)(uptr size);
 173 };
 174
 175 ALIGNED(32) const MallocDebugK asan_malloc_dispatch_k = {
 176     WRAP(malloc),  WRAP(free),     WRAP(calloc),
 177     WRAP(realloc), WRAP(memalign), WRAP(malloc_usable_size)};
 178
 179 ALIGNED(32) const MallocDebugL asan_malloc_dispatch_l = {
 180     WRAP(calloc),         WRAP(free),               WRAP(mallinfo),
 181     WRAP(malloc),         WRAP(malloc_usable_size), WRAP(memalign),
 182     WRAP(posix_memalign), WRAP(pvalloc),            WRAP(realloc),
 183     WRAP(valloc)};
 184
 185 namespace __asan {
 186 void ReplaceSystemMalloc() {
 187   void **__libc_malloc_dispatch_p =
 188       (void **)AsanDlSymNext("__libc_malloc_dispatch");
 189   if (__libc_malloc_dispatch_p) {
 190     // Decide on K vs L dispatch format by the presence of
 191     // __libc_malloc_default_dispatch export in libc.
 192     void *default_dispatch_p = AsanDlSymNext("__libc_malloc_default_dispatch");
 193     if (default_dispatch_p)
 194       *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_k;
 195     else
 196       *__libc_malloc_dispatch_p = (void *)&asan_malloc_dispatch_l;
 197   }
 198 }
 199 }  // namespace __asan
 200
 201 #else  // SANITIZER_ANDROID
 202
 203 namespace __asan {
 204 void ReplaceSystemMalloc() {
 205 }
 206 }  // namespace __asan
 207 #endif  // SANITIZER_ANDROID
 208
 209 #endif  // SANITIZER_FREEBSD || SANITIZER_LINUX