1//=-- lsan_allocator.h ----------------------------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file is a part of LeakSanitizer. 11// Allocator for standalone LSan. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LSAN_ALLOCATOR_H 16#define LSAN_ALLOCATOR_H 17 18#include "sanitizer_common/sanitizer_allocator.h" 19#include "sanitizer_common/sanitizer_common.h" 20#include "sanitizer_common/sanitizer_internal_defs.h" 21#include "lsan_common.h" 22 23namespace __lsan { 24 25void *Allocate(const StackTrace &stack, uptr size, uptr alignment, 26 bool cleared); 27void Deallocate(void *p); 28void *Reallocate(const StackTrace &stack, void *p, uptr new_size, 29 uptr alignment); 30uptr GetMallocUsableSize(const void *p); 31 32template<typename Callable> 33void ForEachChunk(const Callable &callback); 34 35void GetAllocatorCacheRange(uptr *begin, uptr *end); 36void AllocatorThreadFinish(); 37void InitializeAllocator(); 38 39const bool kAlwaysClearMemory = true; 40 41struct ChunkMetadata { 42 u8 allocated : 8; // Must be first. 43 ChunkTag tag : 2; 44#if SANITIZER_WORDSIZE == 64 45 uptr requested_size : 54; 46#else 47 uptr requested_size : 32; 48 uptr padding : 22; 49#endif 50 u32 stack_trace_id; 51}; 52 53#if defined(__mips64) || defined(__aarch64__) || defined(__i386__) || \ 54 defined(__arm__) 55static const uptr kRegionSizeLog = 20; 56static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog; 57template <typename AddressSpaceView> 58using ByteMapASVT = 59 TwoLevelByteMap<(kNumRegions >> 12), 1 << 12, AddressSpaceView>; 60 61template <typename AddressSpaceViewTy> 62struct AP32 { 63 static const uptr kSpaceBeg = 0; 64 static const u64 kSpaceSize = SANITIZER_MMAP_RANGE_SIZE; 65 static const uptr kMetadataSize = sizeof(ChunkMetadata); 66 typedef __sanitizer::CompactSizeClassMap SizeClassMap; 67 static const uptr kRegionSizeLog = __lsan::kRegionSizeLog; 68 using AddressSpaceView = AddressSpaceViewTy; 69 using ByteMap = __lsan::ByteMapASVT<AddressSpaceView>; 70 typedef NoOpMapUnmapCallback MapUnmapCallback; 71 static const uptr kFlags = 0; 72}; 73template <typename AddressSpaceView> 74using PrimaryAllocatorASVT = SizeClassAllocator32<AP32<AddressSpaceView>>; 75using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>; 76#elif defined(__x86_64__) || defined(__powerpc64__) 77# if defined(__powerpc64__) 78const uptr kAllocatorSpace = 0xa0000000000ULL; 79const uptr kAllocatorSize = 0x20000000000ULL; // 2T. 80# else 81const uptr kAllocatorSpace = 0x600000000000ULL; 82const uptr kAllocatorSize = 0x40000000000ULL; // 4T. 83# endif 84template <typename AddressSpaceViewTy> 85struct AP64 { // Allocator64 parameters. Deliberately using a short name. 86 static const uptr kSpaceBeg = kAllocatorSpace; 87 static const uptr kSpaceSize = kAllocatorSize; 88 static const uptr kMetadataSize = sizeof(ChunkMetadata); 89 typedef DefaultSizeClassMap SizeClassMap; 90 typedef NoOpMapUnmapCallback MapUnmapCallback; 91 static const uptr kFlags = 0; 92 using AddressSpaceView = AddressSpaceViewTy; 93}; 94 95template <typename AddressSpaceView> 96using PrimaryAllocatorASVT = SizeClassAllocator64<AP64<AddressSpaceView>>; 97using PrimaryAllocator = PrimaryAllocatorASVT<LocalAddressSpaceView>; 98#endif 99 100template <typename AddressSpaceView> 101using AllocatorCacheASVT = 102 SizeClassAllocatorLocalCache<PrimaryAllocatorASVT<AddressSpaceView>>; 103using AllocatorCache = AllocatorCacheASVT<LocalAddressSpaceView>; 104 105template <typename AddressSpaceView> 106using SecondaryAllocatorASVT = 107 LargeMmapAllocator<NoOpMapUnmapCallback, DefaultLargeMmapAllocatorPtrArray, 108 AddressSpaceView>; 109 110template <typename AddressSpaceView> 111using AllocatorASVT = 112 CombinedAllocator<PrimaryAllocatorASVT<AddressSpaceView>, 113 AllocatorCacheASVT<AddressSpaceView>, 114 SecondaryAllocatorASVT<AddressSpaceView>>; 115using Allocator = AllocatorASVT<LocalAddressSpaceView>; 116 117AllocatorCache *GetAllocatorCache(); 118 119int lsan_posix_memalign(void **memptr, uptr alignment, uptr size, 120 const StackTrace &stack); 121void *lsan_aligned_alloc(uptr alignment, uptr size, const StackTrace &stack); 122void *lsan_memalign(uptr alignment, uptr size, const StackTrace &stack); 123void *lsan_malloc(uptr size, const StackTrace &stack); 124void lsan_free(void *p); 125void *lsan_realloc(void *p, uptr size, const StackTrace &stack); 126void *lsan_calloc(uptr nmemb, uptr size, const StackTrace &stack); 127void *lsan_valloc(uptr size, const StackTrace &stack); 128void *lsan_pvalloc(uptr size, const StackTrace &stack); 129uptr lsan_mz_size(const void *p); 130 131} // namespace __lsan 132 133#endif // LSAN_ALLOCATOR_H 134