1//===-- allocator_config.def ------------------------------------*- C++ -*-===// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8// 9// This file defines all the flags and types supported in Scudo. For optional 10// flags and types, only explicitly define them when interested (i.e., unused 11// optional flags or types can be skipped). 12 13#ifndef BASE_REQUIRED_TEMPLATE_TYPE 14#define BASE_REQUIRED_TEMPLATE_TYPE(...) 15#endif 16#ifndef BASE_OPTIONAL 17#define BASE_OPTIONAL(...) 18#endif 19#ifndef PRIMARY_REQUIRED_TYPE 20#define PRIMARY_REQUIRED_TYPE(...) 21#endif 22#ifndef PRIMARY_REQUIRED 23#define PRIMARY_REQUIRED(...) 24#endif 25#ifndef PRIMARY_OPTIONAL 26#define PRIMARY_OPTIONAL(...) 27#endif 28#ifndef PRIMARY_OPTIONAL_TYPE 29#define PRIMARY_OPTIONAL_TYPE(...) 30#endif 31#ifndef SECONDARY_REQUIRED_TEMPLATE_TYPE 32#define SECONDARY_REQUIRED_TEMPLATE_TYPE(...) 33#endif 34#ifndef SECONDARY_OPTIONAL 35#define SECONDARY_OPTIONAL(...) 36#endif 37#ifndef SECONDARY_CACHE_OPTIONAL 38#define SECONDARY_CACHE_OPTIONAL(...) 39#endif 40 41// BASE_REQUIRED_TEMPLATE_TYPE(NAME) 42// 43// Thread-Specific Data Registry used, shared or exclusive. 44BASE_REQUIRED_TEMPLATE_TYPE(TSDRegistryT) 45 46// Defines the type of Primary allocator to use. 47BASE_REQUIRED_TEMPLATE_TYPE(PrimaryT) 48 49// Defines the type of Secondary allocator to use. 50BASE_REQUIRED_TEMPLATE_TYPE(SecondaryT) 51 52// BASE_OPTIONAL(TYPE, NAME, DEFAULT) 53// 54// Indicates possible support for Memory Tagging. 55BASE_OPTIONAL(const bool, MaySupportMemoryTagging, false) 56 57// PRIMARY_REQUIRED_TYPE(NAME) 58// 59// SizeClassMap to use with the Primary. 60PRIMARY_REQUIRED_TYPE(SizeClassMap) 61 62// PRIMARY_REQUIRED(TYPE, NAME) 63// 64// Log2 of the size of a size class region, as used by the Primary. 65PRIMARY_REQUIRED(const uptr, RegionSizeLog) 66 67// Conceptually, a region will be divided into groups based on the address 68// range. Each allocation consumes blocks in the same group until exhaustion 69// then it pops out blocks in a new group. Therefore, `GroupSizeLog` is always 70// smaller or equal to `RegionSizeLog`. Note that `GroupSizeLog` needs to be 71// equal to `RegionSizeLog` for SizeClassAllocator32 because of certain 72// constraints. 73PRIMARY_REQUIRED(const uptr, GroupSizeLog) 74 75// Call map for user memory with at least this size. Only used with primary64. 76PRIMARY_REQUIRED(const uptr, MapSizeIncrement) 77 78// Defines the minimal & maximal release interval that can be set. 79PRIMARY_REQUIRED(const s32, MinReleaseToOsIntervalMs) 80PRIMARY_REQUIRED(const s32, MaxReleaseToOsIntervalMs) 81 82// PRIMARY_OPTIONAL(TYPE, NAME, DEFAULT) 83// 84 85// Enables/disables primary block caching. Batch class still caches. 86PRIMARY_OPTIONAL(const bool, EnableBlockCache, true) 87 88// The scale of a compact pointer. E.g., Ptr = Base + (CompactPtr << Scale). 89PRIMARY_OPTIONAL(const uptr, CompactPtrScale, SCUDO_MIN_ALIGNMENT_LOG) 90 91// Indicates support for offsetting the start of a region by a random number of 92// pages. This is only used if `EnableContiguousRegions` is enabled. 93PRIMARY_OPTIONAL(const bool, EnableRandomOffset, false) 94PRIMARY_OPTIONAL(const s32, DefaultReleaseToOsIntervalMs, INT32_MIN) 95 96// When `EnableContiguousRegions` is true, all regions will be be arranged in 97// adjacency. This will reduce the fragmentation caused by region allocations 98// but may require a huge amount of contiguous pages at initialization. 99PRIMARY_OPTIONAL(const bool, EnableContiguousRegions, true) 100 101// PRIMARY_OPTIONAL_TYPE(NAME, DEFAULT) 102// 103// Use condition variable to shorten the waiting time of refillment of 104// freelist. Note that this depends on the implementation of condition 105// variable on each platform and the performance may vary so that it does not 106// guarantee a performance benefit. 107PRIMARY_OPTIONAL_TYPE(ConditionVariableT, ConditionVariableDummy) 108 109// Defines the type and scale of a compact pointer. A compact pointer can 110// be understood as the offset of a pointer within the region it belongs 111// to, in increments of a power-of-2 scale. See `CompactPtrScale` also. 112PRIMARY_OPTIONAL_TYPE(CompactPtrT, uptr) 113 114// SECONDARY_REQUIRED_TEMPLATE_TYPE(NAME) 115// 116// Defines the type of Secondary Cache to use. 117SECONDARY_REQUIRED_TEMPLATE_TYPE(CacheT) 118 119// SECONDARY_OPTIONAL(TYPE, NAME, DEFAULT) 120// 121// Add one guard page at the front and back for each allocation. 122SECONDARY_OPTIONAL(const bool, EnableGuardPages, true) 123 124// SECONDARY_CACHE_OPTIONAL(TYPE, NAME, DEFAULT) 125// 126// Defines the type of cache used by the Secondary. Some additional 127// configuration entries can be necessary depending on the Cache. 128SECONDARY_CACHE_OPTIONAL(const u32, EntriesArraySize, 0) 129SECONDARY_CACHE_OPTIONAL(const u32, QuarantineSize, 0) 130SECONDARY_CACHE_OPTIONAL(const u32, DefaultMaxEntriesCount, 0) 131SECONDARY_CACHE_OPTIONAL(const uptr, DefaultMaxEntrySize, 0) 132SECONDARY_CACHE_OPTIONAL(const s32, MinReleaseToOsIntervalMs, INT32_MIN) 133SECONDARY_CACHE_OPTIONAL(const s32, MaxReleaseToOsIntervalMs, INT32_MAX) 134SECONDARY_CACHE_OPTIONAL(const s32, DefaultReleaseToOsIntervalMs, INT32_MIN) 135 136#undef SECONDARY_CACHE_OPTIONAL 137#undef SECONDARY_OPTIONAL 138#undef SECONDARY_REQUIRED_TEMPLATE_TYPE 139#undef PRIMARY_OPTIONAL_TYPE 140#undef PRIMARY_OPTIONAL 141#undef PRIMARY_REQUIRED 142#undef PRIMARY_REQUIRED_TYPE 143#undef BASE_OPTIONAL 144#undef BASE_REQUIRED_TEMPLATE_TYPE 145