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
InitializeAllocator()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
AllocatorThreadFinish()46 void AllocatorThreadFinish() {
47 allocator.SwallowCache(GetAllocatorCache());
48 }
49
Metadata(const void * p)50 static ChunkMetadata *Metadata(const void *p) {
51 return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
52 }
53
RegisterAllocation(const StackTrace & stack,void * p,uptr size)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
RegisterDeallocation(void * p)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
Allocate(const StackTrace & stack,uptr size,uptr alignment,bool cleared)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
Calloc(uptr nmemb,uptr size,const StackTrace & stack)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
Deallocate(void * p)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
Reallocate(const StackTrace & stack,void * p,uptr new_size,uptr alignment)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
GetAllocatorCacheRange(uptr * begin,uptr * end)116 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
117 *begin = (uptr)GetAllocatorCache();
118 *end = *begin + sizeof(AllocatorCache);
119 }
120
GetMallocUsableSize(const void * p)121 uptr GetMallocUsableSize(const void *p) {
122 ChunkMetadata *m = Metadata(p);
123 if (!m) return 0;
124 return m->requested_size;
125 }
126
lsan_memalign(uptr alignment,uptr size,const StackTrace & stack)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
lsan_malloc(uptr size,const StackTrace & stack)135 void *lsan_malloc(uptr size, const StackTrace &stack) {
136 return SetErrnoOnNull(Allocate(stack, size, 1, kAlwaysClearMemory));
137 }
138
lsan_free(void * p)139 void lsan_free(void *p) {
140 Deallocate(p);
141 }
142
lsan_realloc(void * p,uptr size,const StackTrace & stack)143 void *lsan_realloc(void *p, uptr size, const StackTrace &stack) {
144 return SetErrnoOnNull(Reallocate(stack, p, size, 1));
145 }
146
lsan_calloc(uptr nmemb,uptr size,const StackTrace & stack)147 void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack) {
148 return SetErrnoOnNull(Calloc(nmemb, size, stack));
149 }
150
lsan_valloc(uptr size,const StackTrace & stack)151 void *lsan_valloc(uptr size, const StackTrace &stack) {
152 return SetErrnoOnNull(
153 Allocate(stack, size, GetPageSizeCached(), kAlwaysClearMemory));
154 }
155
lsan_mz_size(const void * p)156 uptr lsan_mz_size(const void *p) {
157 return GetMallocUsableSize(p);
158 }
159
160 ///// Interface to the common LSan module. /////
161
LockAllocator()162 void LockAllocator() {
163 allocator.ForceLock();
164 }
165
UnlockAllocator()166 void UnlockAllocator() {
167 allocator.ForceUnlock();
168 }
169
GetAllocatorGlobalRange(uptr * begin,uptr * end)170 void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
171 *begin = (uptr)&allocator;
172 *end = *begin + sizeof(allocator);
173 }
174
PointsIntoChunk(void * p)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
GetUserBegin(uptr chunk)193 uptr GetUserBegin(uptr chunk) {
194 return chunk;
195 }
196
LsanMetadata(uptr chunk)197 LsanMetadata::LsanMetadata(uptr chunk) {
198 metadata_ = Metadata(reinterpret_cast<void *>(chunk));
199 CHECK(metadata_);
200 }
201
allocated() const202 bool LsanMetadata::allocated() const {
203 return reinterpret_cast<ChunkMetadata *>(metadata_)->allocated;
204 }
205
tag() const206 ChunkTag LsanMetadata::tag() const {
207 return reinterpret_cast<ChunkMetadata *>(metadata_)->tag;
208 }
209
set_tag(ChunkTag value)210 void LsanMetadata::set_tag(ChunkTag value) {
211 reinterpret_cast<ChunkMetadata *>(metadata_)->tag = value;
212 }
213
requested_size() const214 uptr LsanMetadata::requested_size() const {
215 return reinterpret_cast<ChunkMetadata *>(metadata_)->requested_size;
216 }
217
stack_trace_id() const218 u32 LsanMetadata::stack_trace_id() const {
219 return reinterpret_cast<ChunkMetadata *>(metadata_)->stack_trace_id;
220 }
221
ForEachChunk(ForEachChunkCallback callback,void * arg)222 void ForEachChunk(ForEachChunkCallback callback, void *arg) {
223 allocator.ForEachChunk(callback, arg);
224 }
225
IgnoreObjectLocked(const void * p)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
__sanitizer_get_current_allocated_bytes()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
__sanitizer_get_heap_size()253 uptr __sanitizer_get_heap_size() {
254 uptr stats[AllocatorStatCount];
255 allocator.GetStats(stats);
256 return stats[AllocatorStatMapped];
257 }
258
259 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_free_bytes()260 uptr __sanitizer_get_free_bytes() { return 0; }
261
262 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_unmapped_bytes()263 uptr __sanitizer_get_unmapped_bytes() { return 0; }
264
265 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_estimated_allocated_size(uptr size)266 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
267
268 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_ownership(const void * p)269 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
270
271 SANITIZER_INTERFACE_ATTRIBUTE
__sanitizer_get_allocated_size(const void * p)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
__sanitizer_malloc_hook(void * ptr,uptr size)279 void __sanitizer_malloc_hook(void *ptr, uptr size) {
280 (void)ptr;
281 (void)size;
282 }
283 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
__sanitizer_free_hook(void * ptr)284 void __sanitizer_free_hook(void *ptr) {
285 (void)ptr;
286 }
287 #endif
288 } // extern "C"
289