1*ee754c2dSkamil //===-- asan_allocator.cc -------------------------------------------------===//
2*ee754c2dSkamil //
3*ee754c2dSkamil // The LLVM Compiler Infrastructure
4*ee754c2dSkamil //
5*ee754c2dSkamil // This file is distributed under the University of Illinois Open Source
6*ee754c2dSkamil // License. See LICENSE.TXT for details.
7*ee754c2dSkamil //
8*ee754c2dSkamil //===----------------------------------------------------------------------===//
9*ee754c2dSkamil //
10*ee754c2dSkamil // This file is a part of AddressSanitizer, an address sanity checker.
11*ee754c2dSkamil //
12*ee754c2dSkamil // Implementation of ASan's memory allocator, 2-nd version.
13*ee754c2dSkamil // This variant uses the allocator from sanitizer_common, i.e. the one shared
14*ee754c2dSkamil // with ThreadSanitizer and MemorySanitizer.
15*ee754c2dSkamil //
16*ee754c2dSkamil //===----------------------------------------------------------------------===//
17*ee754c2dSkamil
18*ee754c2dSkamil #include "asan_allocator.h"
19*ee754c2dSkamil #include "asan_mapping.h"
20*ee754c2dSkamil #include "asan_poisoning.h"
21*ee754c2dSkamil #include "asan_report.h"
22*ee754c2dSkamil #include "asan_stack.h"
23*ee754c2dSkamil #include "asan_thread.h"
24*ee754c2dSkamil #include "sanitizer_common/sanitizer_allocator_checks.h"
25*ee754c2dSkamil #include "sanitizer_common/sanitizer_allocator_interface.h"
26*ee754c2dSkamil #include "sanitizer_common/sanitizer_errno.h"
27*ee754c2dSkamil #include "sanitizer_common/sanitizer_flags.h"
28*ee754c2dSkamil #include "sanitizer_common/sanitizer_internal_defs.h"
29*ee754c2dSkamil #include "sanitizer_common/sanitizer_list.h"
30*ee754c2dSkamil #include "sanitizer_common/sanitizer_stackdepot.h"
31*ee754c2dSkamil #include "sanitizer_common/sanitizer_quarantine.h"
32*ee754c2dSkamil #include "lsan/lsan_common.h"
33*ee754c2dSkamil
34*ee754c2dSkamil namespace __asan {
35*ee754c2dSkamil
36*ee754c2dSkamil // Valid redzone sizes are 16, 32, 64, ... 2048, so we encode them in 3 bits.
37*ee754c2dSkamil // We use adaptive redzones: for larger allocation larger redzones are used.
RZLog2Size(u32 rz_log)38*ee754c2dSkamil static u32 RZLog2Size(u32 rz_log) {
39*ee754c2dSkamil CHECK_LT(rz_log, 8);
40*ee754c2dSkamil return 16 << rz_log;
41*ee754c2dSkamil }
42*ee754c2dSkamil
RZSize2Log(u32 rz_size)43*ee754c2dSkamil static u32 RZSize2Log(u32 rz_size) {
44*ee754c2dSkamil CHECK_GE(rz_size, 16);
45*ee754c2dSkamil CHECK_LE(rz_size, 2048);
46*ee754c2dSkamil CHECK(IsPowerOfTwo(rz_size));
47*ee754c2dSkamil u32 res = Log2(rz_size) - 4;
48*ee754c2dSkamil CHECK_EQ(rz_size, RZLog2Size(res));
49*ee754c2dSkamil return res;
50*ee754c2dSkamil }
51*ee754c2dSkamil
52*ee754c2dSkamil static AsanAllocator &get_allocator();
53*ee754c2dSkamil
54*ee754c2dSkamil // The memory chunk allocated from the underlying allocator looks like this:
55*ee754c2dSkamil // L L L L L L H H U U U U U U R R
56*ee754c2dSkamil // L -- left redzone words (0 or more bytes)
57*ee754c2dSkamil // H -- ChunkHeader (16 bytes), which is also a part of the left redzone.
58*ee754c2dSkamil // U -- user memory.
59*ee754c2dSkamil // R -- right redzone (0 or more bytes)
60*ee754c2dSkamil // ChunkBase consists of ChunkHeader and other bytes that overlap with user
61*ee754c2dSkamil // memory.
62*ee754c2dSkamil
63*ee754c2dSkamil // If the left redzone is greater than the ChunkHeader size we store a magic
64*ee754c2dSkamil // value in the first uptr word of the memory block and store the address of
65*ee754c2dSkamil // ChunkBase in the next uptr.
66*ee754c2dSkamil // M B L L L L L L L L L H H U U U U U U
67*ee754c2dSkamil // | ^
68*ee754c2dSkamil // ---------------------|
69*ee754c2dSkamil // M -- magic value kAllocBegMagic
70*ee754c2dSkamil // B -- address of ChunkHeader pointing to the first 'H'
71*ee754c2dSkamil static const uptr kAllocBegMagic = 0xCC6E96B9;
72*ee754c2dSkamil
73*ee754c2dSkamil struct ChunkHeader {
74*ee754c2dSkamil // 1-st 8 bytes.
75*ee754c2dSkamil u32 chunk_state : 8; // Must be first.
76*ee754c2dSkamil u32 alloc_tid : 24;
77*ee754c2dSkamil
78*ee754c2dSkamil u32 free_tid : 24;
79*ee754c2dSkamil u32 from_memalign : 1;
80*ee754c2dSkamil u32 alloc_type : 2;
81*ee754c2dSkamil u32 rz_log : 3;
82*ee754c2dSkamil u32 lsan_tag : 2;
83*ee754c2dSkamil // 2-nd 8 bytes
84*ee754c2dSkamil // This field is used for small sizes. For large sizes it is equal to
85*ee754c2dSkamil // SizeClassMap::kMaxSize and the actual size is stored in the
86*ee754c2dSkamil // SecondaryAllocator's metadata.
87*ee754c2dSkamil u32 user_requested_size : 29;
88*ee754c2dSkamil // align < 8 -> 0
89*ee754c2dSkamil // else -> log2(min(align, 512)) - 2
90*ee754c2dSkamil u32 user_requested_alignment_log : 3;
91*ee754c2dSkamil u32 alloc_context_id;
92*ee754c2dSkamil };
93*ee754c2dSkamil
94*ee754c2dSkamil struct ChunkBase : ChunkHeader {
95*ee754c2dSkamil // Header2, intersects with user memory.
96*ee754c2dSkamil u32 free_context_id;
97*ee754c2dSkamil };
98*ee754c2dSkamil
99*ee754c2dSkamil static const uptr kChunkHeaderSize = sizeof(ChunkHeader);
100*ee754c2dSkamil static const uptr kChunkHeader2Size = sizeof(ChunkBase) - kChunkHeaderSize;
101*ee754c2dSkamil COMPILER_CHECK(kChunkHeaderSize == 16);
102*ee754c2dSkamil COMPILER_CHECK(kChunkHeader2Size <= 16);
103*ee754c2dSkamil
104*ee754c2dSkamil // Every chunk of memory allocated by this allocator can be in one of 3 states:
105*ee754c2dSkamil // CHUNK_AVAILABLE: the chunk is in the free list and ready to be allocated.
106*ee754c2dSkamil // CHUNK_ALLOCATED: the chunk is allocated and not yet freed.
107*ee754c2dSkamil // CHUNK_QUARANTINE: the chunk was freed and put into quarantine zone.
108*ee754c2dSkamil enum {
109*ee754c2dSkamil CHUNK_AVAILABLE = 0, // 0 is the default value even if we didn't set it.
110*ee754c2dSkamil CHUNK_ALLOCATED = 2,
111*ee754c2dSkamil CHUNK_QUARANTINE = 3
112*ee754c2dSkamil };
113*ee754c2dSkamil
114*ee754c2dSkamil struct AsanChunk: ChunkBase {
Beg__asan::AsanChunk115*ee754c2dSkamil uptr Beg() { return reinterpret_cast<uptr>(this) + kChunkHeaderSize; }
UsedSize__asan::AsanChunk116*ee754c2dSkamil uptr UsedSize(bool locked_version = false) {
117*ee754c2dSkamil if (user_requested_size != SizeClassMap::kMaxSize)
118*ee754c2dSkamil return user_requested_size;
119*ee754c2dSkamil return *reinterpret_cast<uptr *>(
120*ee754c2dSkamil get_allocator().GetMetaData(AllocBeg(locked_version)));
121*ee754c2dSkamil }
AllocBeg__asan::AsanChunk122*ee754c2dSkamil void *AllocBeg(bool locked_version = false) {
123*ee754c2dSkamil if (from_memalign) {
124*ee754c2dSkamil if (locked_version)
125*ee754c2dSkamil return get_allocator().GetBlockBeginFastLocked(
126*ee754c2dSkamil reinterpret_cast<void *>(this));
127*ee754c2dSkamil return get_allocator().GetBlockBegin(reinterpret_cast<void *>(this));
128*ee754c2dSkamil }
129*ee754c2dSkamil return reinterpret_cast<void*>(Beg() - RZLog2Size(rz_log));
130*ee754c2dSkamil }
AddrIsInside__asan::AsanChunk131*ee754c2dSkamil bool AddrIsInside(uptr addr, bool locked_version = false) {
132*ee754c2dSkamil return (addr >= Beg()) && (addr < Beg() + UsedSize(locked_version));
133*ee754c2dSkamil }
134*ee754c2dSkamil };
135*ee754c2dSkamil
136*ee754c2dSkamil struct QuarantineCallback {
QuarantineCallback__asan::QuarantineCallback137*ee754c2dSkamil QuarantineCallback(AllocatorCache *cache, BufferedStackTrace *stack)
138*ee754c2dSkamil : cache_(cache),
139*ee754c2dSkamil stack_(stack) {
140*ee754c2dSkamil }
141*ee754c2dSkamil
Recycle__asan::QuarantineCallback142*ee754c2dSkamil void Recycle(AsanChunk *m) {
143*ee754c2dSkamil CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
144*ee754c2dSkamil atomic_store((atomic_uint8_t*)m, CHUNK_AVAILABLE, memory_order_relaxed);
145*ee754c2dSkamil CHECK_NE(m->alloc_tid, kInvalidTid);
146*ee754c2dSkamil CHECK_NE(m->free_tid, kInvalidTid);
147*ee754c2dSkamil PoisonShadow(m->Beg(),
148*ee754c2dSkamil RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
149*ee754c2dSkamil kAsanHeapLeftRedzoneMagic);
150*ee754c2dSkamil void *p = reinterpret_cast<void *>(m->AllocBeg());
151*ee754c2dSkamil if (p != m) {
152*ee754c2dSkamil uptr *alloc_magic = reinterpret_cast<uptr *>(p);
153*ee754c2dSkamil CHECK_EQ(alloc_magic[0], kAllocBegMagic);
154*ee754c2dSkamil // Clear the magic value, as allocator internals may overwrite the
155*ee754c2dSkamil // contents of deallocated chunk, confusing GetAsanChunk lookup.
156*ee754c2dSkamil alloc_magic[0] = 0;
157*ee754c2dSkamil CHECK_EQ(alloc_magic[1], reinterpret_cast<uptr>(m));
158*ee754c2dSkamil }
159*ee754c2dSkamil
160*ee754c2dSkamil // Statistics.
161*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
162*ee754c2dSkamil thread_stats.real_frees++;
163*ee754c2dSkamil thread_stats.really_freed += m->UsedSize();
164*ee754c2dSkamil
165*ee754c2dSkamil get_allocator().Deallocate(cache_, p);
166*ee754c2dSkamil }
167*ee754c2dSkamil
Allocate__asan::QuarantineCallback168*ee754c2dSkamil void *Allocate(uptr size) {
169*ee754c2dSkamil void *res = get_allocator().Allocate(cache_, size, 1);
170*ee754c2dSkamil // TODO(alekseys): Consider making quarantine OOM-friendly.
171*ee754c2dSkamil if (UNLIKELY(!res))
172*ee754c2dSkamil ReportOutOfMemory(size, stack_);
173*ee754c2dSkamil return res;
174*ee754c2dSkamil }
175*ee754c2dSkamil
Deallocate__asan::QuarantineCallback176*ee754c2dSkamil void Deallocate(void *p) {
177*ee754c2dSkamil get_allocator().Deallocate(cache_, p);
178*ee754c2dSkamil }
179*ee754c2dSkamil
180*ee754c2dSkamil private:
181*ee754c2dSkamil AllocatorCache* const cache_;
182*ee754c2dSkamil BufferedStackTrace* const stack_;
183*ee754c2dSkamil };
184*ee754c2dSkamil
185*ee754c2dSkamil typedef Quarantine<QuarantineCallback, AsanChunk> AsanQuarantine;
186*ee754c2dSkamil typedef AsanQuarantine::Cache QuarantineCache;
187*ee754c2dSkamil
OnMap(uptr p,uptr size) const188*ee754c2dSkamil void AsanMapUnmapCallback::OnMap(uptr p, uptr size) const {
189*ee754c2dSkamil PoisonShadow(p, size, kAsanHeapLeftRedzoneMagic);
190*ee754c2dSkamil // Statistics.
191*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
192*ee754c2dSkamil thread_stats.mmaps++;
193*ee754c2dSkamil thread_stats.mmaped += size;
194*ee754c2dSkamil }
OnUnmap(uptr p,uptr size) const195*ee754c2dSkamil void AsanMapUnmapCallback::OnUnmap(uptr p, uptr size) const {
196*ee754c2dSkamil PoisonShadow(p, size, 0);
197*ee754c2dSkamil // We are about to unmap a chunk of user memory.
198*ee754c2dSkamil // Mark the corresponding shadow memory as not needed.
199*ee754c2dSkamil FlushUnneededASanShadowMemory(p, size);
200*ee754c2dSkamil // Statistics.
201*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
202*ee754c2dSkamil thread_stats.munmaps++;
203*ee754c2dSkamil thread_stats.munmaped += size;
204*ee754c2dSkamil }
205*ee754c2dSkamil
206*ee754c2dSkamil // We can not use THREADLOCAL because it is not supported on some of the
207*ee754c2dSkamil // platforms we care about (OSX 10.6, Android).
208*ee754c2dSkamil // static THREADLOCAL AllocatorCache cache;
GetAllocatorCache(AsanThreadLocalMallocStorage * ms)209*ee754c2dSkamil AllocatorCache *GetAllocatorCache(AsanThreadLocalMallocStorage *ms) {
210*ee754c2dSkamil CHECK(ms);
211*ee754c2dSkamil return &ms->allocator_cache;
212*ee754c2dSkamil }
213*ee754c2dSkamil
GetQuarantineCache(AsanThreadLocalMallocStorage * ms)214*ee754c2dSkamil QuarantineCache *GetQuarantineCache(AsanThreadLocalMallocStorage *ms) {
215*ee754c2dSkamil CHECK(ms);
216*ee754c2dSkamil CHECK_LE(sizeof(QuarantineCache), sizeof(ms->quarantine_cache));
217*ee754c2dSkamil return reinterpret_cast<QuarantineCache *>(ms->quarantine_cache);
218*ee754c2dSkamil }
219*ee754c2dSkamil
SetFrom(const Flags * f,const CommonFlags * cf)220*ee754c2dSkamil void AllocatorOptions::SetFrom(const Flags *f, const CommonFlags *cf) {
221*ee754c2dSkamil quarantine_size_mb = f->quarantine_size_mb;
222*ee754c2dSkamil thread_local_quarantine_size_kb = f->thread_local_quarantine_size_kb;
223*ee754c2dSkamil min_redzone = f->redzone;
224*ee754c2dSkamil max_redzone = f->max_redzone;
225*ee754c2dSkamil may_return_null = cf->allocator_may_return_null;
226*ee754c2dSkamil alloc_dealloc_mismatch = f->alloc_dealloc_mismatch;
227*ee754c2dSkamil release_to_os_interval_ms = cf->allocator_release_to_os_interval_ms;
228*ee754c2dSkamil }
229*ee754c2dSkamil
CopyTo(Flags * f,CommonFlags * cf)230*ee754c2dSkamil void AllocatorOptions::CopyTo(Flags *f, CommonFlags *cf) {
231*ee754c2dSkamil f->quarantine_size_mb = quarantine_size_mb;
232*ee754c2dSkamil f->thread_local_quarantine_size_kb = thread_local_quarantine_size_kb;
233*ee754c2dSkamil f->redzone = min_redzone;
234*ee754c2dSkamil f->max_redzone = max_redzone;
235*ee754c2dSkamil cf->allocator_may_return_null = may_return_null;
236*ee754c2dSkamil f->alloc_dealloc_mismatch = alloc_dealloc_mismatch;
237*ee754c2dSkamil cf->allocator_release_to_os_interval_ms = release_to_os_interval_ms;
238*ee754c2dSkamil }
239*ee754c2dSkamil
240*ee754c2dSkamil struct Allocator {
241*ee754c2dSkamil static const uptr kMaxAllowedMallocSize =
242*ee754c2dSkamil FIRST_32_SECOND_64(3UL << 30, 1ULL << 40);
243*ee754c2dSkamil
244*ee754c2dSkamil AsanAllocator allocator;
245*ee754c2dSkamil AsanQuarantine quarantine;
246*ee754c2dSkamil StaticSpinMutex fallback_mutex;
247*ee754c2dSkamil AllocatorCache fallback_allocator_cache;
248*ee754c2dSkamil QuarantineCache fallback_quarantine_cache;
249*ee754c2dSkamil
250*ee754c2dSkamil atomic_uint8_t rss_limit_exceeded;
251*ee754c2dSkamil
252*ee754c2dSkamil // ------------------- Options --------------------------
253*ee754c2dSkamil atomic_uint16_t min_redzone;
254*ee754c2dSkamil atomic_uint16_t max_redzone;
255*ee754c2dSkamil atomic_uint8_t alloc_dealloc_mismatch;
256*ee754c2dSkamil
257*ee754c2dSkamil // ------------------- Initialization ------------------------
Allocator__asan::Allocator258*ee754c2dSkamil explicit Allocator(LinkerInitialized)
259*ee754c2dSkamil : quarantine(LINKER_INITIALIZED),
260*ee754c2dSkamil fallback_quarantine_cache(LINKER_INITIALIZED) {}
261*ee754c2dSkamil
CheckOptions__asan::Allocator262*ee754c2dSkamil void CheckOptions(const AllocatorOptions &options) const {
263*ee754c2dSkamil CHECK_GE(options.min_redzone, 16);
264*ee754c2dSkamil CHECK_GE(options.max_redzone, options.min_redzone);
265*ee754c2dSkamil CHECK_LE(options.max_redzone, 2048);
266*ee754c2dSkamil CHECK(IsPowerOfTwo(options.min_redzone));
267*ee754c2dSkamil CHECK(IsPowerOfTwo(options.max_redzone));
268*ee754c2dSkamil }
269*ee754c2dSkamil
SharedInitCode__asan::Allocator270*ee754c2dSkamil void SharedInitCode(const AllocatorOptions &options) {
271*ee754c2dSkamil CheckOptions(options);
272*ee754c2dSkamil quarantine.Init((uptr)options.quarantine_size_mb << 20,
273*ee754c2dSkamil (uptr)options.thread_local_quarantine_size_kb << 10);
274*ee754c2dSkamil atomic_store(&alloc_dealloc_mismatch, options.alloc_dealloc_mismatch,
275*ee754c2dSkamil memory_order_release);
276*ee754c2dSkamil atomic_store(&min_redzone, options.min_redzone, memory_order_release);
277*ee754c2dSkamil atomic_store(&max_redzone, options.max_redzone, memory_order_release);
278*ee754c2dSkamil }
279*ee754c2dSkamil
InitLinkerInitialized__asan::Allocator280*ee754c2dSkamil void InitLinkerInitialized(const AllocatorOptions &options) {
281*ee754c2dSkamil SetAllocatorMayReturnNull(options.may_return_null);
282*ee754c2dSkamil allocator.InitLinkerInitialized(options.release_to_os_interval_ms);
283*ee754c2dSkamil SharedInitCode(options);
284*ee754c2dSkamil }
285*ee754c2dSkamil
RssLimitExceeded__asan::Allocator286*ee754c2dSkamil bool RssLimitExceeded() {
287*ee754c2dSkamil return atomic_load(&rss_limit_exceeded, memory_order_relaxed);
288*ee754c2dSkamil }
289*ee754c2dSkamil
SetRssLimitExceeded__asan::Allocator290*ee754c2dSkamil void SetRssLimitExceeded(bool limit_exceeded) {
291*ee754c2dSkamil atomic_store(&rss_limit_exceeded, limit_exceeded, memory_order_relaxed);
292*ee754c2dSkamil }
293*ee754c2dSkamil
RePoisonChunk__asan::Allocator294*ee754c2dSkamil void RePoisonChunk(uptr chunk) {
295*ee754c2dSkamil // This could be a user-facing chunk (with redzones), or some internal
296*ee754c2dSkamil // housekeeping chunk, like TransferBatch. Start by assuming the former.
297*ee754c2dSkamil AsanChunk *ac = GetAsanChunk((void *)chunk);
298*ee754c2dSkamil uptr allocated_size = allocator.GetActuallyAllocatedSize((void *)ac);
299*ee754c2dSkamil uptr beg = ac->Beg();
300*ee754c2dSkamil uptr end = ac->Beg() + ac->UsedSize(true);
301*ee754c2dSkamil uptr chunk_end = chunk + allocated_size;
302*ee754c2dSkamil if (chunk < beg && beg < end && end <= chunk_end &&
303*ee754c2dSkamil ac->chunk_state == CHUNK_ALLOCATED) {
304*ee754c2dSkamil // Looks like a valid AsanChunk in use, poison redzones only.
305*ee754c2dSkamil PoisonShadow(chunk, beg - chunk, kAsanHeapLeftRedzoneMagic);
306*ee754c2dSkamil uptr end_aligned_down = RoundDownTo(end, SHADOW_GRANULARITY);
307*ee754c2dSkamil FastPoisonShadowPartialRightRedzone(
308*ee754c2dSkamil end_aligned_down, end - end_aligned_down,
309*ee754c2dSkamil chunk_end - end_aligned_down, kAsanHeapLeftRedzoneMagic);
310*ee754c2dSkamil } else {
311*ee754c2dSkamil // This is either not an AsanChunk or freed or quarantined AsanChunk.
312*ee754c2dSkamil // In either case, poison everything.
313*ee754c2dSkamil PoisonShadow(chunk, allocated_size, kAsanHeapLeftRedzoneMagic);
314*ee754c2dSkamil }
315*ee754c2dSkamil }
316*ee754c2dSkamil
ReInitialize__asan::Allocator317*ee754c2dSkamil void ReInitialize(const AllocatorOptions &options) {
318*ee754c2dSkamil SetAllocatorMayReturnNull(options.may_return_null);
319*ee754c2dSkamil allocator.SetReleaseToOSIntervalMs(options.release_to_os_interval_ms);
320*ee754c2dSkamil SharedInitCode(options);
321*ee754c2dSkamil
322*ee754c2dSkamil // Poison all existing allocation's redzones.
323*ee754c2dSkamil if (CanPoisonMemory()) {
324*ee754c2dSkamil allocator.ForceLock();
325*ee754c2dSkamil allocator.ForEachChunk(
326*ee754c2dSkamil [](uptr chunk, void *alloc) {
327*ee754c2dSkamil ((Allocator *)alloc)->RePoisonChunk(chunk);
328*ee754c2dSkamil },
329*ee754c2dSkamil this);
330*ee754c2dSkamil allocator.ForceUnlock();
331*ee754c2dSkamil }
332*ee754c2dSkamil }
333*ee754c2dSkamil
GetOptions__asan::Allocator334*ee754c2dSkamil void GetOptions(AllocatorOptions *options) const {
335*ee754c2dSkamil options->quarantine_size_mb = quarantine.GetSize() >> 20;
336*ee754c2dSkamil options->thread_local_quarantine_size_kb = quarantine.GetCacheSize() >> 10;
337*ee754c2dSkamil options->min_redzone = atomic_load(&min_redzone, memory_order_acquire);
338*ee754c2dSkamil options->max_redzone = atomic_load(&max_redzone, memory_order_acquire);
339*ee754c2dSkamil options->may_return_null = AllocatorMayReturnNull();
340*ee754c2dSkamil options->alloc_dealloc_mismatch =
341*ee754c2dSkamil atomic_load(&alloc_dealloc_mismatch, memory_order_acquire);
342*ee754c2dSkamil options->release_to_os_interval_ms = allocator.ReleaseToOSIntervalMs();
343*ee754c2dSkamil }
344*ee754c2dSkamil
345*ee754c2dSkamil // -------------------- Helper methods. -------------------------
ComputeRZLog__asan::Allocator346*ee754c2dSkamil uptr ComputeRZLog(uptr user_requested_size) {
347*ee754c2dSkamil u32 rz_log =
348*ee754c2dSkamil user_requested_size <= 64 - 16 ? 0 :
349*ee754c2dSkamil user_requested_size <= 128 - 32 ? 1 :
350*ee754c2dSkamil user_requested_size <= 512 - 64 ? 2 :
351*ee754c2dSkamil user_requested_size <= 4096 - 128 ? 3 :
352*ee754c2dSkamil user_requested_size <= (1 << 14) - 256 ? 4 :
353*ee754c2dSkamil user_requested_size <= (1 << 15) - 512 ? 5 :
354*ee754c2dSkamil user_requested_size <= (1 << 16) - 1024 ? 6 : 7;
355*ee754c2dSkamil u32 min_rz = atomic_load(&min_redzone, memory_order_acquire);
356*ee754c2dSkamil u32 max_rz = atomic_load(&max_redzone, memory_order_acquire);
357*ee754c2dSkamil return Min(Max(rz_log, RZSize2Log(min_rz)), RZSize2Log(max_rz));
358*ee754c2dSkamil }
359*ee754c2dSkamil
ComputeUserRequestedAlignmentLog__asan::Allocator360*ee754c2dSkamil static uptr ComputeUserRequestedAlignmentLog(uptr user_requested_alignment) {
361*ee754c2dSkamil if (user_requested_alignment < 8)
362*ee754c2dSkamil return 0;
363*ee754c2dSkamil if (user_requested_alignment > 512)
364*ee754c2dSkamil user_requested_alignment = 512;
365*ee754c2dSkamil return Log2(user_requested_alignment) - 2;
366*ee754c2dSkamil }
367*ee754c2dSkamil
ComputeUserAlignment__asan::Allocator368*ee754c2dSkamil static uptr ComputeUserAlignment(uptr user_requested_alignment_log) {
369*ee754c2dSkamil if (user_requested_alignment_log == 0)
370*ee754c2dSkamil return 0;
371*ee754c2dSkamil return 1LL << (user_requested_alignment_log + 2);
372*ee754c2dSkamil }
373*ee754c2dSkamil
374*ee754c2dSkamil // We have an address between two chunks, and we want to report just one.
ChooseChunk__asan::Allocator375*ee754c2dSkamil AsanChunk *ChooseChunk(uptr addr, AsanChunk *left_chunk,
376*ee754c2dSkamil AsanChunk *right_chunk) {
377*ee754c2dSkamil // Prefer an allocated chunk over freed chunk and freed chunk
378*ee754c2dSkamil // over available chunk.
379*ee754c2dSkamil if (left_chunk->chunk_state != right_chunk->chunk_state) {
380*ee754c2dSkamil if (left_chunk->chunk_state == CHUNK_ALLOCATED)
381*ee754c2dSkamil return left_chunk;
382*ee754c2dSkamil if (right_chunk->chunk_state == CHUNK_ALLOCATED)
383*ee754c2dSkamil return right_chunk;
384*ee754c2dSkamil if (left_chunk->chunk_state == CHUNK_QUARANTINE)
385*ee754c2dSkamil return left_chunk;
386*ee754c2dSkamil if (right_chunk->chunk_state == CHUNK_QUARANTINE)
387*ee754c2dSkamil return right_chunk;
388*ee754c2dSkamil }
389*ee754c2dSkamil // Same chunk_state: choose based on offset.
390*ee754c2dSkamil sptr l_offset = 0, r_offset = 0;
391*ee754c2dSkamil CHECK(AsanChunkView(left_chunk).AddrIsAtRight(addr, 1, &l_offset));
392*ee754c2dSkamil CHECK(AsanChunkView(right_chunk).AddrIsAtLeft(addr, 1, &r_offset));
393*ee754c2dSkamil if (l_offset < r_offset)
394*ee754c2dSkamil return left_chunk;
395*ee754c2dSkamil return right_chunk;
396*ee754c2dSkamil }
397*ee754c2dSkamil
398*ee754c2dSkamil // -------------------- Allocation/Deallocation routines ---------------
Allocate__asan::Allocator399*ee754c2dSkamil void *Allocate(uptr size, uptr alignment, BufferedStackTrace *stack,
400*ee754c2dSkamil AllocType alloc_type, bool can_fill) {
401*ee754c2dSkamil if (UNLIKELY(!asan_inited))
402*ee754c2dSkamil AsanInitFromRtl();
403*ee754c2dSkamil if (RssLimitExceeded()) {
404*ee754c2dSkamil if (AllocatorMayReturnNull())
405*ee754c2dSkamil return nullptr;
406*ee754c2dSkamil ReportRssLimitExceeded(stack);
407*ee754c2dSkamil }
408*ee754c2dSkamil Flags &fl = *flags();
409*ee754c2dSkamil CHECK(stack);
410*ee754c2dSkamil const uptr min_alignment = SHADOW_GRANULARITY;
411*ee754c2dSkamil const uptr user_requested_alignment_log =
412*ee754c2dSkamil ComputeUserRequestedAlignmentLog(alignment);
413*ee754c2dSkamil if (alignment < min_alignment)
414*ee754c2dSkamil alignment = min_alignment;
415*ee754c2dSkamil if (size == 0) {
416*ee754c2dSkamil // We'd be happy to avoid allocating memory for zero-size requests, but
417*ee754c2dSkamil // some programs/tests depend on this behavior and assume that malloc
418*ee754c2dSkamil // would not return NULL even for zero-size allocations. Moreover, it
419*ee754c2dSkamil // looks like operator new should never return NULL, and results of
420*ee754c2dSkamil // consecutive "new" calls must be different even if the allocated size
421*ee754c2dSkamil // is zero.
422*ee754c2dSkamil size = 1;
423*ee754c2dSkamil }
424*ee754c2dSkamil CHECK(IsPowerOfTwo(alignment));
425*ee754c2dSkamil uptr rz_log = ComputeRZLog(size);
426*ee754c2dSkamil uptr rz_size = RZLog2Size(rz_log);
427*ee754c2dSkamil uptr rounded_size = RoundUpTo(Max(size, kChunkHeader2Size), alignment);
428*ee754c2dSkamil uptr needed_size = rounded_size + rz_size;
429*ee754c2dSkamil if (alignment > min_alignment)
430*ee754c2dSkamil needed_size += alignment;
431*ee754c2dSkamil bool using_primary_allocator = true;
432*ee754c2dSkamil // If we are allocating from the secondary allocator, there will be no
433*ee754c2dSkamil // automatic right redzone, so add the right redzone manually.
434*ee754c2dSkamil if (!PrimaryAllocator::CanAllocate(needed_size, alignment)) {
435*ee754c2dSkamil needed_size += rz_size;
436*ee754c2dSkamil using_primary_allocator = false;
437*ee754c2dSkamil }
438*ee754c2dSkamil CHECK(IsAligned(needed_size, min_alignment));
439*ee754c2dSkamil if (size > kMaxAllowedMallocSize || needed_size > kMaxAllowedMallocSize) {
440*ee754c2dSkamil if (AllocatorMayReturnNull()) {
441*ee754c2dSkamil Report("WARNING: AddressSanitizer failed to allocate 0x%zx bytes\n",
442*ee754c2dSkamil (void*)size);
443*ee754c2dSkamil return nullptr;
444*ee754c2dSkamil }
445*ee754c2dSkamil ReportAllocationSizeTooBig(size, needed_size, kMaxAllowedMallocSize,
446*ee754c2dSkamil stack);
447*ee754c2dSkamil }
448*ee754c2dSkamil
449*ee754c2dSkamil AsanThread *t = GetCurrentThread();
450*ee754c2dSkamil void *allocated;
451*ee754c2dSkamil if (t) {
452*ee754c2dSkamil AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
453*ee754c2dSkamil allocated = allocator.Allocate(cache, needed_size, 8);
454*ee754c2dSkamil } else {
455*ee754c2dSkamil SpinMutexLock l(&fallback_mutex);
456*ee754c2dSkamil AllocatorCache *cache = &fallback_allocator_cache;
457*ee754c2dSkamil allocated = allocator.Allocate(cache, needed_size, 8);
458*ee754c2dSkamil }
459*ee754c2dSkamil if (UNLIKELY(!allocated)) {
460*ee754c2dSkamil SetAllocatorOutOfMemory();
461*ee754c2dSkamil if (AllocatorMayReturnNull())
462*ee754c2dSkamil return nullptr;
463*ee754c2dSkamil ReportOutOfMemory(size, stack);
464*ee754c2dSkamil }
465*ee754c2dSkamil
466*ee754c2dSkamil if (*(u8 *)MEM_TO_SHADOW((uptr)allocated) == 0 && CanPoisonMemory()) {
467*ee754c2dSkamil // Heap poisoning is enabled, but the allocator provides an unpoisoned
468*ee754c2dSkamil // chunk. This is possible if CanPoisonMemory() was false for some
469*ee754c2dSkamil // time, for example, due to flags()->start_disabled.
470*ee754c2dSkamil // Anyway, poison the block before using it for anything else.
471*ee754c2dSkamil uptr allocated_size = allocator.GetActuallyAllocatedSize(allocated);
472*ee754c2dSkamil PoisonShadow((uptr)allocated, allocated_size, kAsanHeapLeftRedzoneMagic);
473*ee754c2dSkamil }
474*ee754c2dSkamil
475*ee754c2dSkamil uptr alloc_beg = reinterpret_cast<uptr>(allocated);
476*ee754c2dSkamil uptr alloc_end = alloc_beg + needed_size;
477*ee754c2dSkamil uptr beg_plus_redzone = alloc_beg + rz_size;
478*ee754c2dSkamil uptr user_beg = beg_plus_redzone;
479*ee754c2dSkamil if (!IsAligned(user_beg, alignment))
480*ee754c2dSkamil user_beg = RoundUpTo(user_beg, alignment);
481*ee754c2dSkamil uptr user_end = user_beg + size;
482*ee754c2dSkamil CHECK_LE(user_end, alloc_end);
483*ee754c2dSkamil uptr chunk_beg = user_beg - kChunkHeaderSize;
484*ee754c2dSkamil AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
485*ee754c2dSkamil m->alloc_type = alloc_type;
486*ee754c2dSkamil m->rz_log = rz_log;
487*ee754c2dSkamil u32 alloc_tid = t ? t->tid() : 0;
488*ee754c2dSkamil m->alloc_tid = alloc_tid;
489*ee754c2dSkamil CHECK_EQ(alloc_tid, m->alloc_tid); // Does alloc_tid fit into the bitfield?
490*ee754c2dSkamil m->free_tid = kInvalidTid;
491*ee754c2dSkamil m->from_memalign = user_beg != beg_plus_redzone;
492*ee754c2dSkamil if (alloc_beg != chunk_beg) {
493*ee754c2dSkamil CHECK_LE(alloc_beg+ 2 * sizeof(uptr), chunk_beg);
494*ee754c2dSkamil reinterpret_cast<uptr *>(alloc_beg)[0] = kAllocBegMagic;
495*ee754c2dSkamil reinterpret_cast<uptr *>(alloc_beg)[1] = chunk_beg;
496*ee754c2dSkamil }
497*ee754c2dSkamil if (using_primary_allocator) {
498*ee754c2dSkamil CHECK(size);
499*ee754c2dSkamil m->user_requested_size = size;
500*ee754c2dSkamil CHECK(allocator.FromPrimary(allocated));
501*ee754c2dSkamil } else {
502*ee754c2dSkamil CHECK(!allocator.FromPrimary(allocated));
503*ee754c2dSkamil m->user_requested_size = SizeClassMap::kMaxSize;
504*ee754c2dSkamil uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(allocated));
505*ee754c2dSkamil meta[0] = size;
506*ee754c2dSkamil meta[1] = chunk_beg;
507*ee754c2dSkamil }
508*ee754c2dSkamil m->user_requested_alignment_log = user_requested_alignment_log;
509*ee754c2dSkamil
510*ee754c2dSkamil m->alloc_context_id = StackDepotPut(*stack);
511*ee754c2dSkamil
512*ee754c2dSkamil uptr size_rounded_down_to_granularity =
513*ee754c2dSkamil RoundDownTo(size, SHADOW_GRANULARITY);
514*ee754c2dSkamil // Unpoison the bulk of the memory region.
515*ee754c2dSkamil if (size_rounded_down_to_granularity)
516*ee754c2dSkamil PoisonShadow(user_beg, size_rounded_down_to_granularity, 0);
517*ee754c2dSkamil // Deal with the end of the region if size is not aligned to granularity.
518*ee754c2dSkamil if (size != size_rounded_down_to_granularity && CanPoisonMemory()) {
519*ee754c2dSkamil u8 *shadow =
520*ee754c2dSkamil (u8 *)MemToShadow(user_beg + size_rounded_down_to_granularity);
521*ee754c2dSkamil *shadow = fl.poison_partial ? (size & (SHADOW_GRANULARITY - 1)) : 0;
522*ee754c2dSkamil }
523*ee754c2dSkamil
524*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
525*ee754c2dSkamil thread_stats.mallocs++;
526*ee754c2dSkamil thread_stats.malloced += size;
527*ee754c2dSkamil thread_stats.malloced_redzones += needed_size - size;
528*ee754c2dSkamil if (needed_size > SizeClassMap::kMaxSize)
529*ee754c2dSkamil thread_stats.malloc_large++;
530*ee754c2dSkamil else
531*ee754c2dSkamil thread_stats.malloced_by_size[SizeClassMap::ClassID(needed_size)]++;
532*ee754c2dSkamil
533*ee754c2dSkamil void *res = reinterpret_cast<void *>(user_beg);
534*ee754c2dSkamil if (can_fill && fl.max_malloc_fill_size) {
535*ee754c2dSkamil uptr fill_size = Min(size, (uptr)fl.max_malloc_fill_size);
536*ee754c2dSkamil REAL(memset)(res, fl.malloc_fill_byte, fill_size);
537*ee754c2dSkamil }
538*ee754c2dSkamil #if CAN_SANITIZE_LEAKS
539*ee754c2dSkamil m->lsan_tag = __lsan::DisabledInThisThread() ? __lsan::kIgnored
540*ee754c2dSkamil : __lsan::kDirectlyLeaked;
541*ee754c2dSkamil #endif
542*ee754c2dSkamil // Must be the last mutation of metadata in this function.
543*ee754c2dSkamil atomic_store((atomic_uint8_t *)m, CHUNK_ALLOCATED, memory_order_release);
544*ee754c2dSkamil ASAN_MALLOC_HOOK(res, size);
545*ee754c2dSkamil return res;
546*ee754c2dSkamil }
547*ee754c2dSkamil
548*ee754c2dSkamil // Set quarantine flag if chunk is allocated, issue ASan error report on
549*ee754c2dSkamil // available and quarantined chunks. Return true on success, false otherwise.
AtomicallySetQuarantineFlagIfAllocated__asan::Allocator550*ee754c2dSkamil bool AtomicallySetQuarantineFlagIfAllocated(AsanChunk *m, void *ptr,
551*ee754c2dSkamil BufferedStackTrace *stack) {
552*ee754c2dSkamil u8 old_chunk_state = CHUNK_ALLOCATED;
553*ee754c2dSkamil // Flip the chunk_state atomically to avoid race on double-free.
554*ee754c2dSkamil if (!atomic_compare_exchange_strong((atomic_uint8_t *)m, &old_chunk_state,
555*ee754c2dSkamil CHUNK_QUARANTINE,
556*ee754c2dSkamil memory_order_acquire)) {
557*ee754c2dSkamil ReportInvalidFree(ptr, old_chunk_state, stack);
558*ee754c2dSkamil // It's not safe to push a chunk in quarantine on invalid free.
559*ee754c2dSkamil return false;
560*ee754c2dSkamil }
561*ee754c2dSkamil CHECK_EQ(CHUNK_ALLOCATED, old_chunk_state);
562*ee754c2dSkamil return true;
563*ee754c2dSkamil }
564*ee754c2dSkamil
565*ee754c2dSkamil // Expects the chunk to already be marked as quarantined by using
566*ee754c2dSkamil // AtomicallySetQuarantineFlagIfAllocated.
QuarantineChunk__asan::Allocator567*ee754c2dSkamil void QuarantineChunk(AsanChunk *m, void *ptr, BufferedStackTrace *stack) {
568*ee754c2dSkamil CHECK_EQ(m->chunk_state, CHUNK_QUARANTINE);
569*ee754c2dSkamil CHECK_GE(m->alloc_tid, 0);
570*ee754c2dSkamil if (SANITIZER_WORDSIZE == 64) // On 32-bits this resides in user area.
571*ee754c2dSkamil CHECK_EQ(m->free_tid, kInvalidTid);
572*ee754c2dSkamil AsanThread *t = GetCurrentThread();
573*ee754c2dSkamil m->free_tid = t ? t->tid() : 0;
574*ee754c2dSkamil m->free_context_id = StackDepotPut(*stack);
575*ee754c2dSkamil
576*ee754c2dSkamil Flags &fl = *flags();
577*ee754c2dSkamil if (fl.max_free_fill_size > 0) {
578*ee754c2dSkamil // We have to skip the chunk header, it contains free_context_id.
579*ee754c2dSkamil uptr scribble_start = (uptr)m + kChunkHeaderSize + kChunkHeader2Size;
580*ee754c2dSkamil if (m->UsedSize() >= kChunkHeader2Size) { // Skip Header2 in user area.
581*ee754c2dSkamil uptr size_to_fill = m->UsedSize() - kChunkHeader2Size;
582*ee754c2dSkamil size_to_fill = Min(size_to_fill, (uptr)fl.max_free_fill_size);
583*ee754c2dSkamil REAL(memset)((void *)scribble_start, fl.free_fill_byte, size_to_fill);
584*ee754c2dSkamil }
585*ee754c2dSkamil }
586*ee754c2dSkamil
587*ee754c2dSkamil // Poison the region.
588*ee754c2dSkamil PoisonShadow(m->Beg(),
589*ee754c2dSkamil RoundUpTo(m->UsedSize(), SHADOW_GRANULARITY),
590*ee754c2dSkamil kAsanHeapFreeMagic);
591*ee754c2dSkamil
592*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
593*ee754c2dSkamil thread_stats.frees++;
594*ee754c2dSkamil thread_stats.freed += m->UsedSize();
595*ee754c2dSkamil
596*ee754c2dSkamil // Push into quarantine.
597*ee754c2dSkamil if (t) {
598*ee754c2dSkamil AsanThreadLocalMallocStorage *ms = &t->malloc_storage();
599*ee754c2dSkamil AllocatorCache *ac = GetAllocatorCache(ms);
600*ee754c2dSkamil quarantine.Put(GetQuarantineCache(ms), QuarantineCallback(ac, stack), m,
601*ee754c2dSkamil m->UsedSize());
602*ee754c2dSkamil } else {
603*ee754c2dSkamil SpinMutexLock l(&fallback_mutex);
604*ee754c2dSkamil AllocatorCache *ac = &fallback_allocator_cache;
605*ee754c2dSkamil quarantine.Put(&fallback_quarantine_cache, QuarantineCallback(ac, stack),
606*ee754c2dSkamil m, m->UsedSize());
607*ee754c2dSkamil }
608*ee754c2dSkamil }
609*ee754c2dSkamil
Deallocate__asan::Allocator610*ee754c2dSkamil void Deallocate(void *ptr, uptr delete_size, uptr delete_alignment,
611*ee754c2dSkamil BufferedStackTrace *stack, AllocType alloc_type) {
612*ee754c2dSkamil uptr p = reinterpret_cast<uptr>(ptr);
613*ee754c2dSkamil if (p == 0) return;
614*ee754c2dSkamil
615*ee754c2dSkamil uptr chunk_beg = p - kChunkHeaderSize;
616*ee754c2dSkamil AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
617*ee754c2dSkamil
618*ee754c2dSkamil // On Windows, uninstrumented DLLs may allocate memory before ASan hooks
619*ee754c2dSkamil // malloc. Don't report an invalid free in this case.
620*ee754c2dSkamil if (SANITIZER_WINDOWS &&
621*ee754c2dSkamil !get_allocator().PointerIsMine(ptr)) {
622*ee754c2dSkamil if (!IsSystemHeapAddress(p))
623*ee754c2dSkamil ReportFreeNotMalloced(p, stack);
624*ee754c2dSkamil return;
625*ee754c2dSkamil }
626*ee754c2dSkamil
627*ee754c2dSkamil ASAN_FREE_HOOK(ptr);
628*ee754c2dSkamil
629*ee754c2dSkamil // Must mark the chunk as quarantined before any changes to its metadata.
630*ee754c2dSkamil // Do not quarantine given chunk if we failed to set CHUNK_QUARANTINE flag.
631*ee754c2dSkamil if (!AtomicallySetQuarantineFlagIfAllocated(m, ptr, stack)) return;
632*ee754c2dSkamil
633*ee754c2dSkamil if (m->alloc_type != alloc_type) {
634*ee754c2dSkamil if (atomic_load(&alloc_dealloc_mismatch, memory_order_acquire)) {
635*ee754c2dSkamil ReportAllocTypeMismatch((uptr)ptr, stack, (AllocType)m->alloc_type,
636*ee754c2dSkamil (AllocType)alloc_type);
637*ee754c2dSkamil }
638*ee754c2dSkamil } else {
639*ee754c2dSkamil if (flags()->new_delete_type_mismatch &&
640*ee754c2dSkamil (alloc_type == FROM_NEW || alloc_type == FROM_NEW_BR) &&
641*ee754c2dSkamil ((delete_size && delete_size != m->UsedSize()) ||
642*ee754c2dSkamil ComputeUserRequestedAlignmentLog(delete_alignment) !=
643*ee754c2dSkamil m->user_requested_alignment_log)) {
644*ee754c2dSkamil ReportNewDeleteTypeMismatch(p, delete_size, delete_alignment, stack);
645*ee754c2dSkamil }
646*ee754c2dSkamil }
647*ee754c2dSkamil
648*ee754c2dSkamil QuarantineChunk(m, ptr, stack);
649*ee754c2dSkamil }
650*ee754c2dSkamil
Reallocate__asan::Allocator651*ee754c2dSkamil void *Reallocate(void *old_ptr, uptr new_size, BufferedStackTrace *stack) {
652*ee754c2dSkamil CHECK(old_ptr && new_size);
653*ee754c2dSkamil uptr p = reinterpret_cast<uptr>(old_ptr);
654*ee754c2dSkamil uptr chunk_beg = p - kChunkHeaderSize;
655*ee754c2dSkamil AsanChunk *m = reinterpret_cast<AsanChunk *>(chunk_beg);
656*ee754c2dSkamil
657*ee754c2dSkamil AsanStats &thread_stats = GetCurrentThreadStats();
658*ee754c2dSkamil thread_stats.reallocs++;
659*ee754c2dSkamil thread_stats.realloced += new_size;
660*ee754c2dSkamil
661*ee754c2dSkamil void *new_ptr = Allocate(new_size, 8, stack, FROM_MALLOC, true);
662*ee754c2dSkamil if (new_ptr) {
663*ee754c2dSkamil u8 chunk_state = m->chunk_state;
664*ee754c2dSkamil if (chunk_state != CHUNK_ALLOCATED)
665*ee754c2dSkamil ReportInvalidFree(old_ptr, chunk_state, stack);
666*ee754c2dSkamil CHECK_NE(REAL(memcpy), nullptr);
667*ee754c2dSkamil uptr memcpy_size = Min(new_size, m->UsedSize());
668*ee754c2dSkamil // If realloc() races with free(), we may start copying freed memory.
669*ee754c2dSkamil // However, we will report racy double-free later anyway.
670*ee754c2dSkamil REAL(memcpy)(new_ptr, old_ptr, memcpy_size);
671*ee754c2dSkamil Deallocate(old_ptr, 0, 0, stack, FROM_MALLOC);
672*ee754c2dSkamil }
673*ee754c2dSkamil return new_ptr;
674*ee754c2dSkamil }
675*ee754c2dSkamil
Calloc__asan::Allocator676*ee754c2dSkamil void *Calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
677*ee754c2dSkamil if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
678*ee754c2dSkamil if (AllocatorMayReturnNull())
679*ee754c2dSkamil return nullptr;
680*ee754c2dSkamil ReportCallocOverflow(nmemb, size, stack);
681*ee754c2dSkamil }
682*ee754c2dSkamil void *ptr = Allocate(nmemb * size, 8, stack, FROM_MALLOC, false);
683*ee754c2dSkamil // If the memory comes from the secondary allocator no need to clear it
684*ee754c2dSkamil // as it comes directly from mmap.
685*ee754c2dSkamil if (ptr && allocator.FromPrimary(ptr))
686*ee754c2dSkamil REAL(memset)(ptr, 0, nmemb * size);
687*ee754c2dSkamil return ptr;
688*ee754c2dSkamil }
689*ee754c2dSkamil
ReportInvalidFree__asan::Allocator690*ee754c2dSkamil void ReportInvalidFree(void *ptr, u8 chunk_state, BufferedStackTrace *stack) {
691*ee754c2dSkamil if (chunk_state == CHUNK_QUARANTINE)
692*ee754c2dSkamil ReportDoubleFree((uptr)ptr, stack);
693*ee754c2dSkamil else
694*ee754c2dSkamil ReportFreeNotMalloced((uptr)ptr, stack);
695*ee754c2dSkamil }
696*ee754c2dSkamil
CommitBack__asan::Allocator697*ee754c2dSkamil void CommitBack(AsanThreadLocalMallocStorage *ms, BufferedStackTrace *stack) {
698*ee754c2dSkamil AllocatorCache *ac = GetAllocatorCache(ms);
699*ee754c2dSkamil quarantine.Drain(GetQuarantineCache(ms), QuarantineCallback(ac, stack));
700*ee754c2dSkamil allocator.SwallowCache(ac);
701*ee754c2dSkamil }
702*ee754c2dSkamil
703*ee754c2dSkamil // -------------------------- Chunk lookup ----------------------
704*ee754c2dSkamil
705*ee754c2dSkamil // Assumes alloc_beg == allocator.GetBlockBegin(alloc_beg).
GetAsanChunk__asan::Allocator706*ee754c2dSkamil AsanChunk *GetAsanChunk(void *alloc_beg) {
707*ee754c2dSkamil if (!alloc_beg) return nullptr;
708*ee754c2dSkamil if (!allocator.FromPrimary(alloc_beg)) {
709*ee754c2dSkamil uptr *meta = reinterpret_cast<uptr *>(allocator.GetMetaData(alloc_beg));
710*ee754c2dSkamil AsanChunk *m = reinterpret_cast<AsanChunk *>(meta[1]);
711*ee754c2dSkamil return m;
712*ee754c2dSkamil }
713*ee754c2dSkamil uptr *alloc_magic = reinterpret_cast<uptr *>(alloc_beg);
714*ee754c2dSkamil if (alloc_magic[0] == kAllocBegMagic)
715*ee754c2dSkamil return reinterpret_cast<AsanChunk *>(alloc_magic[1]);
716*ee754c2dSkamil return reinterpret_cast<AsanChunk *>(alloc_beg);
717*ee754c2dSkamil }
718*ee754c2dSkamil
GetAsanChunkByAddr__asan::Allocator719*ee754c2dSkamil AsanChunk *GetAsanChunkByAddr(uptr p) {
720*ee754c2dSkamil void *alloc_beg = allocator.GetBlockBegin(reinterpret_cast<void *>(p));
721*ee754c2dSkamil return GetAsanChunk(alloc_beg);
722*ee754c2dSkamil }
723*ee754c2dSkamil
724*ee754c2dSkamil // Allocator must be locked when this function is called.
GetAsanChunkByAddrFastLocked__asan::Allocator725*ee754c2dSkamil AsanChunk *GetAsanChunkByAddrFastLocked(uptr p) {
726*ee754c2dSkamil void *alloc_beg =
727*ee754c2dSkamil allocator.GetBlockBeginFastLocked(reinterpret_cast<void *>(p));
728*ee754c2dSkamil return GetAsanChunk(alloc_beg);
729*ee754c2dSkamil }
730*ee754c2dSkamil
AllocationSize__asan::Allocator731*ee754c2dSkamil uptr AllocationSize(uptr p) {
732*ee754c2dSkamil AsanChunk *m = GetAsanChunkByAddr(p);
733*ee754c2dSkamil if (!m) return 0;
734*ee754c2dSkamil if (m->chunk_state != CHUNK_ALLOCATED) return 0;
735*ee754c2dSkamil if (m->Beg() != p) return 0;
736*ee754c2dSkamil return m->UsedSize();
737*ee754c2dSkamil }
738*ee754c2dSkamil
FindHeapChunkByAddress__asan::Allocator739*ee754c2dSkamil AsanChunkView FindHeapChunkByAddress(uptr addr) {
740*ee754c2dSkamil AsanChunk *m1 = GetAsanChunkByAddr(addr);
741*ee754c2dSkamil if (!m1) return AsanChunkView(m1);
742*ee754c2dSkamil sptr offset = 0;
743*ee754c2dSkamil if (AsanChunkView(m1).AddrIsAtLeft(addr, 1, &offset)) {
744*ee754c2dSkamil // The address is in the chunk's left redzone, so maybe it is actually
745*ee754c2dSkamil // a right buffer overflow from the other chunk to the left.
746*ee754c2dSkamil // Search a bit to the left to see if there is another chunk.
747*ee754c2dSkamil AsanChunk *m2 = nullptr;
748*ee754c2dSkamil for (uptr l = 1; l < GetPageSizeCached(); l++) {
749*ee754c2dSkamil m2 = GetAsanChunkByAddr(addr - l);
750*ee754c2dSkamil if (m2 == m1) continue; // Still the same chunk.
751*ee754c2dSkamil break;
752*ee754c2dSkamil }
753*ee754c2dSkamil if (m2 && AsanChunkView(m2).AddrIsAtRight(addr, 1, &offset))
754*ee754c2dSkamil m1 = ChooseChunk(addr, m2, m1);
755*ee754c2dSkamil }
756*ee754c2dSkamil return AsanChunkView(m1);
757*ee754c2dSkamil }
758*ee754c2dSkamil
Purge__asan::Allocator759*ee754c2dSkamil void Purge(BufferedStackTrace *stack) {
760*ee754c2dSkamil AsanThread *t = GetCurrentThread();
761*ee754c2dSkamil if (t) {
762*ee754c2dSkamil AsanThreadLocalMallocStorage *ms = &t->malloc_storage();
763*ee754c2dSkamil quarantine.DrainAndRecycle(GetQuarantineCache(ms),
764*ee754c2dSkamil QuarantineCallback(GetAllocatorCache(ms),
765*ee754c2dSkamil stack));
766*ee754c2dSkamil }
767*ee754c2dSkamil {
768*ee754c2dSkamil SpinMutexLock l(&fallback_mutex);
769*ee754c2dSkamil quarantine.DrainAndRecycle(&fallback_quarantine_cache,
770*ee754c2dSkamil QuarantineCallback(&fallback_allocator_cache,
771*ee754c2dSkamil stack));
772*ee754c2dSkamil }
773*ee754c2dSkamil
774*ee754c2dSkamil allocator.ForceReleaseToOS();
775*ee754c2dSkamil }
776*ee754c2dSkamil
PrintStats__asan::Allocator777*ee754c2dSkamil void PrintStats() {
778*ee754c2dSkamil allocator.PrintStats();
779*ee754c2dSkamil quarantine.PrintStats();
780*ee754c2dSkamil }
781*ee754c2dSkamil
ForceLock__asan::Allocator782*ee754c2dSkamil void ForceLock() {
783*ee754c2dSkamil allocator.ForceLock();
784*ee754c2dSkamil fallback_mutex.Lock();
785*ee754c2dSkamil }
786*ee754c2dSkamil
ForceUnlock__asan::Allocator787*ee754c2dSkamil void ForceUnlock() {
788*ee754c2dSkamil fallback_mutex.Unlock();
789*ee754c2dSkamil allocator.ForceUnlock();
790*ee754c2dSkamil }
791*ee754c2dSkamil };
792*ee754c2dSkamil
793*ee754c2dSkamil static Allocator instance(LINKER_INITIALIZED);
794*ee754c2dSkamil
get_allocator()795*ee754c2dSkamil static AsanAllocator &get_allocator() {
796*ee754c2dSkamil return instance.allocator;
797*ee754c2dSkamil }
798*ee754c2dSkamil
IsValid() const799*ee754c2dSkamil bool AsanChunkView::IsValid() const {
800*ee754c2dSkamil return chunk_ && chunk_->chunk_state != CHUNK_AVAILABLE;
801*ee754c2dSkamil }
IsAllocated() const802*ee754c2dSkamil bool AsanChunkView::IsAllocated() const {
803*ee754c2dSkamil return chunk_ && chunk_->chunk_state == CHUNK_ALLOCATED;
804*ee754c2dSkamil }
IsQuarantined() const805*ee754c2dSkamil bool AsanChunkView::IsQuarantined() const {
806*ee754c2dSkamil return chunk_ && chunk_->chunk_state == CHUNK_QUARANTINE;
807*ee754c2dSkamil }
Beg() const808*ee754c2dSkamil uptr AsanChunkView::Beg() const { return chunk_->Beg(); }
End() const809*ee754c2dSkamil uptr AsanChunkView::End() const { return Beg() + UsedSize(); }
UsedSize() const810*ee754c2dSkamil uptr AsanChunkView::UsedSize() const { return chunk_->UsedSize(); }
UserRequestedAlignment() const811*ee754c2dSkamil u32 AsanChunkView::UserRequestedAlignment() const {
812*ee754c2dSkamil return Allocator::ComputeUserAlignment(chunk_->user_requested_alignment_log);
813*ee754c2dSkamil }
AllocTid() const814*ee754c2dSkamil uptr AsanChunkView::AllocTid() const { return chunk_->alloc_tid; }
FreeTid() const815*ee754c2dSkamil uptr AsanChunkView::FreeTid() const { return chunk_->free_tid; }
GetAllocType() const816*ee754c2dSkamil AllocType AsanChunkView::GetAllocType() const {
817*ee754c2dSkamil return (AllocType)chunk_->alloc_type;
818*ee754c2dSkamil }
819*ee754c2dSkamil
GetStackTraceFromId(u32 id)820*ee754c2dSkamil static StackTrace GetStackTraceFromId(u32 id) {
821*ee754c2dSkamil CHECK(id);
822*ee754c2dSkamil StackTrace res = StackDepotGet(id);
823*ee754c2dSkamil CHECK(res.trace);
824*ee754c2dSkamil return res;
825*ee754c2dSkamil }
826*ee754c2dSkamil
GetAllocStackId() const827*ee754c2dSkamil u32 AsanChunkView::GetAllocStackId() const { return chunk_->alloc_context_id; }
GetFreeStackId() const828*ee754c2dSkamil u32 AsanChunkView::GetFreeStackId() const { return chunk_->free_context_id; }
829*ee754c2dSkamil
GetAllocStack() const830*ee754c2dSkamil StackTrace AsanChunkView::GetAllocStack() const {
831*ee754c2dSkamil return GetStackTraceFromId(GetAllocStackId());
832*ee754c2dSkamil }
833*ee754c2dSkamil
GetFreeStack() const834*ee754c2dSkamil StackTrace AsanChunkView::GetFreeStack() const {
835*ee754c2dSkamil return GetStackTraceFromId(GetFreeStackId());
836*ee754c2dSkamil }
837*ee754c2dSkamil
InitializeAllocator(const AllocatorOptions & options)838*ee754c2dSkamil void InitializeAllocator(const AllocatorOptions &options) {
839*ee754c2dSkamil instance.InitLinkerInitialized(options);
840*ee754c2dSkamil }
841*ee754c2dSkamil
ReInitializeAllocator(const AllocatorOptions & options)842*ee754c2dSkamil void ReInitializeAllocator(const AllocatorOptions &options) {
843*ee754c2dSkamil instance.ReInitialize(options);
844*ee754c2dSkamil }
845*ee754c2dSkamil
GetAllocatorOptions(AllocatorOptions * options)846*ee754c2dSkamil void GetAllocatorOptions(AllocatorOptions *options) {
847*ee754c2dSkamil instance.GetOptions(options);
848*ee754c2dSkamil }
849*ee754c2dSkamil
FindHeapChunkByAddress(uptr addr)850*ee754c2dSkamil AsanChunkView FindHeapChunkByAddress(uptr addr) {
851*ee754c2dSkamil return instance.FindHeapChunkByAddress(addr);
852*ee754c2dSkamil }
FindHeapChunkByAllocBeg(uptr addr)853*ee754c2dSkamil AsanChunkView FindHeapChunkByAllocBeg(uptr addr) {
854*ee754c2dSkamil return AsanChunkView(instance.GetAsanChunk(reinterpret_cast<void*>(addr)));
855*ee754c2dSkamil }
856*ee754c2dSkamil
CommitBack()857*ee754c2dSkamil void AsanThreadLocalMallocStorage::CommitBack() {
858*ee754c2dSkamil GET_STACK_TRACE_MALLOC;
859*ee754c2dSkamil instance.CommitBack(this, &stack);
860*ee754c2dSkamil }
861*ee754c2dSkamil
PrintInternalAllocatorStats()862*ee754c2dSkamil void PrintInternalAllocatorStats() {
863*ee754c2dSkamil instance.PrintStats();
864*ee754c2dSkamil }
865*ee754c2dSkamil
asan_free(void * ptr,BufferedStackTrace * stack,AllocType alloc_type)866*ee754c2dSkamil void asan_free(void *ptr, BufferedStackTrace *stack, AllocType alloc_type) {
867*ee754c2dSkamil instance.Deallocate(ptr, 0, 0, stack, alloc_type);
868*ee754c2dSkamil }
869*ee754c2dSkamil
asan_delete(void * ptr,uptr size,uptr alignment,BufferedStackTrace * stack,AllocType alloc_type)870*ee754c2dSkamil void asan_delete(void *ptr, uptr size, uptr alignment,
871*ee754c2dSkamil BufferedStackTrace *stack, AllocType alloc_type) {
872*ee754c2dSkamil instance.Deallocate(ptr, size, alignment, stack, alloc_type);
873*ee754c2dSkamil }
874*ee754c2dSkamil
asan_malloc(uptr size,BufferedStackTrace * stack)875*ee754c2dSkamil void *asan_malloc(uptr size, BufferedStackTrace *stack) {
876*ee754c2dSkamil return SetErrnoOnNull(instance.Allocate(size, 8, stack, FROM_MALLOC, true));
877*ee754c2dSkamil }
878*ee754c2dSkamil
asan_calloc(uptr nmemb,uptr size,BufferedStackTrace * stack)879*ee754c2dSkamil void *asan_calloc(uptr nmemb, uptr size, BufferedStackTrace *stack) {
880*ee754c2dSkamil return SetErrnoOnNull(instance.Calloc(nmemb, size, stack));
881*ee754c2dSkamil }
882*ee754c2dSkamil
asan_realloc(void * p,uptr size,BufferedStackTrace * stack)883*ee754c2dSkamil void *asan_realloc(void *p, uptr size, BufferedStackTrace *stack) {
884*ee754c2dSkamil if (!p)
885*ee754c2dSkamil return SetErrnoOnNull(instance.Allocate(size, 8, stack, FROM_MALLOC, true));
886*ee754c2dSkamil if (size == 0) {
887*ee754c2dSkamil if (flags()->allocator_frees_and_returns_null_on_realloc_zero) {
888*ee754c2dSkamil instance.Deallocate(p, 0, 0, stack, FROM_MALLOC);
889*ee754c2dSkamil return nullptr;
890*ee754c2dSkamil }
891*ee754c2dSkamil // Allocate a size of 1 if we shouldn't free() on Realloc to 0
892*ee754c2dSkamil size = 1;
893*ee754c2dSkamil }
894*ee754c2dSkamil return SetErrnoOnNull(instance.Reallocate(p, size, stack));
895*ee754c2dSkamil }
896*ee754c2dSkamil
asan_valloc(uptr size,BufferedStackTrace * stack)897*ee754c2dSkamil void *asan_valloc(uptr size, BufferedStackTrace *stack) {
898*ee754c2dSkamil return SetErrnoOnNull(
899*ee754c2dSkamil instance.Allocate(size, GetPageSizeCached(), stack, FROM_MALLOC, true));
900*ee754c2dSkamil }
901*ee754c2dSkamil
asan_pvalloc(uptr size,BufferedStackTrace * stack)902*ee754c2dSkamil void *asan_pvalloc(uptr size, BufferedStackTrace *stack) {
903*ee754c2dSkamil uptr PageSize = GetPageSizeCached();
904*ee754c2dSkamil if (UNLIKELY(CheckForPvallocOverflow(size, PageSize))) {
905*ee754c2dSkamil errno = errno_ENOMEM;
906*ee754c2dSkamil if (AllocatorMayReturnNull())
907*ee754c2dSkamil return nullptr;
908*ee754c2dSkamil ReportPvallocOverflow(size, stack);
909*ee754c2dSkamil }
910*ee754c2dSkamil // pvalloc(0) should allocate one page.
911*ee754c2dSkamil size = size ? RoundUpTo(size, PageSize) : PageSize;
912*ee754c2dSkamil return SetErrnoOnNull(
913*ee754c2dSkamil instance.Allocate(size, PageSize, stack, FROM_MALLOC, true));
914*ee754c2dSkamil }
915*ee754c2dSkamil
asan_memalign(uptr alignment,uptr size,BufferedStackTrace * stack,AllocType alloc_type)916*ee754c2dSkamil void *asan_memalign(uptr alignment, uptr size, BufferedStackTrace *stack,
917*ee754c2dSkamil AllocType alloc_type) {
918*ee754c2dSkamil if (UNLIKELY(!IsPowerOfTwo(alignment))) {
919*ee754c2dSkamil errno = errno_EINVAL;
920*ee754c2dSkamil if (AllocatorMayReturnNull())
921*ee754c2dSkamil return nullptr;
922*ee754c2dSkamil ReportInvalidAllocationAlignment(alignment, stack);
923*ee754c2dSkamil }
924*ee754c2dSkamil return SetErrnoOnNull(
925*ee754c2dSkamil instance.Allocate(size, alignment, stack, alloc_type, true));
926*ee754c2dSkamil }
927*ee754c2dSkamil
asan_aligned_alloc(uptr alignment,uptr size,BufferedStackTrace * stack)928*ee754c2dSkamil void *asan_aligned_alloc(uptr alignment, uptr size, BufferedStackTrace *stack) {
929*ee754c2dSkamil if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(alignment, size))) {
930*ee754c2dSkamil errno = errno_EINVAL;
931*ee754c2dSkamil if (AllocatorMayReturnNull())
932*ee754c2dSkamil return nullptr;
933*ee754c2dSkamil ReportInvalidAlignedAllocAlignment(size, alignment, stack);
934*ee754c2dSkamil }
935*ee754c2dSkamil return SetErrnoOnNull(
936*ee754c2dSkamil instance.Allocate(size, alignment, stack, FROM_MALLOC, true));
937*ee754c2dSkamil }
938*ee754c2dSkamil
asan_posix_memalign(void ** memptr,uptr alignment,uptr size,BufferedStackTrace * stack)939*ee754c2dSkamil int asan_posix_memalign(void **memptr, uptr alignment, uptr size,
940*ee754c2dSkamil BufferedStackTrace *stack) {
941*ee754c2dSkamil if (UNLIKELY(!CheckPosixMemalignAlignment(alignment))) {
942*ee754c2dSkamil if (AllocatorMayReturnNull())
943*ee754c2dSkamil return errno_EINVAL;
944*ee754c2dSkamil ReportInvalidPosixMemalignAlignment(alignment, stack);
945*ee754c2dSkamil }
946*ee754c2dSkamil void *ptr = instance.Allocate(size, alignment, stack, FROM_MALLOC, true);
947*ee754c2dSkamil if (UNLIKELY(!ptr))
948*ee754c2dSkamil // OOM error is already taken care of by Allocate.
949*ee754c2dSkamil return errno_ENOMEM;
950*ee754c2dSkamil CHECK(IsAligned((uptr)ptr, alignment));
951*ee754c2dSkamil *memptr = ptr;
952*ee754c2dSkamil return 0;
953*ee754c2dSkamil }
954*ee754c2dSkamil
asan_malloc_usable_size(const void * ptr,uptr pc,uptr bp)955*ee754c2dSkamil uptr asan_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
956*ee754c2dSkamil if (!ptr) return 0;
957*ee754c2dSkamil uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
958*ee754c2dSkamil if (flags()->check_malloc_usable_size && (usable_size == 0)) {
959*ee754c2dSkamil GET_STACK_TRACE_FATAL(pc, bp);
960*ee754c2dSkamil ReportMallocUsableSizeNotOwned((uptr)ptr, &stack);
961*ee754c2dSkamil }
962*ee754c2dSkamil return usable_size;
963*ee754c2dSkamil }
964*ee754c2dSkamil
asan_mz_size(const void * ptr)965*ee754c2dSkamil uptr asan_mz_size(const void *ptr) {
966*ee754c2dSkamil return instance.AllocationSize(reinterpret_cast<uptr>(ptr));
967*ee754c2dSkamil }
968*ee754c2dSkamil
asan_mz_force_lock()969*ee754c2dSkamil void asan_mz_force_lock() {
970*ee754c2dSkamil instance.ForceLock();
971*ee754c2dSkamil }
972*ee754c2dSkamil
asan_mz_force_unlock()973*ee754c2dSkamil void asan_mz_force_unlock() {
974*ee754c2dSkamil instance.ForceUnlock();
975*ee754c2dSkamil }
976*ee754c2dSkamil
AsanSoftRssLimitExceededCallback(bool limit_exceeded)977*ee754c2dSkamil void AsanSoftRssLimitExceededCallback(bool limit_exceeded) {
978*ee754c2dSkamil instance.SetRssLimitExceeded(limit_exceeded);
979*ee754c2dSkamil }
980*ee754c2dSkamil
981*ee754c2dSkamil } // namespace __asan
982*ee754c2dSkamil
983*ee754c2dSkamil // --- Implementation of LSan-specific functions --- {{{1
984*ee754c2dSkamil namespace __lsan {
LockAllocator()985*ee754c2dSkamil void LockAllocator() {
986*ee754c2dSkamil __asan::get_allocator().ForceLock();
987*ee754c2dSkamil }
988*ee754c2dSkamil
UnlockAllocator()989*ee754c2dSkamil void UnlockAllocator() {
990*ee754c2dSkamil __asan::get_allocator().ForceUnlock();
991*ee754c2dSkamil }
992*ee754c2dSkamil
GetAllocatorGlobalRange(uptr * begin,uptr * end)993*ee754c2dSkamil void GetAllocatorGlobalRange(uptr *begin, uptr *end) {
994*ee754c2dSkamil *begin = (uptr)&__asan::get_allocator();
995*ee754c2dSkamil *end = *begin + sizeof(__asan::get_allocator());
996*ee754c2dSkamil }
997*ee754c2dSkamil
PointsIntoChunk(void * p)998*ee754c2dSkamil uptr PointsIntoChunk(void* p) {
999*ee754c2dSkamil uptr addr = reinterpret_cast<uptr>(p);
1000*ee754c2dSkamil __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(addr);
1001*ee754c2dSkamil if (!m) return 0;
1002*ee754c2dSkamil uptr chunk = m->Beg();
1003*ee754c2dSkamil if (m->chunk_state != __asan::CHUNK_ALLOCATED)
1004*ee754c2dSkamil return 0;
1005*ee754c2dSkamil if (m->AddrIsInside(addr, /*locked_version=*/true))
1006*ee754c2dSkamil return chunk;
1007*ee754c2dSkamil if (IsSpecialCaseOfOperatorNew0(chunk, m->UsedSize(/*locked_version*/ true),
1008*ee754c2dSkamil addr))
1009*ee754c2dSkamil return chunk;
1010*ee754c2dSkamil return 0;
1011*ee754c2dSkamil }
1012*ee754c2dSkamil
GetUserBegin(uptr chunk)1013*ee754c2dSkamil uptr GetUserBegin(uptr chunk) {
1014*ee754c2dSkamil __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddrFastLocked(chunk);
1015*ee754c2dSkamil CHECK(m);
1016*ee754c2dSkamil return m->Beg();
1017*ee754c2dSkamil }
1018*ee754c2dSkamil
LsanMetadata(uptr chunk)1019*ee754c2dSkamil LsanMetadata::LsanMetadata(uptr chunk) {
1020*ee754c2dSkamil metadata_ = reinterpret_cast<void *>(chunk - __asan::kChunkHeaderSize);
1021*ee754c2dSkamil }
1022*ee754c2dSkamil
allocated() const1023*ee754c2dSkamil bool LsanMetadata::allocated() const {
1024*ee754c2dSkamil __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
1025*ee754c2dSkamil return m->chunk_state == __asan::CHUNK_ALLOCATED;
1026*ee754c2dSkamil }
1027*ee754c2dSkamil
tag() const1028*ee754c2dSkamil ChunkTag LsanMetadata::tag() const {
1029*ee754c2dSkamil __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
1030*ee754c2dSkamil return static_cast<ChunkTag>(m->lsan_tag);
1031*ee754c2dSkamil }
1032*ee754c2dSkamil
set_tag(ChunkTag value)1033*ee754c2dSkamil void LsanMetadata::set_tag(ChunkTag value) {
1034*ee754c2dSkamil __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
1035*ee754c2dSkamil m->lsan_tag = value;
1036*ee754c2dSkamil }
1037*ee754c2dSkamil
requested_size() const1038*ee754c2dSkamil uptr LsanMetadata::requested_size() const {
1039*ee754c2dSkamil __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
1040*ee754c2dSkamil return m->UsedSize(/*locked_version=*/true);
1041*ee754c2dSkamil }
1042*ee754c2dSkamil
stack_trace_id() const1043*ee754c2dSkamil u32 LsanMetadata::stack_trace_id() const {
1044*ee754c2dSkamil __asan::AsanChunk *m = reinterpret_cast<__asan::AsanChunk *>(metadata_);
1045*ee754c2dSkamil return m->alloc_context_id;
1046*ee754c2dSkamil }
1047*ee754c2dSkamil
ForEachChunk(ForEachChunkCallback callback,void * arg)1048*ee754c2dSkamil void ForEachChunk(ForEachChunkCallback callback, void *arg) {
1049*ee754c2dSkamil __asan::get_allocator().ForEachChunk(callback, arg);
1050*ee754c2dSkamil }
1051*ee754c2dSkamil
IgnoreObjectLocked(const void * p)1052*ee754c2dSkamil IgnoreObjectResult IgnoreObjectLocked(const void *p) {
1053*ee754c2dSkamil uptr addr = reinterpret_cast<uptr>(p);
1054*ee754c2dSkamil __asan::AsanChunk *m = __asan::instance.GetAsanChunkByAddr(addr);
1055*ee754c2dSkamil if (!m) return kIgnoreObjectInvalid;
1056*ee754c2dSkamil if ((m->chunk_state == __asan::CHUNK_ALLOCATED) && m->AddrIsInside(addr)) {
1057*ee754c2dSkamil if (m->lsan_tag == kIgnored)
1058*ee754c2dSkamil return kIgnoreObjectAlreadyIgnored;
1059*ee754c2dSkamil m->lsan_tag = __lsan::kIgnored;
1060*ee754c2dSkamil return kIgnoreObjectSuccess;
1061*ee754c2dSkamil } else {
1062*ee754c2dSkamil return kIgnoreObjectInvalid;
1063*ee754c2dSkamil }
1064*ee754c2dSkamil }
1065*ee754c2dSkamil } // namespace __lsan
1066*ee754c2dSkamil
1067*ee754c2dSkamil // ---------------------- Interface ---------------- {{{1
1068*ee754c2dSkamil using namespace __asan; // NOLINT
1069*ee754c2dSkamil
1070*ee754c2dSkamil // ASan allocator doesn't reserve extra bytes, so normally we would
1071*ee754c2dSkamil // just return "size". We don't want to expose our redzone sizes, etc here.
__sanitizer_get_estimated_allocated_size(uptr size)1072*ee754c2dSkamil uptr __sanitizer_get_estimated_allocated_size(uptr size) {
1073*ee754c2dSkamil return size;
1074*ee754c2dSkamil }
1075*ee754c2dSkamil
__sanitizer_get_ownership(const void * p)1076*ee754c2dSkamil int __sanitizer_get_ownership(const void *p) {
1077*ee754c2dSkamil uptr ptr = reinterpret_cast<uptr>(p);
1078*ee754c2dSkamil return instance.AllocationSize(ptr) > 0;
1079*ee754c2dSkamil }
1080*ee754c2dSkamil
__sanitizer_get_allocated_size(const void * p)1081*ee754c2dSkamil uptr __sanitizer_get_allocated_size(const void *p) {
1082*ee754c2dSkamil if (!p) return 0;
1083*ee754c2dSkamil uptr ptr = reinterpret_cast<uptr>(p);
1084*ee754c2dSkamil uptr allocated_size = instance.AllocationSize(ptr);
1085*ee754c2dSkamil // Die if p is not malloced or if it is already freed.
1086*ee754c2dSkamil if (allocated_size == 0) {
1087*ee754c2dSkamil GET_STACK_TRACE_FATAL_HERE;
1088*ee754c2dSkamil ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
1089*ee754c2dSkamil }
1090*ee754c2dSkamil return allocated_size;
1091*ee754c2dSkamil }
1092*ee754c2dSkamil
__sanitizer_purge_allocator()1093*ee754c2dSkamil void __sanitizer_purge_allocator() {
1094*ee754c2dSkamil GET_STACK_TRACE_MALLOC;
1095*ee754c2dSkamil instance.Purge(&stack);
1096*ee754c2dSkamil }
1097*ee754c2dSkamil
1098*ee754c2dSkamil #if !SANITIZER_SUPPORTS_WEAK_HOOKS
1099*ee754c2dSkamil // Provide default (no-op) implementation of malloc hooks.
SANITIZER_INTERFACE_WEAK_DEF(void,__sanitizer_malloc_hook,void * ptr,uptr size)1100*ee754c2dSkamil SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_malloc_hook,
1101*ee754c2dSkamil void *ptr, uptr size) {
1102*ee754c2dSkamil (void)ptr;
1103*ee754c2dSkamil (void)size;
1104*ee754c2dSkamil }
1105*ee754c2dSkamil
SANITIZER_INTERFACE_WEAK_DEF(void,__sanitizer_free_hook,void * ptr)1106*ee754c2dSkamil SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_free_hook, void *ptr) {
1107*ee754c2dSkamil (void)ptr;
1108*ee754c2dSkamil }
1109*ee754c2dSkamil #endif
1110