Retro68/gcc/libsanitizer/asan/asan_activation.cc

143 lines
4.5 KiB
C++
Raw Normal View History

2015-08-28 15:33:40 +00:00
//===-- asan_activation.cc --------------------------------------*- C++ -*-===//
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file is a part of AddressSanitizer, an address sanity checker.
//
// ASan activation/deactivation logic.
//===----------------------------------------------------------------------===//
#include "asan_activation.h"
#include "asan_allocator.h"
#include "asan_flags.h"
#include "asan_internal.h"
2019-06-02 15:48:37 +00:00
#include "asan_mapping.h"
2017-04-10 11:32:00 +00:00
#include "asan_poisoning.h"
#include "asan_stack.h"
2019-06-02 15:48:37 +00:00
#include "sanitizer_common/sanitizer_common.h"
2015-08-28 15:33:40 +00:00
#include "sanitizer_common/sanitizer_flags.h"
namespace __asan {
static struct AsanDeactivatedFlags {
2017-04-10 11:32:00 +00:00
AllocatorOptions allocator_options;
2015-08-28 15:33:40 +00:00
int malloc_context_size;
bool poison_heap;
2017-04-10 11:32:00 +00:00
bool coverage;
const char *coverage_dir;
void RegisterActivationFlags(FlagParser *parser, Flags *f, CommonFlags *cf) {
#define ASAN_ACTIVATION_FLAG(Type, Name) \
RegisterFlag(parser, #Name, "", &f->Name);
#define COMMON_ACTIVATION_FLAG(Type, Name) \
RegisterFlag(parser, #Name, "", &cf->Name);
#include "asan_activation_flags.inc"
#undef ASAN_ACTIVATION_FLAG
#undef COMMON_ACTIVATION_FLAG
RegisterIncludeFlags(parser, cf);
}
void OverrideFromActivationFlags() {
Flags f;
CommonFlags cf;
FlagParser parser;
RegisterActivationFlags(&parser, &f, &cf);
cf.SetDefaults();
2017-04-10 11:32:00 +00:00
// Copy the current activation flags.
allocator_options.CopyTo(&f, &cf);
cf.malloc_context_size = malloc_context_size;
f.poison_heap = poison_heap;
cf.coverage = coverage;
cf.coverage_dir = coverage_dir;
cf.verbosity = Verbosity();
cf.help = false; // this is activation-specific help
// Check if activation flags need to be overriden.
if (const char *env = GetEnv("ASAN_ACTIVATION_OPTIONS")) {
parser.ParseString(env);
}
InitializeCommonFlags(&cf);
2017-04-10 11:32:00 +00:00
if (Verbosity()) ReportUnrecognizedFlags();
if (cf.help) parser.PrintFlagDescriptions();
allocator_options.SetFrom(&f, &cf);
malloc_context_size = cf.malloc_context_size;
poison_heap = f.poison_heap;
coverage = cf.coverage;
coverage_dir = cf.coverage_dir;
}
void Print() {
Report(
2018-12-28 15:30:48 +00:00
"quarantine_size_mb %d, thread_local_quarantine_size_kb %d, "
"max_redzone %d, poison_heap %d, malloc_context_size %d, "
"alloc_dealloc_mismatch %d, allocator_may_return_null %d, coverage %d, "
"coverage_dir %s, allocator_release_to_os_interval_ms %d\n",
allocator_options.quarantine_size_mb,
allocator_options.thread_local_quarantine_size_kb,
allocator_options.max_redzone, poison_heap, malloc_context_size,
2017-04-10 11:32:00 +00:00
allocator_options.alloc_dealloc_mismatch,
2018-12-28 15:30:48 +00:00
allocator_options.may_return_null, coverage, coverage_dir,
allocator_options.release_to_os_interval_ms);
2017-04-10 11:32:00 +00:00
}
2015-08-28 15:33:40 +00:00
} asan_deactivated_flags;
static bool asan_is_deactivated;
2017-04-10 11:32:00 +00:00
void AsanDeactivate() {
CHECK(!asan_is_deactivated);
2015-08-28 15:33:40 +00:00
VReport(1, "Deactivating ASan\n");
2017-04-10 11:32:00 +00:00
// Stash runtime state.
GetAllocatorOptions(&asan_deactivated_flags.allocator_options);
asan_deactivated_flags.malloc_context_size = GetMallocContextSize();
asan_deactivated_flags.poison_heap = CanPoisonMemory();
asan_deactivated_flags.coverage = common_flags()->coverage;
asan_deactivated_flags.coverage_dir = common_flags()->coverage_dir;
// Deactivate the runtime.
SetCanPoisonMemory(false);
SetMallocContextSize(1);
AllocatorOptions disabled = asan_deactivated_flags.allocator_options;
disabled.quarantine_size_mb = 0;
2018-12-28 15:30:48 +00:00
disabled.thread_local_quarantine_size_kb = 0;
2019-06-02 15:48:37 +00:00
// Redzone must be at least Max(16, granularity) bytes long.
disabled.min_redzone = Max(16, (int)SHADOW_GRANULARITY);
disabled.max_redzone = disabled.min_redzone;
2017-04-10 11:32:00 +00:00
disabled.alloc_dealloc_mismatch = false;
disabled.may_return_null = true;
ReInitializeAllocator(disabled);
2015-08-28 15:33:40 +00:00
asan_is_deactivated = true;
}
void AsanActivate() {
if (!asan_is_deactivated) return;
VReport(1, "Activating ASan\n");
2017-04-10 11:32:00 +00:00
UpdateProcessName();
2015-08-28 15:33:40 +00:00
2017-04-10 11:32:00 +00:00
asan_deactivated_flags.OverrideFromActivationFlags();
2015-08-28 15:33:40 +00:00
2017-04-10 11:32:00 +00:00
SetCanPoisonMemory(asan_deactivated_flags.poison_heap);
SetMallocContextSize(asan_deactivated_flags.malloc_context_size);
ReInitializeAllocator(asan_deactivated_flags.allocator_options);
2015-08-28 15:33:40 +00:00
asan_is_deactivated = false;
2017-04-10 11:32:00 +00:00
if (Verbosity()) {
Report("Activated with flags:\n");
asan_deactivated_flags.Print();
}
2015-08-28 15:33:40 +00:00
}
} // namespace __asan