1 //=-- lsan_allocator.cc ---------------------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file is a part of LeakSanitizer.
11 // See lsan_allocator.h for details.
13 //===----------------------------------------------------------------------===//
15 #include "lsan_allocator.h"
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_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"
26 extern "C" void *memset(void *ptr, int value, uptr num);
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;
34 static const uptr kMaxAllowedMallocSize = 8UL << 30;
36 typedef LargeMmapAllocator<> SecondaryAllocator;
37 typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
38 SecondaryAllocator> Allocator;
40 static Allocator allocator;
42 void InitializeAllocator() {
43 SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null);
44 allocator.InitLinkerInitialized(
45 common_flags()->allocator_release_to_os_interval_ms);
48 void AllocatorThreadFinish() {
49 allocator.SwallowCache(GetAllocatorCache());
52 static ChunkMetadata *Metadata(const void *p) {
53 return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
56 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
58 ChunkMetadata *m = Metadata(p);
60 m->tag = DisabledInThisThread() ? kIgnored : kDirectlyLeaked;
61 m->stack_trace_id = StackDepotPut(stack);
62 m->requested_size = size;
63 atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 1, memory_order_relaxed);
66 static void RegisterDeallocation(void *p) {
68 ChunkMetadata *m = Metadata(p);
70 atomic_store(reinterpret_cast<atomic_uint8_t *>(m), 0, memory_order_relaxed);
73 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
77 if (size > kMaxAllowedMallocSize) {
78 Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size);
79 return Allocator::FailureHandler::OnBadRequest();
81 void *p = allocator.Allocate(GetAllocatorCache(), size, alignment);
82 // Do not rely on the allocator to clear the memory (it's slow).
83 if (cleared && allocator.FromPrimary(p))
85 RegisterAllocation(stack, p, size);
86 if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
87 RunMallocHooks(p, size);
91 static void *Calloc(uptr nmemb, uptr size, const StackTrace &stack) {
92 if (UNLIKELY(CheckForCallocOverflow(size, nmemb)))
93 return Allocator::FailureHandler::OnBadRequest();
95 return Allocate(stack, size, 1, true);
98 void Deallocate(void *p) {
99 if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
101 RegisterDeallocation(p);
102 allocator.Deallocate(GetAllocatorCache(), p);
105 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
107 RegisterDeallocation(p);
108 if (new_size > kMaxAllowedMallocSize) {
109 Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", new_size);
110 allocator.Deallocate(GetAllocatorCache(), p);
111 return Allocator::FailureHandler::OnBadRequest();
113 p = allocator.Reallocate(GetAllocatorCache(), p, new_size, alignment);
114 RegisterAllocation(stack, p, new_size);
118 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
119 *begin = (uptr)GetAllocatorCache();
120 *end = *begin + sizeof(AllocatorCache);
123 uptr GetMallocUsableSize(const void *p) {
124 ChunkMetadata *m = Metadata(p);
126 return m->requested_size;
129 void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack) {
130 if (UNLIKELY(!IsPowerOfTwo(alignment))) {
131 errno = errno_EINVAL;
132 return Allocator::FailureHandler::OnBadRequest();
134 return SetErrnoOnNull(Allocate(stack, size, alignment, kAlwaysClearMemory));
137 void *lsan_malloc(uptr size, const StackTrace &stack) {
138 return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory));
141 void lsan_free(void *p) {
145 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) {
146 return SetErrnoOnNull(Reallocate(stack, p, size, 1));
149 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
150 return SetErrnoOnNull(Calloc(nmemb, size, stack));
153 void *lsan_valloc(uptr size, const StackTrace &stack) {
154 return SetErrnoOnNull(
155 Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory));
158 uptr lsan_mz_size(const void *p) {
159 return GetMallocUsableSize(p);
162 ///// Interface to the common LSan module. /////
164 void LockAllocator() {
165 allocator.ForceLock();
168 void UnlockAllocator() {
169 allocator.ForceUnlock();
172 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
173 *begin = (uptr)&allocator;
174 *end = *begin + sizeof(allocator);
177 uptr PointsIntoChunk(void* p) {
178 uptr addr = reinterpret_cast<uptr>(p);
179 uptr chunk = reinterpret_cast<uptr>(allocator.GetBlockBeginFastLocked(p));
180 if (!chunk) return 0;
181 // LargeMmapAllocator considers pointers to the meta-region of a chunk to be
182 // valid, but we don't want that.
183 if (addr < chunk) return 0;
184 ChunkMetadata *m = Metadata(reinterpret_cast<void *>(chunk));
188 if (addr < chunk + m->requested_size)
190 if (IsSpecialCaseOfOperatorNew0(chunk, m->requested_size, addr))
195 uptr GetUserBegin(uptr chunk) {
199 LsanMetadata::LsanMetadata(uptr chunk) {
200 metadata_ = Metadata(reinterpret_cast<void *>(chunk));
204 bool LsanMetadata::allocated() const {
205 return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
208 ChunkTag LsanMetadata::tag() const {
209 return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
212 void LsanMetadata::set_tag(ChunkTag value) {
213 reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
216 uptr LsanMetadata::requested_size() const {
217 return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
220 u32 LsanMetadata::stack_trace_id() const {
221 return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
224 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
225 allocator.ForEachChunk(callback, arg);
228 IgnoreObjectResult IgnoreObjectLocked(const void *p) {
229 void *chunk = allocator.GetBlockBegin(p);
230 if (!chunk || p < chunk) return kIgnoreObjectInvalid;
231 ChunkMetadata *m = Metadata(chunk);
233 if (m->allocated && (uptr)p < (uptr)chunk + m->requested_size) {
234 if (m->tag == kIgnored)
235 return kIgnoreObjectAlreadyIgnored;
237 return kIgnoreObjectSuccess;
239 return kIgnoreObjectInvalid;
242 } // namespace __lsan
244 using namespace __lsan;
247 SANITIZER_INTERFACE_ATTRIBUTE
248 uptr __sanitizer_get_current_allocated_bytes() {
249 uptr stats[AllocatorStatCount];
250 allocator.GetStats(stats);
251 return stats[AllocatorStatAllocated];
254 SANITIZER_INTERFACE_ATTRIBUTE
255 uptr __sanitizer_get_heap_size() {
256 uptr stats[AllocatorStatCount];
257 allocator.GetStats(stats);
258 return stats[AllocatorStatMapped];
261 SANITIZER_INTERFACE_ATTRIBUTE
262 uptr __sanitizer_get_free_bytes() { return 0; }
264 SANITIZER_INTERFACE_ATTRIBUTE
265 uptr __sanitizer_get_unmapped_bytes() { return 0; }
267 SANITIZER_INTERFACE_ATTRIBUTE
268 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
270 SANITIZER_INTERFACE_ATTRIBUTE
271 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
273 SANITIZER_INTERFACE_ATTRIBUTE
274 uptr __sanitizer_get_allocated_size(const void *p) {
275 return GetMallocUsableSize(p);
278 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
279 // Provide default (no-op) implementation of malloc hooks.
280 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
281 void __sanitizer_malloc_hook(void *ptr, uptr size) {
285 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
286 void __sanitizer_free_hook(void *ptr) {