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