| // Copyright 2020 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/allocator/partition_alloc_features.h" |
| |
| #include "base/allocator/miracle_parameter.h" |
| #include "base/allocator/partition_allocator/src/partition_alloc/partition_alloc_base/time/time.h" |
| #include "base/allocator/partition_allocator/src/partition_alloc/partition_alloc_buildflags.h" |
| #include "base/allocator/partition_allocator/src/partition_alloc/partition_root.h" |
| #include "base/allocator/partition_allocator/src/partition_alloc/shim/allocator_shim_dispatch_to_noop_on_free.h" |
| #include "base/allocator/partition_allocator/src/partition_alloc/thread_cache.h" |
| #include "base/base_export.h" |
| #include "base/feature_list.h" |
| #include "base/features.h" |
| #include "base/metrics/field_trial_params.h" |
| #include "base/time/time.h" |
| #include "build/build_config.h" |
| #include "build/chromecast_buildflags.h" |
| #include "build/chromeos_buildflags.h" |
| |
| namespace base { |
| namespace features { |
| |
| BASE_FEATURE(kPartitionAllocUnretainedDanglingPtr, |
| "PartitionAllocUnretainedDanglingPtr", |
| FEATURE_ENABLED_BY_DEFAULT); |
| |
| constexpr FeatureParam<UnretainedDanglingPtrMode>::Option |
| kUnretainedDanglingPtrModeOption[] = { |
| {UnretainedDanglingPtrMode::kCrash, "crash"}, |
| {UnretainedDanglingPtrMode::kDumpWithoutCrashing, |
| "dump_without_crashing"}, |
| }; |
| const base::FeatureParam<UnretainedDanglingPtrMode> |
| kUnretainedDanglingPtrModeParam = { |
| &kPartitionAllocUnretainedDanglingPtr, |
| "mode", |
| UnretainedDanglingPtrMode::kDumpWithoutCrashing, |
| &kUnretainedDanglingPtrModeOption, |
| }; |
| |
| BASE_FEATURE(kPartitionAllocDanglingPtr, |
| "PartitionAllocDanglingPtr", |
| #if BUILDFLAG(ENABLE_DANGLING_RAW_PTR_FEATURE_FLAG) || \ |
| (BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) && BUILDFLAG(IS_LINUX) && \ |
| !defined(OFFICIAL_BUILD) && (!defined(NDEBUG) || DCHECK_IS_ON())) |
| FEATURE_ENABLED_BY_DEFAULT |
| #else |
| FEATURE_DISABLED_BY_DEFAULT |
| #endif |
| ); |
| |
| constexpr FeatureParam<DanglingPtrMode>::Option kDanglingPtrModeOption[] = { |
| {DanglingPtrMode::kCrash, "crash"}, |
| {DanglingPtrMode::kLogOnly, "log_only"}, |
| }; |
| const base::FeatureParam<DanglingPtrMode> kDanglingPtrModeParam{ |
| &kPartitionAllocDanglingPtr, |
| "mode", |
| DanglingPtrMode::kCrash, |
| &kDanglingPtrModeOption, |
| }; |
| constexpr FeatureParam<DanglingPtrType>::Option kDanglingPtrTypeOption[] = { |
| {DanglingPtrType::kAll, "all"}, |
| {DanglingPtrType::kCrossTask, "cross_task"}, |
| }; |
| const base::FeatureParam<DanglingPtrType> kDanglingPtrTypeParam{ |
| &kPartitionAllocDanglingPtr, |
| "type", |
| DanglingPtrType::kAll, |
| &kDanglingPtrTypeOption, |
| }; |
| |
| #if BUILDFLAG(USE_STARSCAN) |
| // If enabled, PCScan is turned on by default for all partitions that don't |
| // disable it explicitly. |
| BASE_FEATURE(kPartitionAllocPCScan, |
| "PartitionAllocPCScan", |
| FEATURE_DISABLED_BY_DEFAULT); |
| #endif // BUILDFLAG(USE_STARSCAN) |
| |
| #if BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC) |
| // If enabled, PCScan is turned on only for the browser's malloc partition. |
| BASE_FEATURE(kPartitionAllocPCScanBrowserOnly, |
| "PartitionAllocPCScanBrowserOnly", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // If enabled, PCScan is turned on only for the renderer's malloc partition. |
| BASE_FEATURE(kPartitionAllocPCScanRendererOnly, |
| "PartitionAllocPCScanRendererOnly", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // Use a larger maximum thread cache cacheable bucket size. |
| BASE_FEATURE(kPartitionAllocLargeThreadCacheSize, |
| "PartitionAllocLargeThreadCacheSize", |
| FEATURE_ENABLED_BY_DEFAULT); |
| |
| MIRACLE_PARAMETER_FOR_INT( |
| GetPartitionAllocLargeThreadCacheSizeValue, |
| kPartitionAllocLargeThreadCacheSize, |
| "PartitionAllocLargeThreadCacheSizeValue", |
| ::partition_alloc::ThreadCacheLimits::kLargeSizeThreshold) |
| |
| MIRACLE_PARAMETER_FOR_INT( |
| GetPartitionAllocLargeThreadCacheSizeValueForLowRAMAndroid, |
| kPartitionAllocLargeThreadCacheSize, |
| "PartitionAllocLargeThreadCacheSizeValueForLowRAMAndroid", |
| ::partition_alloc::ThreadCacheLimits::kDefaultSizeThreshold) |
| |
| BASE_FEATURE(kPartitionAllocLargeEmptySlotSpanRing, |
| "PartitionAllocLargeEmptySlotSpanRing", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| BASE_FEATURE(kPartitionAllocSchedulerLoopQuarantine, |
| "PartitionAllocSchedulerLoopQuarantine", |
| FEATURE_DISABLED_BY_DEFAULT); |
| // Scheduler Loop Quarantine's capacity in bytes. |
| const base::FeatureParam<int> kPartitionAllocSchedulerLoopQuarantineCapacity{ |
| &kPartitionAllocSchedulerLoopQuarantine, |
| "PartitionAllocSchedulerLoopQuarantineCapacity", 0}; |
| |
| BASE_FEATURE(kPartitionAllocZappingByFreeFlags, |
| "PartitionAllocZappingByFreeFlags", |
| FEATURE_DISABLED_BY_DEFAULT); |
| #endif // BUILDFLAG(USE_PARTITION_ALLOC_AS_MALLOC) |
| |
| BASE_FEATURE(kPartitionAllocBackupRefPtr, |
| "PartitionAllocBackupRefPtr", |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC) || \ |
| BUILDFLAG(IS_CHROMEOS_ASH) || BUILDFLAG(IS_CHROMEOS_LACROS) || \ |
| (BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_CASTOS)) || \ |
| BUILDFLAG(ENABLE_BACKUP_REF_PTR_FEATURE_FLAG) |
| FEATURE_ENABLED_BY_DEFAULT |
| #else |
| FEATURE_DISABLED_BY_DEFAULT |
| #endif |
| ); |
| |
| constexpr FeatureParam<BackupRefPtrEnabledProcesses>::Option |
| kBackupRefPtrEnabledProcessesOptions[] = { |
| {BackupRefPtrEnabledProcesses::kBrowserOnly, "browser-only"}, |
| {BackupRefPtrEnabledProcesses::kBrowserAndRenderer, |
| "browser-and-renderer"}, |
| {BackupRefPtrEnabledProcesses::kNonRenderer, "non-renderer"}, |
| {BackupRefPtrEnabledProcesses::kAllProcesses, "all-processes"}}; |
| |
| const base::FeatureParam<BackupRefPtrEnabledProcesses> |
| kBackupRefPtrEnabledProcessesParam{ |
| &kPartitionAllocBackupRefPtr, "enabled-processes", |
| BackupRefPtrEnabledProcesses::kNonRenderer, |
| &kBackupRefPtrEnabledProcessesOptions}; |
| |
| // Map *-with-memory-reclaimer modes onto their counterpars without the suffix. |
| // They are the same, as memory reclaimer is now controlled independently. |
| // |
| // Similarly, map disabled-but-*-way-split onto plain disabled, as we are done |
| // experimenting with partition split. |
| // |
| // We need to keep those option strings, as there is a long tail of clients that |
| // may have an old field trial config, which used these modes. |
| // |
| // DO NOT USE *-with-memory-reclaimer and disabled-but-*-way-split modes in new |
| // configs! |
| constexpr FeatureParam<BackupRefPtrMode>::Option kBackupRefPtrModeOptions[] = { |
| {BackupRefPtrMode::kDisabled, "disabled"}, |
| {BackupRefPtrMode::kEnabled, "enabled"}, |
| {BackupRefPtrMode::kEnabled, "enabled-with-memory-reclaimer"}, |
| {BackupRefPtrMode::kEnabledInSameSlotMode, "enabled-in-same-slot-mode"}, |
| {BackupRefPtrMode::kDisabled, "disabled-but-2-way-split"}, |
| {BackupRefPtrMode::kDisabled, |
| "disabled-but-2-way-split-with-memory-reclaimer"}, |
| {BackupRefPtrMode::kDisabled, "disabled-but-3-way-split"}, |
| }; |
| |
| const base::FeatureParam<BackupRefPtrMode> kBackupRefPtrModeParam{ |
| &kPartitionAllocBackupRefPtr, "brp-mode", |
| BackupRefPtrMode::kEnabledInSameSlotMode, &kBackupRefPtrModeOptions}; |
| |
| BASE_FEATURE(kPartitionAllocMemoryTagging, |
| "PartitionAllocMemoryTagging", |
| #if BUILDFLAG(USE_FULL_MTE) |
| FEATURE_ENABLED_BY_DEFAULT |
| #else |
| FEATURE_DISABLED_BY_DEFAULT |
| #endif |
| ); |
| |
| constexpr FeatureParam<MemtagMode>::Option kMemtagModeOptions[] = { |
| {MemtagMode::kSync, "sync"}, |
| {MemtagMode::kAsync, "async"}}; |
| |
| const base::FeatureParam<MemtagMode> kMemtagModeParam{ |
| &kPartitionAllocMemoryTagging, "memtag-mode", |
| #if BUILDFLAG(USE_FULL_MTE) |
| MemtagMode::kSync, |
| #else |
| MemtagMode::kAsync, |
| #endif |
| &kMemtagModeOptions}; |
| |
| constexpr FeatureParam<MemoryTaggingEnabledProcesses>::Option |
| kMemoryTaggingEnabledProcessesOptions[] = { |
| {MemoryTaggingEnabledProcesses::kBrowserOnly, "browser-only"}, |
| {MemoryTaggingEnabledProcesses::kNonRenderer, "non-renderer"}, |
| {MemoryTaggingEnabledProcesses::kAllProcesses, "all-processes"}}; |
| |
| const base::FeatureParam<MemoryTaggingEnabledProcesses> |
| kMemoryTaggingEnabledProcessesParam{ |
| &kPartitionAllocMemoryTagging, "enabled-processes", |
| #if BUILDFLAG(USE_FULL_MTE) |
| MemoryTaggingEnabledProcesses::kAllProcesses, |
| #else |
| MemoryTaggingEnabledProcesses::kBrowserOnly, |
| #endif |
| &kMemoryTaggingEnabledProcessesOptions}; |
| |
| BASE_FEATURE(kKillPartitionAllocMemoryTagging, |
| "KillPartitionAllocMemoryTagging", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| BASE_EXPORT BASE_DECLARE_FEATURE(kPartitionAllocPermissiveMte); |
| BASE_FEATURE(kPartitionAllocPermissiveMte, |
| "PartitionAllocPermissiveMte", |
| #if BUILDFLAG(USE_FULL_MTE) |
| // We want to actually crash if USE_FULL_MTE is enabled. |
| FEATURE_DISABLED_BY_DEFAULT |
| #else |
| FEATURE_ENABLED_BY_DEFAULT |
| #endif |
| ); |
| |
| const base::FeatureParam<bool> kBackupRefPtrAsanEnableDereferenceCheckParam{ |
| &kPartitionAllocBackupRefPtr, "asan-enable-dereference-check", true}; |
| const base::FeatureParam<bool> kBackupRefPtrAsanEnableExtractionCheckParam{ |
| &kPartitionAllocBackupRefPtr, "asan-enable-extraction-check", |
| false}; // Not much noise at the moment to enable by default. |
| const base::FeatureParam<bool> kBackupRefPtrAsanEnableInstantiationCheckParam{ |
| &kPartitionAllocBackupRefPtr, "asan-enable-instantiation-check", true}; |
| |
| // If enabled, switches the bucket distribution to a denser one. |
| // |
| // We enable this by default everywhere except for 32-bit Android, since we saw |
| // regressions there. |
| BASE_FEATURE(kPartitionAllocUseDenserDistribution, |
| "PartitionAllocUseDenserDistribution", |
| #if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS) |
| FEATURE_DISABLED_BY_DEFAULT |
| #else |
| FEATURE_ENABLED_BY_DEFAULT |
| #endif // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS) |
| ); |
| const base::FeatureParam<BucketDistributionMode>::Option |
| kPartitionAllocBucketDistributionOption[] = { |
| {BucketDistributionMode::kDefault, "default"}, |
| {BucketDistributionMode::kDenser, "denser"}, |
| }; |
| const base::FeatureParam<BucketDistributionMode> |
| kPartitionAllocBucketDistributionParam { |
| &kPartitionAllocUseDenserDistribution, "mode", |
| #if BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS) |
| BucketDistributionMode::kDefault, |
| #else |
| BucketDistributionMode::kDenser, |
| #endif // BUILDFLAG(IS_ANDROID) && defined(ARCH_CPU_32_BITS) |
| &kPartitionAllocBucketDistributionOption |
| }; |
| |
| BASE_FEATURE(kPartitionAllocMemoryReclaimer, |
| "PartitionAllocMemoryReclaimer", |
| FEATURE_ENABLED_BY_DEFAULT); |
| const base::FeatureParam<TimeDelta> kPartitionAllocMemoryReclaimerInterval = { |
| &kPartitionAllocMemoryReclaimer, "interval", |
| TimeDelta(), // Defaults to zero. |
| }; |
| |
| // Configures whether we set a lower limit for renderers that do not have a main |
| // frame, similar to the limit that is already done for backgrounded renderers. |
| BASE_FEATURE(kLowerPAMemoryLimitForNonMainRenderers, |
| "LowerPAMemoryLimitForNonMainRenderers", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // If enabled, switches PCScan scheduling to a mutator-aware scheduler. Does not |
| // affect whether PCScan is enabled itself. |
| BASE_FEATURE(kPartitionAllocPCScanMUAwareScheduler, |
| "PartitionAllocPCScanMUAwareScheduler", |
| FEATURE_ENABLED_BY_DEFAULT); |
| |
| // If enabled, PCScan frees unconditionally all quarantined objects. |
| // This is a performance testing feature. |
| BASE_FEATURE(kPartitionAllocPCScanImmediateFreeing, |
| "PartitionAllocPCScanImmediateFreeing", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // If enabled, PCScan clears eagerly (synchronously) on free(). |
| BASE_FEATURE(kPartitionAllocPCScanEagerClearing, |
| "PartitionAllocPCScanEagerClearing", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // In addition to heap, scan also the stack of the current mutator. |
| BASE_FEATURE(kPartitionAllocPCScanStackScanning, |
| "PartitionAllocPCScanStackScanning", |
| #if BUILDFLAG(PCSCAN_STACK_SUPPORTED) |
| FEATURE_ENABLED_BY_DEFAULT |
| #else |
| FEATURE_DISABLED_BY_DEFAULT |
| #endif // BUILDFLAG(PCSCAN_STACK_SUPPORTED) |
| ); |
| |
| BASE_FEATURE(kPartitionAllocDCScan, |
| "PartitionAllocDCScan", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| // Whether to straighten free lists for larger slot spans in PurgeMemory() -> |
| // ... -> PartitionPurgeSlotSpan(). |
| BASE_FEATURE(kPartitionAllocStraightenLargerSlotSpanFreeLists, |
| "PartitionAllocStraightenLargerSlotSpanFreeLists", |
| FEATURE_ENABLED_BY_DEFAULT); |
| const base::FeatureParam< |
| partition_alloc::StraightenLargerSlotSpanFreeListsMode>::Option |
| kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption[] = { |
| {partition_alloc::StraightenLargerSlotSpanFreeListsMode:: |
| kOnlyWhenUnprovisioning, |
| "only-when-unprovisioning"}, |
| {partition_alloc::StraightenLargerSlotSpanFreeListsMode::kAlways, |
| "always"}, |
| }; |
| const base::FeatureParam<partition_alloc::StraightenLargerSlotSpanFreeListsMode> |
| kPartitionAllocStraightenLargerSlotSpanFreeListsMode = { |
| &kPartitionAllocStraightenLargerSlotSpanFreeLists, |
| "mode", |
| partition_alloc::StraightenLargerSlotSpanFreeListsMode:: |
| kOnlyWhenUnprovisioning, |
| &kPartitionAllocStraightenLargerSlotSpanFreeListsModeOption, |
| }; |
| |
| // Whether to sort free lists for smaller slot spans in PurgeMemory(). |
| BASE_FEATURE(kPartitionAllocSortSmallerSlotSpanFreeLists, |
| "PartitionAllocSortSmallerSlotSpanFreeLists", |
| FEATURE_ENABLED_BY_DEFAULT); |
| |
| // Whether to sort the active slot spans in PurgeMemory(). |
| BASE_FEATURE(kPartitionAllocSortActiveSlotSpans, |
| "PartitionAllocSortActiveSlotSpans", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| #if BUILDFLAG(IS_WIN) |
| // Whether to retry allocations when commit fails. |
| BASE_FEATURE(kPageAllocatorRetryOnCommitFailure, |
| "PageAllocatorRetryOnCommitFailure", |
| FEATURE_DISABLED_BY_DEFAULT); |
| #endif |
| |
| #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS) |
| // A parameter to exclude or not exclude PartitionAllocSupport from |
| // PartialLowModeOnMidRangeDevices. This is used to see how it affects |
| // renderer performances, e.g. blink_perf.parser benchmark. |
| // The feature: kPartialLowEndModeOnMidRangeDevices is defined in |
| // //base/features.cc. Since the following feature param is related to |
| // PartitionAlloc, define the param here. |
| const FeatureParam<bool> kPartialLowEndModeExcludePartitionAllocSupport{ |
| &kPartialLowEndModeOnMidRangeDevices, "exclude-partition-alloc-support", |
| false}; |
| #endif |
| |
| BASE_FEATURE(kEnableConfigurableThreadCacheMultiplier, |
| "EnableConfigurableThreadCacheMultiplier", |
| base::FEATURE_DISABLED_BY_DEFAULT); |
| |
| MIRACLE_PARAMETER_FOR_DOUBLE(GetThreadCacheMultiplier, |
| kEnableConfigurableThreadCacheMultiplier, |
| "ThreadCacheMultiplier", |
| 2.) |
| |
| MIRACLE_PARAMETER_FOR_DOUBLE(GetThreadCacheMultiplierForAndroid, |
| kEnableConfigurableThreadCacheMultiplier, |
| "ThreadCacheMultiplierForAndroid", |
| 1.) |
| |
| constexpr partition_alloc::internal::base::TimeDelta ToPartitionAllocTimeDelta( |
| base::TimeDelta time_delta) { |
| return partition_alloc::internal::base::Microseconds( |
| time_delta.InMicroseconds()); |
| } |
| |
| constexpr base::TimeDelta FromPartitionAllocTimeDelta( |
| partition_alloc::internal::base::TimeDelta time_delta) { |
| return base::Microseconds(time_delta.InMicroseconds()); |
| } |
| |
| BASE_FEATURE(kEnableConfigurableThreadCachePurgeInterval, |
| "EnableConfigurableThreadCachePurgeInterval", |
| base::FEATURE_DISABLED_BY_DEFAULT); |
| |
| MIRACLE_PARAMETER_FOR_TIME_DELTA( |
| GetThreadCacheMinPurgeIntervalValue, |
| kEnableConfigurableThreadCachePurgeInterval, |
| "ThreadCacheMinPurgeInterval", |
| FromPartitionAllocTimeDelta(partition_alloc::kMinPurgeInterval)) |
| |
| MIRACLE_PARAMETER_FOR_TIME_DELTA( |
| GetThreadCacheMaxPurgeIntervalValue, |
| kEnableConfigurableThreadCachePurgeInterval, |
| "ThreadCacheMaxPurgeInterval", |
| FromPartitionAllocTimeDelta(partition_alloc::kMaxPurgeInterval)) |
| |
| MIRACLE_PARAMETER_FOR_TIME_DELTA( |
| GetThreadCacheDefaultPurgeIntervalValue, |
| kEnableConfigurableThreadCachePurgeInterval, |
| "ThreadCacheDefaultPurgeInterval", |
| FromPartitionAllocTimeDelta(partition_alloc::kDefaultPurgeInterval)) |
| |
| const partition_alloc::internal::base::TimeDelta |
| GetThreadCacheMinPurgeInterval() { |
| return ToPartitionAllocTimeDelta(GetThreadCacheMinPurgeIntervalValue()); |
| } |
| |
| const partition_alloc::internal::base::TimeDelta |
| GetThreadCacheMaxPurgeInterval() { |
| return ToPartitionAllocTimeDelta(GetThreadCacheMaxPurgeIntervalValue()); |
| } |
| |
| const partition_alloc::internal::base::TimeDelta |
| GetThreadCacheDefaultPurgeInterval() { |
| return ToPartitionAllocTimeDelta(GetThreadCacheDefaultPurgeIntervalValue()); |
| } |
| |
| BASE_FEATURE(kEnableConfigurableThreadCacheMinCachedMemoryForPurging, |
| "EnableConfigurableThreadCacheMinCachedMemoryForPurging", |
| base::FEATURE_DISABLED_BY_DEFAULT); |
| |
| MIRACLE_PARAMETER_FOR_INT( |
| GetThreadCacheMinCachedMemoryForPurgingBytes, |
| kEnableConfigurableThreadCacheMinCachedMemoryForPurging, |
| "ThreadCacheMinCachedMemoryForPurgingBytes", |
| partition_alloc::kMinCachedMemoryForPurgingBytes) |
| |
| // An apparent quarantine leak in the buffer partition unacceptably |
| // bloats memory when MiraclePtr is enabled in the renderer process. |
| // We believe we have found and patched the leak, but out of an |
| // abundance of caution, we provide this toggle that allows us to |
| // wholly disable MiraclePtr in the buffer partition, if necessary. |
| // |
| // TODO(crbug.com/1444624): this is unneeded once |
| // MiraclePtr-for-Renderer launches. |
| BASE_FEATURE(kPartitionAllocDisableBRPInBufferPartition, |
| "PartitionAllocDisableBRPInBufferPartition", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| #if BUILDFLAG(USE_FREELIST_POOL_OFFSETS) |
| BASE_FEATURE(kUsePoolOffsetFreelists, |
| "PartitionAllocUsePoolOffsetFreelists", |
| base::FEATURE_DISABLED_BY_DEFAULT); |
| #endif |
| |
| BASE_FEATURE(kPartitionAllocMakeFreeNoOpOnShutdown, |
| "PartitionAllocMakeFreeNoOpOnShutdown", |
| FEATURE_DISABLED_BY_DEFAULT); |
| |
| constexpr FeatureParam<WhenFreeBecomesNoOp>::Option |
| kPartitionAllocMakeFreeNoOpOnShutdownOptions[] = { |
| { |
| WhenFreeBecomesNoOp::kBeforeShutDownThreads, |
| "before-shutdown-threads", |
| }, |
| { |
| WhenFreeBecomesNoOp::kInShutDownThreads, |
| "in-shutdown-threads", |
| }, |
| { |
| WhenFreeBecomesNoOp::kAfterShutDownThreads, |
| "after-shutdown-threads", |
| }, |
| }; |
| |
| const base::FeatureParam<WhenFreeBecomesNoOp> |
| kPartitionAllocMakeFreeNoOpOnShutdownParam{ |
| &kPartitionAllocMakeFreeNoOpOnShutdown, "callsite", |
| WhenFreeBecomesNoOp::kBeforeShutDownThreads, |
| &kPartitionAllocMakeFreeNoOpOnShutdownOptions}; |
| |
| void MakeFreeNoOp(WhenFreeBecomesNoOp callsite) { |
| CHECK(base::FeatureList::GetInstance()); |
| // Ignoring `free()` during Shutdown would allow developers to introduce new |
| // dangling pointers. So we want to avoid ignoring free when it is enabled. |
| // Note: For now, the DanglingPointerDetector is only enabled on 5 bots, and |
| // on linux non-official configuration. |
| // TODO(b/40802063): Reconsider this decision after the experiment. |
| #if BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) |
| if (base::FeatureList::IsEnabled(features::kPartitionAllocDanglingPtr)) { |
| return; |
| } |
| #endif // BUILDFLAG(ENABLE_DANGLING_RAW_PTR_CHECKS) |
| #if BUILDFLAG(USE_ALLOCATOR_SHIM) |
| if (base::FeatureList::IsEnabled(kPartitionAllocMakeFreeNoOpOnShutdown) && |
| kPartitionAllocMakeFreeNoOpOnShutdownParam.Get() == callsite) { |
| allocator_shim::InsertNoOpOnFreeAllocatorShimOnShutDown(); |
| } |
| #endif // BUILDFLAG(USE_ALLOCATOR_SHIM) |
| } |
| |
| } // namespace features |
| } // namespace base |