1 //=-- lsan_allocator.cpp --------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of LeakSanitizer. 10 // See lsan_allocator.h for details. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "lsan_allocator.h" 15 16 #include "sanitizer_common/sanitizer_allocator.h" 17 #include "sanitizer_common/sanitizer_allocator_checks.h" 18 #include "sanitizer_common/sanitizer_allocator_interface.h" 19 #include "sanitizer_common/sanitizer_allocator_report.h" 20 #include "sanitizer_common/sanitizer_errno.h" 21 #include "sanitizer_common/sanitizer_internal_defs.h" 22 #include "sanitizer_common/sanitizer_stackdepot.h" 23 #include "sanitizer_common/sanitizer_stacktrace.h" 24 #include "lsan_common.h" 25 26 extern "C" void *memset(void *ptr, int value, uptr num); 27 28 namespace __lsan { 29 #if defined(__i386__) || defined(__arm__) 30 static const uptr kMaxAllowedMallocSize = 1UL << 30; 31 #elif defined(__mips64) || defined(__aarch64__) 32 static const uptr kMaxAllowedMallocSize = 4UL << 30; 33 #else 34 static const uptr kMaxAllowedMallocSize = 8UL << 30; 35 #endif 36 37 static Allocator allocator; 38 39 static uptr max_malloc_size; 40 41 void InitializeAllocator() { 42 SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null); 43 allocator.InitLinkerInitialized( 44 common_flags()->allocator_release_to_os_interval_ms); 45 if (common_flags()->max_allocation_size_mb) 46 max_malloc_size = Min(common_flags()->max_allocation_size_mb << 20, 47 kMaxAllowedMallocSize); 48 else 49 max_malloc_size = kMaxAllowedMallocSize; 50 } 51 52 void AllocatorThreadFinish() { 53 allocator.SwallowCache(GetAllocatorCache()); 54 } 55 56 static ChunkMetadata *Metadata(const void *p) { 57 return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p)); 58 } 59 60 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) { 61 if (!p) return; 62 ChunkMetadata *m = Metadata(p); 63 CHECK(m); 64 m->tag = DisabledInThisThread() ? kIgnored : kDirectlyLeaked; 65 m->stack_trace_id = StackDepotPut(stack); 66 m->requested_size = size; 67 atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed); 68 } 69 70 static void RegisterDeallocation(void *p) { 71 if (!p) return; 72 ChunkMetadata *m = Metadata(p); 73 CHECK(m); 74 atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed); 75 } 76 77 static void *ReportAllocationSizeTooBig(uptr size, const StackTrace &stack) { 78 if (AllocatorMayReturnNull()) { 79 Report("WARNING: LeakSanitizer failed to allocate 0x%zx bytes\n", size); 80 return nullptr; 81 } 82 ReportAllocationSizeTooBig(size, max_malloc_size, &stack); 83 } 84 85 void *Allocate(const StackTrace &stack, uptr size, uptr alignment, 86 bool cleared) { 87 if (size == 0) 88 size = 1; 89 if (size > max_malloc_size) 90 return ReportAllocationSizeTooBig(size, stack); 91 void *p = allocator.Allocate(GetAllocatorCache(), size, alignment); 92 if (UNLIKELY(!p)) { 93 SetAllocatorOutOfMemory(); 94 if (AllocatorMayReturnNull()) 95 return nullptr; 96 ReportOutOfMemory(size, &stack); 97 } 98 // Do not rely on the allocator to clear the memory (it's slow). 99 if (cleared && allocator.FromPrimary(p)) 100 memset(p, 0, size); 101 RegisterAllocation(stack, p, size); 102 if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size); 103 RunMallocHooks(p, size); 104 return p; 105 } 106 107 static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) { 108 if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) { 109 if (AllocatorMayReturnNull()) 110 return nullptr; 111 ReportCallocOverflow(nmemb, size, &stack); 112 } 113 size *= nmemb; 114 return Allocate(stack, size, 1, true); 115 } 116 117 void Deallocate(void *p) { 118 if (&__sanitizer_free_hook) __sanitizer_free_hook(p); 119 RunFreeHooks(p); 120 RegisterDeallocation(p); 121 allocator.Deallocate(GetAllocatorCache(), p); 122 } 123 124 void *Reallocate(const StackTrace &stack, void *p, uptr new_size, 125 uptr alignment) { 126 if (new_size > max_malloc_size) { 127 ReportAllocationSizeTooBig(new_size, stack); 128 return nullptr; 129 } 130 RegisterDeallocation(p); 131 void *new_p = 132 allocator.Reallocate(GetAllocatorCache(), p, new_size, alignment); 133 if (new_p) 134 RegisterAllocation(stack, new_p, new_size); 135 else if (new_size != 0) 136 RegisterAllocation(stack, p, new_size); 137 return new_p; 138 } 139 140 void GetAllocatorCacheRange(uptr *begin, uptr *end) { 141 *begin = (uptr)GetAllocatorCache(); 142 *end = *begin + sizeof(AllocatorCache); 143 } 144 145 uptr GetMallocUsableSize(const void *p) { 146 ChunkMetadata *m = Metadata(p); 147 if (!m) return 0; 148 return m->requested_size; 149 } 150 151 int lsan_posix_memalign(void **memptr, uptr alignment, uptr size, 152 const StackTrace &stack) { 153 if (UNLIKELY(!CheckPosixMemalignAlignment(alignment))) { 154 if (AllocatorMayReturnNull()) 155 return errno_EINVAL; 156 ReportInvalidPosixMemalignAlignment(alignment, &stack); 157 } 158 void *ptr = Allocate(stack, size, alignment, kAlwaysClearMemory); 159 if (UNLIKELY(!ptr)) 160 // OOM error is already taken care of by Allocate. 161 return errno_ENOMEM; 162 CHECK(IsAligned((uptr)ptr, alignment)); 163 *memptr = ptr; 164 return 0; 165 } 166 167 void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack) { 168 if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(alignment, size))) { 169 errno = errno_EINVAL; 170 if (AllocatorMayReturnNull()) 171 return nullptr; 172 ReportInvalidAlignedAllocAlignment(size, alignment, &stack); 173 } 174 return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory)); 175 } 176 177 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) { 178 if (UNLIKELY(!IsPowerOfTwo(alignment))) { 179 errno = errno_EINVAL; 180 if (AllocatorMayReturnNull()) 181 return nullptr; 182 ReportInvalidAllocationAlignment(alignment, &stack); 183 } 184 return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory)); 185 } 186 187 void *lsan_malloc(uptr size, const StackTrace &stack) { 188 return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory)); 189 } 190 191 void lsan_free(void *p) { 192 Deallocate(p); 193 } 194 195 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) { 196 return SetErrnoOnNull(Reallocate(stack, p, size, 1)); 197 } 198 199 void *lsan_reallocarray(void *ptr, uptr nmemb, uptr size, 200 const StackTrace &stack) { 201 if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) { 202 errno = errno_ENOMEM; 203 if (AllocatorMayReturnNull()) 204 return nullptr; 205 ReportReallocArrayOverflow(nmemb, size, &stack); 206 } 207 return lsan_realloc(ptr, nmemb * size, stack); 208 } 209 210 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) { 211 return SetErrnoOnNull(Calloc(nmemb, size, stack)); 212 } 213 214 void *lsan_valloc(uptr size, const StackTrace &stack) { 215 return SetErrnoOnNull( 216 Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory)); 217 } 218 219 void *lsan_pvalloc(uptr size, const StackTrace &stack) { 220 uptr PageSize = GetPageSizeCached(); 221 if (UNLIKELY(CheckForPvallocOverflow(size, PageSize))) { 222 errno = errno_ENOMEM; 223 if (AllocatorMayReturnNull()) 224 return nullptr; 225 ReportPvallocOverflow(size, &stack); 226 } 227 // pvalloc(0) should allocate one page. 228 size = size ? RoundUpTo(size, PageSize) : PageSize; 229 return SetErrnoOnNull(Allocate(stack, size, PageSize, kAlwaysClearMemory)); 230 } 231 232 uptr lsan_mz_size(const void *p) { 233 return GetMallocUsableSize(p); 234 } 235 236 ///// Interface to the common LSan module. ///// 237 238 void LockAllocator() { 239 allocator.ForceLock(); 240 } 241 242 void UnlockAllocator() { 243 allocator.ForceUnlock(); 244 } 245 246 void GetAllocatorGlobalRange(uptr *begin, uptr *end) { 247 *begin = (uptr)&allocator; 248 *end = *begin + sizeof(allocator); 249 } 250 251 uptr PointsIntoChunk(void* p) { 252 uptr addr = reinterpret_cast<uptr>(p); 253 uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p)); 254 if (!chunk) return 0; 255 // LargeMmapAllocator considers pointers to the meta-region of a chunk to be 256 // valid, but we don't want that. 257 if (addr < chunk) return 0; 258 ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk)); 259 CHECK(m); 260 if (!m->allocated) 261 return 0; 262 if (addr < chunk + m->requested_size) 263 return chunk; 264 if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr)) 265 return chunk; 266 return 0; 267 } 268 269 uptr GetUserBegin(uptr chunk) { 270 return chunk; 271 } 272 273 LsanMetadata::LsanMetadata(uptr chunk) { 274 metadata_ = Metadata(reinterpret_cast<void *>(chunk)); 275 CHECK(metadata_); 276 } 277 278 bool LsanMetadata::allocated() const { 279 return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated; 280 } 281 282 ChunkTag LsanMetadata::tag() const { 283 return reinterpret_cast<ChunkMetadata *>(metadata_)->tag; 284 } 285 286 void LsanMetadata::set_tag(ChunkTag value) { 287 reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value; 288 } 289 290 uptr LsanMetadata::requested_size() const { 291 return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size; 292 } 293 294 u32 LsanMetadata::stack_trace_id() const { 295 return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id; 296 } 297 298 void ForEachChunk(ForEachChunkCallback callback, void *arg) { 299 allocator.ForEachChunk(callback, arg); 300 } 301 302 IgnoreObjectResult IgnoreObjectLocked(const void *p) { 303 void *chunk = allocator.GetBlockBegin(p); 304 if (!chunk || p < chunk) return kIgnoreObjectInvalid; 305 ChunkMetadata *m = Metadata(chunk); 306 CHECK(m); 307 if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) { 308 if (m->tag == kIgnored) 309 return kIgnoreObjectAlreadyIgnored; 310 m->tag = kIgnored; 311 return kIgnoreObjectSuccess; 312 } else { 313 return kIgnoreObjectInvalid; 314 } 315 } 316 317 void GetAdditionalThreadContextPtrs(ThreadContextBase *tctx, void *ptrs) { 318 // This function can be used to treat memory reachable from `tctx` as live. 319 // This is useful for threads that have been created but not yet started. 320 321 // This is currently a no-op because the LSan `pthread_create()` interceptor 322 // blocks until the child thread starts which keeps the thread's `arg` pointer 323 // live. 324 } 325 326 } // namespace __lsan 327 328 using namespace __lsan; 329 330 extern "C" { 331 SANITIZER_INTERFACE_ATTRIBUTE 332 uptr __sanitizer_get_current_allocated_bytes() { 333 uptr stats[AllocatorStatCount]; 334 allocator.GetStats(stats); 335 return stats[AllocatorStatAllocated]; 336 } 337 338 SANITIZER_INTERFACE_ATTRIBUTE 339 uptr __sanitizer_get_heap_size() { 340 uptr stats[AllocatorStatCount]; 341 allocator.GetStats(stats); 342 return stats[AllocatorStatMapped]; 343 } 344 345 SANITIZER_INTERFACE_ATTRIBUTE 346 uptr __sanitizer_get_free_bytes() { return 0; } 347 348 SANITIZER_INTERFACE_ATTRIBUTE 349 uptr __sanitizer_get_unmapped_bytes() { return 0; } 350 351 SANITIZER_INTERFACE_ATTRIBUTE 352 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; } 353 354 SANITIZER_INTERFACE_ATTRIBUTE 355 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; } 356 357 SANITIZER_INTERFACE_ATTRIBUTE 358 uptr __sanitizer_get_allocated_size(const void *p) { 359 return GetMallocUsableSize(p); 360 } 361 362 #if !SANITIZER_SUPPORTS_WEAK_HOOKS 363 // Provide default (no-op) implementation of malloc hooks. 364 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE 365 void __sanitizer_malloc_hook(void *ptr, uptr size) { 366 (void)ptr; 367 (void)size; 368 } 369 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE 370 void __sanitizer_free_hook(void *ptr) { 371 (void)ptr; 372 } 373 #endif 374 } // extern "C" 375