1 //===-- sanitizer_coverage_libcdep_new.cc ---------------------------------===// 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 // Sanitizer Coverage Controller for Trace PC Guard. 10 11 #include "sanitizer_platform.h" 12 13 #if !SANITIZER_FUCHSIA 14 #include "sancov_flags.h" 15 #include "sanitizer_allocator_internal.h" 16 #include "sanitizer_atomic.h" 17 #include "sanitizer_common.h" 18 #include "sanitizer_file.h" 19 20 using namespace __sanitizer; 21 22 using AddressRange = LoadedModule::AddressRange; 23 24 namespace __sancov { 25 namespace { 26 27 static const u64 Magic64 = 0xC0BFFFFFFFFFFF64ULL; 28 static const u64 Magic32 = 0xC0BFFFFFFFFFFF32ULL; 29 static const u64 Magic = SANITIZER_WORDSIZE == 64 ? Magic64 : Magic32; 30 31 static fd_t OpenFile(const char* path) { 32 error_t err; 33 fd_t fd = OpenFile(path, WrOnly, &err); 34 if (fd == kInvalidFd) 35 Report("SanitizerCoverage: failed to open %s for writing (reason: %d)\n", 36 path, err); 37 return fd; 38 } 39 40 static void GetCoverageFilename(char* path, const char* name, 41 const char* extension) { 42 CHECK(name); 43 internal_snprintf(path, kMaxPathLength, "%s/%s.%zd.%s", 44 common_flags()->coverage_dir, name, internal_getpid(), 45 extension); 46 } 47 48 static void WriteModuleCoverage(char* file_path, const char* module_name, 49 const uptr* pcs, uptr len) { 50 GetCoverageFilename(file_path, StripModuleName(module_name), "sancov"); 51 fd_t fd = OpenFile(file_path); 52 WriteToFile(fd, &Magic, sizeof(Magic)); 53 WriteToFile(fd, pcs, len * sizeof(*pcs)); 54 CloseFile(fd); 55 Printf("SanitizerCoverage: %s: %zd PCs written\n", file_path, len); 56 } 57 58 static void SanitizerDumpCoverage(const uptr* unsorted_pcs, uptr len) { 59 if (!len) return; 60 61 char* file_path = static_cast<char*>(InternalAlloc(kMaxPathLength)); 62 char* module_name = static_cast<char*>(InternalAlloc(kMaxPathLength)); 63 uptr* pcs = static_cast<uptr*>(InternalAlloc(len * sizeof(uptr))); 64 65 internal_memcpy(pcs, unsorted_pcs, len * sizeof(uptr)); 66 Sort(pcs, len); 67 68 bool module_found = false; 69 uptr last_base = 0; 70 uptr module_start_idx = 0; 71 72 for (uptr i = 0; i < len; ++i) { 73 const uptr pc = pcs[i]; 74 if (!pc) continue; 75 76 if (!__sanitizer_get_module_and_offset_for_pc(pc, nullptr, 0, &pcs[i])) { 77 Printf("ERROR: unknown pc 0x%x (may happen if dlclose is used)\n", pc); 78 continue; 79 } 80 uptr module_base = pc - pcs[i]; 81 82 if (module_base != last_base || !module_found) { 83 if (module_found) { 84 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx], 85 i - module_start_idx); 86 } 87 88 last_base = module_base; 89 module_start_idx = i; 90 module_found = true; 91 __sanitizer_get_module_and_offset_for_pc(pc, module_name, kMaxPathLength, 92 &pcs[i]); 93 } 94 } 95 96 if (module_found) { 97 WriteModuleCoverage(file_path, module_name, &pcs[module_start_idx], 98 len - module_start_idx); 99 } 100 101 InternalFree(file_path); 102 InternalFree(module_name); 103 InternalFree(pcs); 104 } 105 106 // Collects trace-pc guard coverage. 107 // This class relies on zero-initialization. 108 class TracePcGuardController { 109 public: 110 void Initialize() { 111 CHECK(!initialized); 112 113 initialized = true; 114 InitializeSancovFlags(); 115 116 pc_vector.Initialize(0); 117 } 118 119 void InitTracePcGuard(u32* start, u32* end) { 120 if (!initialized) Initialize(); 121 CHECK(!*start); 122 CHECK_NE(start, end); 123 124 u32 i = pc_vector.size(); 125 for (u32* p = start; p < end; p++) *p = ++i; 126 pc_vector.resize(i); 127 } 128 129 void TracePcGuard(u32* guard, uptr pc) { 130 u32 idx = *guard; 131 if (!idx) return; 132 // we start indices from 1. 133 atomic_uintptr_t* pc_ptr = 134 reinterpret_cast<atomic_uintptr_t*>(&pc_vector[idx - 1]); 135 if (atomic_load(pc_ptr, memory_order_relaxed) == 0) 136 atomic_store(pc_ptr, pc, memory_order_relaxed); 137 } 138 139 void Reset() { 140 internal_memset(&pc_vector[0], 0, sizeof(pc_vector[0]) * pc_vector.size()); 141 } 142 143 void Dump() { 144 if (!initialized || !common_flags()->coverage) return; 145 __sanitizer_dump_coverage(pc_vector.data(), pc_vector.size()); 146 } 147 148 private: 149 bool initialized; 150 InternalMmapVectorNoCtor<uptr> pc_vector; 151 }; 152 153 static TracePcGuardController pc_guard_controller; 154 155 } // namespace 156 } // namespace __sancov 157 158 namespace __sanitizer { 159 void InitializeCoverage(bool enabled, const char *dir) { 160 static bool coverage_enabled = false; 161 if (coverage_enabled) 162 return; // May happen if two sanitizer enable coverage in the same process. 163 coverage_enabled = enabled; 164 Atexit(__sanitizer_cov_dump); 165 AddDieCallback(__sanitizer_cov_dump); 166 } 167 } // namespace __sanitizer 168 169 extern "C" { 170 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_coverage( // NOLINT 171 const uptr* pcs, uptr len) { 172 return __sancov::SanitizerDumpCoverage(pcs, len); 173 } 174 175 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard, u32* guard) { 176 if (!*guard) return; 177 __sancov::pc_guard_controller.TracePcGuard(guard, GET_CALLER_PC() - 1); 178 } 179 180 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_guard_init, 181 u32* start, u32* end) { 182 if (start == end || *start) return; 183 __sancov::pc_guard_controller.InitTracePcGuard(start, end); 184 } 185 186 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_dump_trace_pc_guard_coverage() { 187 __sancov::pc_guard_controller.Dump(); 188 } 189 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_dump() { 190 __sanitizer_dump_trace_pc_guard_coverage(); 191 } 192 SANITIZER_INTERFACE_ATTRIBUTE void __sanitizer_cov_reset() { 193 __sancov::pc_guard_controller.Reset(); 194 } 195 // Default empty implementations (weak). Users should redefine them. 196 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp, void) {} 197 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp1, void) {} 198 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp2, void) {} 199 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp4, void) {} 200 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_cmp8, void) {} 201 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp1, void) {} 202 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp2, void) {} 203 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp4, void) {} 204 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_const_cmp8, void) {} 205 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_switch, void) {} 206 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div4, void) {} 207 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_div8, void) {} 208 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_gep, void) {} 209 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_trace_pc_indir, void) {} 210 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_8bit_counters_init, void) {} 211 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_cov_pcs_init, void) {} 212 } // extern "C" 213 // Weak definition for code instrumented with -fsanitize-coverage=stack-depth 214 // and later linked with code containing a strong definition. 215 // E.g., -fsanitize=fuzzer-no-link 216 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE 217 SANITIZER_TLS_INITIAL_EXEC_ATTRIBUTE uptr __sancov_lowest_stack; 218 219 #endif // !SANITIZER_FUCHSIA 220
Indexes created Tue Sep 23 14:10:03 GMT 2025