1 //===-- asan_activation.cc --------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file is a part of AddressSanitizer, an address sanity checker. 11 // 12 // ASan activation/deactivation logic. 13 //===----------------------------------------------------------------------===// 14 15 #include "asan_activation.h" 16 #include "asan_allocator.h" 17 #include "asan_flags.h" 18 #include "asan_internal.h" 19 #include "asan_mapping.h" 20 #include "asan_poisoning.h" 21 #include "asan_stack.h" 22 #include "sanitizer_common/sanitizer_common.h" 23 #include "sanitizer_common/sanitizer_flags.h" 24 25 namespace __asan { 26 27 static struct AsanDeactivatedFlags { 28 AllocatorOptions allocator_options; 29 int malloc_context_size; 30 bool poison_heap; 31 bool coverage; 32 const char *coverage_dir; 33 34 void RegisterActivationFlags(FlagParser *parser, Flags *f, CommonFlags *cf) { 35 #define ASAN_ACTIVATION_FLAG(Type, Name) \ 36 RegisterFlag(parser, #Name, "", &f->Name); 37 #define COMMON_ACTIVATION_FLAG(Type, Name) \ 38 RegisterFlag(parser, #Name, "", &cf->Name); 39 #include "asan_activation_flags.inc" 40 #undef ASAN_ACTIVATION_FLAG 41 #undef COMMON_ACTIVATION_FLAG 42 43 RegisterIncludeFlags(parser, cf); 44 } 45 46 void OverrideFromActivationFlags() { 47 Flags f; 48 CommonFlags cf; 49 FlagParser parser; 50 RegisterActivationFlags(&parser, &f, &cf); 51 52 cf.SetDefaults(); 53 // Copy the current activation flags. 54 allocator_options.CopyTo(&f, &cf); 55 cf.malloc_context_size = malloc_context_size; 56 f.poison_heap = poison_heap; 57 cf.coverage = coverage; 58 cf.coverage_dir = coverage_dir; 59 cf.verbosity = Verbosity(); 60 cf.help = false; // this is activation-specific help 61 62 // Check if activation flags need to be overriden. 63 if (const char *env = GetEnv("ASAN_ACTIVATION_OPTIONS")) { 64 parser.ParseString(env); 65 } 66 67 InitializeCommonFlags(&cf); 68 69 if (Verbosity()) ReportUnrecognizedFlags(); 70 71 if (cf.help) parser.PrintFlagDescriptions(); 72 73 allocator_options.SetFrom(&f, &cf); 74 malloc_context_size = cf.malloc_context_size; 75 poison_heap = f.poison_heap; 76 coverage = cf.coverage; 77 coverage_dir = cf.coverage_dir; 78 } 79 80 void Print() { 81 Report( 82 "quarantine_size_mb %d, thread_local_quarantine_size_kb %d, " 83 "max_redzone %d, poison_heap %d, malloc_context_size %d, " 84 "alloc_dealloc_mismatch %d, allocator_may_return_null %d, coverage %d, " 85 "coverage_dir %s, allocator_release_to_os_interval_ms %d\n", 86 allocator_options.quarantine_size_mb, 87 allocator_options.thread_local_quarantine_size_kb, 88 allocator_options.max_redzone, poison_heap, malloc_context_size, 89 allocator_options.alloc_dealloc_mismatch, 90 allocator_options.may_return_null, coverage, coverage_dir, 91 allocator_options.release_to_os_interval_ms); 92 } 93 } asan_deactivated_flags; 94 95 static bool asan_is_deactivated; 96 97 void AsanDeactivate() { 98 CHECK(!asan_is_deactivated); 99 VReport(1, "Deactivating ASan\n"); 100 101 // Stash runtime state. 102 GetAllocatorOptions(&asan_deactivated_flags.allocator_options); 103 asan_deactivated_flags.malloc_context_size = GetMallocContextSize(); 104 asan_deactivated_flags.poison_heap = CanPoisonMemory(); 105 asan_deactivated_flags.coverage = common_flags()->coverage; 106 asan_deactivated_flags.coverage_dir = common_flags()->coverage_dir; 107 108 // Deactivate the runtime. 109 SetCanPoisonMemory(false); 110 SetMallocContextSize(1); 111 112 AllocatorOptions disabled = asan_deactivated_flags.allocator_options; 113 disabled.quarantine_size_mb = 0; 114 disabled.thread_local_quarantine_size_kb = 0; 115 // Redzone must be at least Max(16, granularity) bytes long. 116 disabled.min_redzone = Max(16, (int)SHADOW_GRANULARITY); 117 disabled.max_redzone = disabled.min_redzone; 118 disabled.alloc_dealloc_mismatch = false; 119 disabled.may_return_null = true; 120 ReInitializeAllocator(disabled); 121 122 asan_is_deactivated = true; 123 } 124 125 void AsanActivate() { 126 if (!asan_is_deactivated) return; 127 VReport(1, "Activating ASan\n"); 128 129 UpdateProcessName(); 130 131 asan_deactivated_flags.OverrideFromActivationFlags(); 132 133 SetCanPoisonMemory(asan_deactivated_flags.poison_heap); 134 SetMallocContextSize(asan_deactivated_flags.malloc_context_size); 135 ReInitializeAllocator(asan_deactivated_flags.allocator_options); 136 137 asan_is_deactivated = false; 138 if (Verbosity()) { 139 Report("Activated with flags:\n"); 140 asan_deactivated_flags.Print(); 141 } 142 } 143 144 } // namespace __asan 145