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

   1 //=-- lsan_allocator.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 // See lsan_allocator.h for details.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "lsan_allocator.h"
  16
  17 #include "sanitizer_common/sanitizer_allocator.h"
  18 #include "sanitizer_common/sanitizer_allocator_checks.h"
  19 #include "sanitizer_common/sanitizer_allocator_interface.h"
  20 #include "sanitizer_common/sanitizer_allocator_report.h"
  21 #include "sanitizer_common/sanitizer_errno.h"
  22 #include "sanitizer_common/sanitizer_internal_defs.h"
  23 #include "sanitizer_common/sanitizer_stackdepot.h"
  24 #include "sanitizer_common/sanitizer_stacktrace.h"
  25 #include "lsan_common.h"
  26
  27 extern "C" void *memset(void *ptr, int value, uptr num);
  28
  29 namespace __lsan {
  30 #if defined(__i386__) || defined(__arm__)
  31 static const uptr kMaxAllowedMallocSize = 1UL << 30;
  32 #elif defined(__mips64) || defined(__aarch64__)
  33 static const uptr kMaxAllowedMallocSize = 4UL << 30;
  34 #else
  35 static const uptr kMaxAllowedMallocSize = 8UL << 30;
  36 #endif
  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 static void *ReportAllocationSizeTooBig(uptr size, const StackTrace &stack) {
  72   if (AllocatorMayReturnNull()) {
  73     Report("WARNING: LeakSanitizer failed to allocate 0x%zx bytes\n", size);
  74     return nullptr;
  75   }
  76   ReportAllocationSizeTooBig(size, kMaxAllowedMallocSize, &stack);
  77 }
  78
  79 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
  80                bool cleared) {
  81   if (size == 0)
  82     size = 1;
  83   if (size > kMaxAllowedMallocSize)
  84     return ReportAllocationSizeTooBig(size, stack);
  85   void *p = allocator.Allocate(GetAllocatorCache(), size, alignment);
  86   if (UNLIKELY(!p)) {
  87     SetAllocatorOutOfMemory();
  88     if (AllocatorMayReturnNull())
  89       return nullptr;
  90     ReportOutOfMemory(size, &stack);
  91   }
  92   // Do not rely on the allocator to clear the memory (it's slow).
  93   if (cleared && allocator.FromPrimary(p))
  94     memset(p, 0, size);
  95   RegisterAllocation(stack, p, size);
  96   if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
  97   RunMallocHooks(p, size);
  98   return p;
  99 }
 100
 101 static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) {
 102   if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
 103     if (AllocatorMayReturnNull())
 104       return nullptr;
 105     ReportCallocOverflow(nmemb, size, &stack);
 106   }
 107   size *= nmemb;
 108   return Allocate(stack, size, 1, true);
 109 }
 110
 111 void Deallocate(void *p) {
 112   if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
 113   RunFreeHooks(p);
 114   RegisterDeallocation(p);
 115   allocator.Deallocate(GetAllocatorCache(), p);
 116 }
 117
 118 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
 119                  uptr alignment) {
 120   RegisterDeallocation(p);
 121   if (new_size > kMaxAllowedMallocSize) {
 122     allocator.Deallocate(GetAllocatorCache(), p);
 123     return ReportAllocationSizeTooBig(new_size, stack);
 124   }
 125   p = allocator.Reallocate(GetAllocatorCache(), p, new_size, alignment);
 126   RegisterAllocation(stack, p, new_size);
 127   return p;
 128 }
 129
 130 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
 131   *begin = (uptr)GetAllocatorCache();
 132   *end = *begin + sizeof(AllocatorCache);
 133 }
 134
 135 uptr GetMallocUsableSize(const void *p) {
 136   ChunkMetadata *m = Metadata(p);
 137   if (!m) return 0;
 138   return m->requested_size;
 139 }
 140
 141 int lsan_posix_memalign(void **memptr, uptr alignment, uptr size,
 142                         const StackTrace &stack) {
 143   if (UNLIKELY(!CheckPosixMemalignAlignment(alignment))) {
 144     if (AllocatorMayReturnNull())
 145       return errno_EINVAL;
 146     ReportInvalidPosixMemalignAlignment(alignment, &stack);
 147   }
 148   void *ptr = Allocate(stack, size, alignment, kAlwaysClearMemory);
 149   if (UNLIKELY(!ptr))
 150     // OOM error is already taken care of by Allocate.
 151     return errno_ENOMEM;
 152   CHECK(IsAligned((uptr)ptr, alignment));
 153   *memptr = ptr;
 154   return 0;
 155 }
 156
 157 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack) {
 158   if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(alignment, size))) {
 159     errno = errno_EINVAL;
 160     if (AllocatorMayReturnNull())
 161       return nullptr;
 162     ReportInvalidAlignedAllocAlignment(size, alignment, &stack);
 163   }
 164   return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
 165 }
 166
 167 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
 168   if (UNLIKELY(!IsPowerOfTwo(alignment))) {
 169     errno = errno_EINVAL;
 170     if (AllocatorMayReturnNull())
 171       return nullptr;
 172     ReportInvalidAllocationAlignment(alignment, &stack);
 173   }
 174   return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
 175 }
 176
 177 void *lsan_malloc(uptr size, const StackTrace &stack) {
 178   return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory));
 179 }
 180
 181 void lsan_free(void *p) {
 182   Deallocate(p);
 183 }
 184
 185 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) {
 186   return SetErrnoOnNull(Reallocate(stack, p, size, 1));
 187 }
 188
 189 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
 190   return SetErrnoOnNull(Calloc(nmemb, size, stack));
 191 }
 192
 193 void *lsan_valloc(uptr size, const StackTrace &stack) {
 194   return SetErrnoOnNull(
 195       Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory));
 196 }
 197
 198 void *lsan_pvalloc(uptr size, const StackTrace &stack) {
 199   uptr PageSize = GetPageSizeCached();
 200   if (UNLIKELY(CheckForPvallocOverflow(size, PageSize))) {
 201     errno = errno_ENOMEM;
 202     if (AllocatorMayReturnNull())
 203       return nullptr;
 204     ReportPvallocOverflow(size, &stack);
 205   }
 206   // pvalloc(0) should allocate one page.
 207   size = size ? RoundUpTo(size, PageSize) : PageSize;
 208   return SetErrnoOnNull(Allocate(stack, size, PageSize, kAlwaysClearMemory));
 209 }
 210
 211 uptr lsan_mz_size(const void *p) {
 212   return GetMallocUsableSize(p);
 213 }
 214
 215 ///// Interface to the common LSan module. /////
 216
 217 void LockAllocator() {
 218   allocator.ForceLock();
 219 }
 220
 221 void UnlockAllocator() {
 222   allocator.ForceUnlock();
 223 }
 224
 225 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
 226   *begin = (uptr)&allocator;
 227   *end = *begin + sizeof(allocator);
 228 }
 229
 230 uptr PointsIntoChunk(void* p) {
 231   uptr addr = reinterpret_cast<uptr>(p);
 232   uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p));
 233   if (!chunk) return 0;
 234   // LargeMmapAllocator considers pointers to the meta-region of a chunk to be
 235   // valid, but we don't want that.
 236   if (addr < chunk) return 0;
 237   ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk));
 238   CHECK(m);
 239   if (!m->allocated)
 240     return 0;
 241   if (addr < chunk + m->requested_size)
 242     return chunk;
 243   if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr))
 244     return chunk;
 245   return 0;
 246 }
 247
 248 uptr GetUserBegin(uptr chunk) {
 249   return chunk;
 250 }
 251
 252 LsanMetadata::LsanMetadata(uptr chunk) {
 253   metadata_ = Metadata(reinterpret_cast<void *>(chunk));
 254   CHECK(metadata_);
 255 }
 256
 257 bool LsanMetadata::allocated() const {
 258   return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
 259 }
 260
 261 ChunkTag LsanMetadata::tag() const {
 262   return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
 263 }
 264
 265 void LsanMetadata::set_tag(ChunkTag value) {
 266   reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
 267 }
 268
 269 uptr LsanMetadata::requested_size() const {
 270   return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
 271 }
 272
 273 u32 LsanMetadata::stack_trace_id() const {
 274   return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
 275 }
 276
 277 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
 278   allocator.ForEachChunk(callback, arg);
 279 }
 280
 281 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
 282   void *chunk = allocator.GetBlockBegin(p);
 283   if (!chunk || p < chunk) return kIgnoreObjectInvalid;
 284   ChunkMetadata *m = Metadata(chunk);
 285   CHECK(m);
 286   if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
 287     if (m->tag == kIgnored)
 288       return kIgnoreObjectAlreadyIgnored;
 289     m->tag = kIgnored;
 290     return kIgnoreObjectSuccess;
 291   } else {
 292     return kIgnoreObjectInvalid;
 293   }
 294 }
 295 } // namespace __lsan
 296
 297 using namespace __lsan;
 298
 299 extern "C" {
 300 SANITIZER_INTERFACE_ATTRIBUTE
 301 uptr __sanitizer_get_current_allocated_bytes() {
 302   uptr stats[AllocatorStatCount];
 303   allocator.GetStats(stats);
 304   return stats[AllocatorStatAllocated];
 305 }
 306
 307 SANITIZER_INTERFACE_ATTRIBUTE
 308 uptr __sanitizer_get_heap_size() {
 309   uptr stats[AllocatorStatCount];
 310   allocator.GetStats(stats);
 311   return stats[AllocatorStatMapped];
 312 }
 313
 314 SANITIZER_INTERFACE_ATTRIBUTE
 315 uptr __sanitizer_get_free_bytes() { return 0; }
 316
 317 SANITIZER_INTERFACE_ATTRIBUTE
 318 uptr __sanitizer_get_unmapped_bytes() { return 0; }
 319
 320 SANITIZER_INTERFACE_ATTRIBUTE
 321 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 322
 323 SANITIZER_INTERFACE_ATTRIBUTE
 324 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 325
 326 SANITIZER_INTERFACE_ATTRIBUTE
 327 uptr __sanitizer_get_allocated_size(const void *p) {
 328   return GetMallocUsableSize(p);
 329 }
 330
 331 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
 332 // Provide default (no-op) implementation of malloc hooks.
 333 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 334 void __sanitizer_malloc_hook(void *ptr, uptr size) {
 335   (void)ptr;
 336   (void)size;
 337 }
 338 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 339 void __sanitizer_free_hook(void *ptr) {
 340   (void)ptr;
 341 }
 342 #endif
 343 } // extern "C"