compiler-rt/lib/scudo/standalone/allocator_config.h

   1 //===-- allocator_config.h --------------------------------------*- 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 #ifndef SCUDO_ALLOCATOR_CONFIG_H_
  10 #define SCUDO_ALLOCATOR_CONFIG_H_
  11
  12 #include "combined.h"
  13 #include "common.h"
  14 #include "condition_variable.h"
  15 #include "flags.h"
  16 #include "primary32.h"
  17 #include "primary64.h"
  18 #include "secondary.h"
  19 #include "size_class_map.h"
  20 #include "tsd_exclusive.h"
  21 #include "tsd_shared.h"
  22
  23 // To import a custom configuration, define `SCUDO_USE_CUSTOM_CONFIG` and
  24 // aliasing the `Config` like:
  25 //
  26 // namespace scudo {
  27 //   // The instance of Scudo will be initiated with `Config`.
  28 //   typedef CustomConfig Config;
  29 //   // Aliasing as default configuration to run the tests with this config.
  30 //   typedef CustomConfig DefaultConfig;
  31 // } // namespace scudo
  32 //
  33 // Put them in the header `custom_scudo_config.h` then you will be using the
  34 // custom configuration and able to run all the tests as well.
  35 #ifdef SCUDO_USE_CUSTOM_CONFIG
  36 #include "custom_scudo_config.h"
  37 #endif
  38
  39 namespace scudo {
  40
  41 // Scudo uses a structure as a template argument that specifies the
  42 // configuration options for the various subcomponents of the allocator. See the
  43 // following configs as examples and check `allocator_config.def` for all the
  44 // available options.
  45
  46 #ifndef SCUDO_USE_CUSTOM_CONFIG
  47
  48 // Default configurations for various platforms. Note this is only enabled when
  49 // there's no custom configuration in the build system.
  50 struct DefaultConfig {
  51   static const bool MaySupportMemoryTagging = true;
  52   template <class A> using TSDRegistryT = TSDRegistryExT<A>; // Exclusive
  53
  54   struct Primary {
  55     using SizeClassMap = DefaultSizeClassMap;
  56 #if SCUDO_CAN_USE_PRIMARY64
  57     static const uptr RegionSizeLog = 32U;
  58     static const uptr GroupSizeLog = 21U;
  59     typedef uptr CompactPtrT;
  60     static const uptr CompactPtrScale = 0;
  61     static const bool EnableRandomOffset = true;
  62     static const uptr MapSizeIncrement = 1UL << 18;
  63 #else
  64     static const uptr RegionSizeLog = 19U;
  65     static const uptr GroupSizeLog = 19U;
  66     typedef uptr CompactPtrT;
  67 #endif
  68     static const s32 MinReleaseToOsIntervalMs = INT32_MIN;
  69     static const s32 MaxReleaseToOsIntervalMs = INT32_MAX;
  70   };
  71 #if SCUDO_CAN_USE_PRIMARY64
  72   template <typename Config> using PrimaryT = SizeClassAllocator64<Config>;
  73 #else
  74   template <typename Config> using PrimaryT = SizeClassAllocator32<Config>;
  75 #endif
  76
  77   struct Secondary {
  78     struct Cache {
  79       static const u32 EntriesArraySize = 32U;
  80       static const u32 QuarantineSize = 0U;
  81       static const u32 DefaultMaxEntriesCount = 32U;
  82       static const uptr DefaultMaxEntrySize = 1UL << 19;
  83       static const s32 MinReleaseToOsIntervalMs = INT32_MIN;
  84       static const s32 MaxReleaseToOsIntervalMs = INT32_MAX;
  85     };
  86     template <typename Config> using CacheT = MapAllocatorCache<Config>;
  87   };
  88
  89   template <typename Config> using SecondaryT = MapAllocator<Config>;
  90 };
  91
  92 #endif // SCUDO_USE_CUSTOM_CONFIG
  93
  94 struct AndroidConfig {
  95   static const bool MaySupportMemoryTagging = true;
  96   template <class A>
  97   using TSDRegistryT = TSDRegistrySharedT<A, 8U, 2U>; // Shared, max 8 TSDs.
  98
  99   struct Primary {
 100     using SizeClassMap = AndroidSizeClassMap;
 101 #if SCUDO_CAN_USE_PRIMARY64
 102     static const uptr RegionSizeLog = 28U;
 103     typedef u32 CompactPtrT;
 104     static const uptr CompactPtrScale = SCUDO_MIN_ALIGNMENT_LOG;
 105     static const uptr GroupSizeLog = 20U;
 106     static const bool EnableRandomOffset = true;
 107     static const uptr MapSizeIncrement = 1UL << 18;
 108 #else
 109     static const uptr RegionSizeLog = 18U;
 110     static const uptr GroupSizeLog = 18U;
 111     typedef uptr CompactPtrT;
 112 #endif
 113     static const s32 MinReleaseToOsIntervalMs = 1000;
 114     static const s32 MaxReleaseToOsIntervalMs = 1000;
 115   };
 116 #if SCUDO_CAN_USE_PRIMARY64
 117   template <typename Config> using PrimaryT = SizeClassAllocator64<Config>;
 118 #else
 119   template <typename Config> using PrimaryT = SizeClassAllocator32<Config>;
 120 #endif
 121
 122   struct Secondary {
 123     struct Cache {
 124       static const u32 EntriesArraySize = 256U;
 125       static const u32 QuarantineSize = 32U;
 126       static const u32 DefaultMaxEntriesCount = 32U;
 127       static const uptr DefaultMaxEntrySize = 2UL << 20;
 128       static const s32 MinReleaseToOsIntervalMs = 0;
 129       static const s32 MaxReleaseToOsIntervalMs = 1000;
 130     };
 131     template <typename Config> using CacheT = MapAllocatorCache<Config>;
 132   };
 133
 134   template <typename Config> using SecondaryT = MapAllocator<Config>;
 135 };
 136
 137 #if SCUDO_CAN_USE_PRIMARY64
 138 struct FuchsiaConfig {
 139   static const bool MaySupportMemoryTagging = false;
 140   template <class A>
 141   using TSDRegistryT = TSDRegistrySharedT<A, 8U, 4U>; // Shared, max 8 TSDs.
 142
 143   struct Primary {
 144     using SizeClassMap = FuchsiaSizeClassMap;
 145 #if SCUDO_RISCV64
 146     // Support 39-bit VMA for riscv-64
 147     static const uptr RegionSizeLog = 28U;
 148     static const uptr GroupSizeLog = 19U;
 149     static const bool EnableContiguousRegions = false;
 150 #else
 151     static const uptr RegionSizeLog = 30U;
 152     static const uptr GroupSizeLog = 21U;
 153 #endif
 154     typedef u32 CompactPtrT;
 155     static const bool EnableRandomOffset = true;
 156     static const uptr MapSizeIncrement = 1UL << 18;
 157     static const uptr CompactPtrScale = SCUDO_MIN_ALIGNMENT_LOG;
 158     static const s32 MinReleaseToOsIntervalMs = INT32_MIN;
 159     static const s32 MaxReleaseToOsIntervalMs = INT32_MAX;
 160   };
 161   template <typename Config> using PrimaryT = SizeClassAllocator64<Config>;
 162
 163   struct Secondary {
 164     template <typename Config> using CacheT = MapAllocatorNoCache<Config>;
 165   };
 166   template <typename Config> using SecondaryT = MapAllocator<Config>;
 167 };
 168
 169 struct TrustyConfig {
 170   static const bool MaySupportMemoryTagging = true;
 171   template <class A>
 172   using TSDRegistryT = TSDRegistrySharedT<A, 1U, 1U>; // Shared, max 1 TSD.
 173
 174   struct Primary {
 175     using SizeClassMap = TrustySizeClassMap;
 176     static const uptr RegionSizeLog = 28U;
 177     static const uptr GroupSizeLog = 20U;
 178     typedef u32 CompactPtrT;
 179     static const bool EnableRandomOffset = false;
 180     static const uptr MapSizeIncrement = 1UL << 12;
 181     static const uptr CompactPtrScale = SCUDO_MIN_ALIGNMENT_LOG;
 182     static const s32 MinReleaseToOsIntervalMs = INT32_MIN;
 183     static const s32 MaxReleaseToOsIntervalMs = INT32_MAX;
 184   };
 185   template <typename Config> using PrimaryT = SizeClassAllocator64<Config>;
 186
 187   struct Secondary {
 188     template <typename Config> using CacheT = MapAllocatorNoCache<Config>;
 189   };
 190
 191   template <typename Config> using SecondaryT = MapAllocator<Config>;
 192 };
 193 #endif
 194
 195 #ifndef SCUDO_USE_CUSTOM_CONFIG
 196
 197 #if SCUDO_ANDROID
 198 typedef AndroidConfig Config;
 199 #elif SCUDO_FUCHSIA
 200 typedef FuchsiaConfig Config;
 201 #elif SCUDO_TRUSTY
 202 typedef TrustyConfig Config;
 203 #else
 204 typedef DefaultConfig Config;
 205 #endif
 206
 207 #endif // SCUDO_USE_CUSTOM_CONFIG
 208
 209 } // namespace scudo
 210
 211 #endif // SCUDO_ALLOCATOR_CONFIG_H_