1 //=-- lsan_allocator.cc ---------------------------------------------------===//
3 // This file is distributed under the University of Illinois Open Source
4 // License. See LICENSE.TXT for details.
6 //===----------------------------------------------------------------------===//
8 // This file is a part of LeakSanitizer.
9 // See lsan_allocator.h for details.
11 //===----------------------------------------------------------------------===//
13 #include "lsan_allocator.h"
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"
24 extern "C" void *memset(void *ptr
, int value
, uptr num
);
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;
32 static const uptr kMaxAllowedMallocSize
= 8UL << 30;
34 typedef LargeMmapAllocator
<> SecondaryAllocator
;
35 typedef CombinedAllocator
<PrimaryAllocator
, AllocatorCache
,
36 SecondaryAllocator
> Allocator
;
38 static Allocator allocator
;
40 void InitializeAllocator() {
41 SetAllocatorMayReturnNull(common_flags()->allocator_may_return_null
);
42 allocator
.InitLinkerInitialized(
43 common_flags()->allocator_release_to_os_interval_ms
);
46 void AllocatorThreadFinish() {
47 allocator
.SwallowCache(GetAllocatorCache());
50 static ChunkMetadata
*Metadata(const void *p
) {
51 return reinterpret_cast<ChunkMetadata
*>(allocator
.GetMetaData(p
));
54 static void RegisterAllocation(const StackTrace
&stack
, void *p
, uptr size
) {
56 ChunkMetadata
*m
= Metadata(p
);
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
);
64 static void RegisterDeallocation(void *p
) {
66 ChunkMetadata
*m
= Metadata(p
);
68 atomic_store(reinterpret_cast<atomic_uint8_t
*>(m
), 0, memory_order_relaxed
);
71 void *Allocate(const StackTrace
&stack
, uptr size
, uptr alignment
,
75 if (size
> kMaxAllowedMallocSize
) {
76 Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size
);
77 return Allocator::FailureHandler::OnBadRequest();
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
))
83 RegisterAllocation(stack
, p
, size
);
84 if (&__sanitizer_malloc_hook
) __sanitizer_malloc_hook(p
, size
);
85 RunMallocHooks(p
, size
);
89 static void *Calloc(uptr nmemb
, uptr size
, const StackTrace
&stack
) {
90 if (UNLIKELY(CheckForCallocOverflow(size
, nmemb
)))
91 return Allocator::FailureHandler::OnBadRequest();
93 return Allocate(stack
, size
, 1, true);
96 void Deallocate(void *p
) {
97 if (&__sanitizer_free_hook
) __sanitizer_free_hook(p
);
99 RegisterDeallocation(p
);
100 allocator
.Deallocate(GetAllocatorCache(), p
);
103 void *Reallocate(const StackTrace
&stack
, void *p
, uptr new_size
,
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();
111 p
= allocator
.Reallocate(GetAllocatorCache(), p
, new_size
, alignment
);
112 RegisterAllocation(stack
, p
, new_size
);
116 void GetAllocatorCacheRange(uptr
*begin
, uptr
*end
) {
117 *begin
= (uptr
)GetAllocatorCache();
118 *end
= *begin
+ sizeof(AllocatorCache
);
121 uptr
GetMallocUsableSize(const void *p
) {
122 ChunkMetadata
*m
= Metadata(p
);
124 return m
->requested_size
;
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();
132 return SetErrnoOnNull(Allocate(stack
, size
, alignment
, kAlwaysClearMemory
));
135 void *lsan_malloc(uptr size
, const StackTrace
&stack
) {
136 return SetErrnoOnNull(Allocate(stack
, size
, 1, kAlwaysClearMemory
));
139 void lsan_free(void *p
) {
143 void *lsan_realloc(void *p
, uptr size
, const StackTrace
&stack
) {
144 return SetErrnoOnNull(Reallocate(stack
, p
, size
, 1));
147 void *lsan_calloc(uptr nmemb
, uptr size
, const StackTrace
&stack
) {
148 return SetErrnoOnNull(Calloc(nmemb
, size
, stack
));
151 void *lsan_valloc(uptr size
, const StackTrace
&stack
) {
152 return SetErrnoOnNull(
153 Allocate(stack
, size
, GetPageSizeCached(), kAlwaysClearMemory
));
156 uptr
lsan_mz_size(const void *p
) {
157 return GetMallocUsableSize(p
);
160 ///// Interface to the common LSan module. /////
162 void LockAllocator() {
163 allocator
.ForceLock();
166 void UnlockAllocator() {
167 allocator
.ForceUnlock();
170 void GetAllocatorGlobalRange(uptr
*begin
, uptr
*end
) {
171 *begin
= (uptr
)&allocator
;
172 *end
= *begin
+ sizeof(allocator
);
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
));
186 if (addr
< chunk
+ m
->requested_size
)
188 if (IsSpecialCaseOfOperatorNew0(chunk
, m
->requested_size
, addr
))
193 uptr
GetUserBegin(uptr chunk
) {
197 LsanMetadata::LsanMetadata(uptr chunk
) {
198 metadata_
= Metadata(reinterpret_cast<void *>(chunk
));
202 bool LsanMetadata::allocated() const {
203 return reinterpret_cast<ChunkMetadata
*>(metadata_
)->allocated
;
206 ChunkTag
LsanMetadata::tag() const {
207 return reinterpret_cast<ChunkMetadata
*>(metadata_
)->tag
;
210 void LsanMetadata::set_tag(ChunkTag value
) {
211 reinterpret_cast<ChunkMetadata
*>(metadata_
)->tag
= value
;
214 uptr
LsanMetadata::requested_size() const {
215 return reinterpret_cast<ChunkMetadata
*>(metadata_
)->requested_size
;
218 u32
LsanMetadata::stack_trace_id() const {
219 return reinterpret_cast<ChunkMetadata
*>(metadata_
)->stack_trace_id
;
222 void ForEachChunk(ForEachChunkCallback callback
, void *arg
) {
223 allocator
.ForEachChunk(callback
, arg
);
226 IgnoreObjectResult
IgnoreObjectLocked(const void *p
) {
227 void *chunk
= allocator
.GetBlockBegin(p
);
228 if (!chunk
|| p
< chunk
) return kIgnoreObjectInvalid
;
229 ChunkMetadata
*m
= Metadata(chunk
);
231 if (m
->allocated
&& (uptr
)p
< (uptr
)chunk
+ m
->requested_size
) {
232 if (m
->tag
== kIgnored
)
233 return kIgnoreObjectAlreadyIgnored
;
235 return kIgnoreObjectSuccess
;
237 return kIgnoreObjectInvalid
;
240 } // namespace __lsan
242 using namespace __lsan
;
245 SANITIZER_INTERFACE_ATTRIBUTE
246 uptr
__sanitizer_get_current_allocated_bytes() {
247 uptr stats
[AllocatorStatCount
];
248 allocator
.GetStats(stats
);
249 return stats
[AllocatorStatAllocated
];
252 SANITIZER_INTERFACE_ATTRIBUTE
253 uptr
__sanitizer_get_heap_size() {
254 uptr stats
[AllocatorStatCount
];
255 allocator
.GetStats(stats
);
256 return stats
[AllocatorStatMapped
];
259 SANITIZER_INTERFACE_ATTRIBUTE
260 uptr
__sanitizer_get_free_bytes() { return 0; }
262 SANITIZER_INTERFACE_ATTRIBUTE
263 uptr
__sanitizer_get_unmapped_bytes() { return 0; }
265 SANITIZER_INTERFACE_ATTRIBUTE
266 uptr
__sanitizer_get_estimated_allocated_size(uptr size
) { return size
; }
268 SANITIZER_INTERFACE_ATTRIBUTE
269 int __sanitizer_get_ownership(const void *p
) { return Metadata(p
) != nullptr; }
271 SANITIZER_INTERFACE_ATTRIBUTE
272 uptr
__sanitizer_get_allocated_size(const void *p
) {
273 return GetMallocUsableSize(p
);
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
) {
283 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
284 void __sanitizer_free_hook(void *ptr
) {