libsanitizer/lsan/lsan_allocator.cc

   1 //=-- lsan_allocator.cc ---------------------------------------------------===//
   2 //
   3 // This file is distributed under the University of Illinois Open Source
   4 // License. See LICENSE.TXT for details.
   5 //
   6 //===----------------------------------------------------------------------===//
   7 //
   8 // This file is a part of LeakSanitizer.
   9 // See lsan_allocator.h for details.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "lsan_allocator.h"
  14
  15 #include "sanitizer_common/sanitizer_allocator.h"
  16 #include "sanitizer_common/sanitizer_allocator_checks.h"
  17 #include "sanitizer_common/sanitizer_allocator_interface.h"
  18 #include "sanitizer_common/sanitizer_errno.h"
  19 #include "sanitizer_common/sanitizer_internal_defs.h"
  20 #include "sanitizer_common/sanitizer_stackdepot.h"
  21 #include "sanitizer_common/sanitizer_stacktrace.h"
  22 #include "lsan_common.h"
  23
  24 extern "C" void *memset(void *ptr, int value, uptr num);
  25
  26 namespace __lsan {
  27 #if defined(__i386__) || defined(__arm__)
  28 static const uptr kMaxAllowedMallocSize = 1UL << 30;
  29 #elif defined(__mips64) || defined(__aarch64__)
  30 static const uptr kMaxAllowedMallocSize = 4UL << 30;
  31 #else
  32 static const uptr kMaxAllowedMallocSize = 8UL << 30;
  33 #endif
  34 typedef LargeMmapAllocator<> SecondaryAllocator;
  35 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
  36           SecondaryAllocator> Allocator;
  37
  38 static Allocator allocator;
  39
  40 void InitializeAllocator() {
  41   SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null);
  42   allocator.InitLinkerInitialized(
  43       common_flags()->allocator_release_to_os_interval_ms);
  44 }
  45
  46 void AllocatorThreadFinish() {
  47   allocator.SwallowCache(GetAllocatorCache());
  48 }
  49
  50 static ChunkMetadata *Metadata(const void *p) {
  51   return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
  52 }
  53
  54 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
  55   if (!p) return;
  56   ChunkMetadata *m = Metadata(p);
  57   CHECK(m);
  58   m->tag = DisabledInThisThread() ? kIgnored : kDirectlyLeaked;
  59   m->stack_trace_id = StackDepotPut(stack);
  60   m->requested_size = size;
  61   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed);
  62 }
  63
  64 static void RegisterDeallocation(void *p) {
  65   if (!p) return;
  66   ChunkMetadata *m = Metadata(p);
  67   CHECK(m);
  68   atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed);
  69 }
  70
  71 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
  72                bool cleared) {
  73   if (size == 0)
  74     size = 1;
  75   if (size > kMaxAllowedMallocSize) {
  76     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size);
  77     return Allocator::FailureHandler::OnBadRequest();
  78   }
  79   void *p = allocator.Allocate(GetAllocatorCache(), size, alignment);
  80   // Do not rely on the allocator to clear the memory (it's slow).
  81   if (cleared && allocator.FromPrimary(p))
  82     memset(p, 0, size);
  83   RegisterAllocation(stack, p, size);
  84   if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
  85   RunMallocHooks(p, size);
  86   return p;
  87 }
  88
  89 static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) {
  90   if (UNLIKELY(CheckForCallocOverflow(size, nmemb)))
  91     return Allocator::FailureHandler::OnBadRequest();
  92   size *= nmemb;
  93   return Allocate(stack, size, 1, true);
  94 }
  95
  96 void Deallocate(void *p) {
  97   if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
  98   RunFreeHooks(p);
  99   RegisterDeallocation(p);
 100   allocator.Deallocate(GetAllocatorCache(), p);
 101 }
 102
 103 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
 104                  uptr alignment) {
 105   RegisterDeallocation(p);
 106   if (new_size > kMaxAllowedMallocSize) {
 107     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", new_size);
 108     allocator.Deallocate(GetAllocatorCache(), p);
 109     return Allocator::FailureHandler::OnBadRequest();
 110   }
 111   p = allocator.Reallocate(GetAllocatorCache(), p, new_size, alignment);
 112   RegisterAllocation(stack, p, new_size);
 113   return p;
 114 }
 115
 116 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
 117   *begin = (uptr)GetAllocatorCache();
 118   *end = *begin + sizeof(AllocatorCache);
 119 }
 120
 121 uptr GetMallocUsableSize(const void *p) {
 122   ChunkMetadata *m = Metadata(p);
 123   if (!m) return 0;
 124   return m->requested_size;
 125 }
 126
 127 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
 128   if (UNLIKELY(!IsPowerOfTwo(alignment))) {
 129     errno = errno_EINVAL;
 130     return Allocator::FailureHandler::OnBadRequest();
 131   }
 132   return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
 133 }
 134
 135 void *lsan_malloc(uptr size, const StackTrace &stack) {
 136   return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory));
 137 }
 138
 139 void lsan_free(void *p) {
 140   Deallocate(p);
 141 }
 142
 143 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) {
 144   return SetErrnoOnNull(Reallocate(stack, p, size, 1));
 145 }
 146
 147 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
 148   return SetErrnoOnNull(Calloc(nmemb, size, stack));
 149 }
 150
 151 void *lsan_valloc(uptr size, const StackTrace &stack) {
 152   return SetErrnoOnNull(
 153       Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory));
 154 }
 155
 156 uptr lsan_mz_size(const void *p) {
 157   return GetMallocUsableSize(p);
 158 }
 159
 160 ///// Interface to the common LSan module. /////
 161
 162 void LockAllocator() {
 163   allocator.ForceLock();
 164 }
 165
 166 void UnlockAllocator() {
 167   allocator.ForceUnlock();
 168 }
 169
 170 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
 171   *begin = (uptr)&allocator;
 172   *end = *begin + sizeof(allocator);
 173 }
 174
 175 uptr PointsIntoChunk(void* p) {
 176   uptr addr = reinterpret_cast<uptr>(p);
 177   uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p));
 178   if (!chunk) return 0;
 179   // LargeMmapAllocator considers pointers to the meta-region of a chunk to be
 180   // valid, but we don't want that.
 181   if (addr < chunk) return 0;
 182   ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk));
 183   CHECK(m);
 184   if (!m->allocated)
 185     return 0;
 186   if (addr < chunk + m->requested_size)
 187     return chunk;
 188   if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr))
 189     return chunk;
 190   return 0;
 191 }
 192
 193 uptr GetUserBegin(uptr chunk) {
 194   return chunk;
 195 }
 196
 197 LsanMetadata::LsanMetadata(uptr chunk) {
 198   metadata_ = Metadata(reinterpret_cast<void *>(chunk));
 199   CHECK(metadata_);
 200 }
 201
 202 bool LsanMetadata::allocated() const {
 203   return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
 204 }
 205
 206 ChunkTag LsanMetadata::tag() const {
 207   return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
 208 }
 209
 210 void LsanMetadata::set_tag(ChunkTag value) {
 211   reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
 212 }
 213
 214 uptr LsanMetadata::requested_size() const {
 215   return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
 216 }
 217
 218 u32 LsanMetadata::stack_trace_id() const {
 219   return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
 220 }
 221
 222 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
 223   allocator.ForEachChunk(callback, arg);
 224 }
 225
 226 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
 227   void *chunk = allocator.GetBlockBegin(p);
 228   if (!chunk || p < chunk) return kIgnoreObjectInvalid;
 229   ChunkMetadata *m = Metadata(chunk);
 230   CHECK(m);
 231   if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
 232     if (m->tag == kIgnored)
 233       return kIgnoreObjectAlreadyIgnored;
 234     m->tag = kIgnored;
 235     return kIgnoreObjectSuccess;
 236   } else {
 237     return kIgnoreObjectInvalid;
 238   }
 239 }
 240 } // namespace __lsan
 241
 242 using namespace __lsan;
 243
 244 extern "C" {
 245 SANITIZER_INTERFACE_ATTRIBUTE
 246 uptr __sanitizer_get_current_allocated_bytes() {
 247   uptr stats[AllocatorStatCount];
 248   allocator.GetStats(stats);
 249   return stats[AllocatorStatAllocated];
 250 }
 251
 252 SANITIZER_INTERFACE_ATTRIBUTE
 253 uptr __sanitizer_get_heap_size() {
 254   uptr stats[AllocatorStatCount];
 255   allocator.GetStats(stats);
 256   return stats[AllocatorStatMapped];
 257 }
 258
 259 SANITIZER_INTERFACE_ATTRIBUTE
 260 uptr __sanitizer_get_free_bytes() { return 0; }
 261
 262 SANITIZER_INTERFACE_ATTRIBUTE
 263 uptr __sanitizer_get_unmapped_bytes() { return 0; }
 264
 265 SANITIZER_INTERFACE_ATTRIBUTE
 266 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 267
 268 SANITIZER_INTERFACE_ATTRIBUTE
 269 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 270
 271 SANITIZER_INTERFACE_ATTRIBUTE
 272 uptr __sanitizer_get_allocated_size(const void *p) {
 273   return GetMallocUsableSize(p);
 274 }
 275
 276 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 277 // Provide default (no-op) implementation of malloc hooks.
 278 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 279 void __sanitizer_malloc_hook(void *ptr, uptr size) {
 280   (void)ptr;
 281   (void)size;
 282 }
 283 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 284 void __sanitizer_free_hook(void *ptr) {
 285   (void)ptr;
 286 }
 287 #endif
 288 } // extern "C"