1 //===-- sanitizer_coverage_mapping.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 // 10 // Mmap-based implementation of sanitizer coverage. 11 // 12 // This is part of the implementation of code coverage that does not require 13 // __sanitizer_cov_dump() call. Data is stored in 2 files per process. 14 // 15 // $pid.sancov.map describes process memory layout in the following text-based 16 // format: 17 // <pointer size in bits> // 1 line, 32 or 64 18 // <mapping start> <mapping end> <base address> <dso name> // repeated 19 // ... 20 // Mapping lines are NOT sorted. This file is updated every time memory layout 21 // is changed (i.e. in dlopen() and dlclose() interceptors). 22 // 23 // $pid.sancov.raw is a binary dump of PC values, sizeof(uptr) each. Again, not 24 // sorted. This file is extended by 64Kb at a time and mapped into memory. It 25 // contains one or more 0 words at the end, up to the next 64Kb aligned offset. 26 // 27 // To convert these 2 files to the usual .sancov format, run sancov.py rawunpack 28 // $pid.sancov.raw. 29 // 30 //===----------------------------------------------------------------------===// 31 32 #include "sanitizer_allocator_internal.h" 33 #include "sanitizer_libc.h" 34 #include "sanitizer_procmaps.h" 35 36 namespace __sanitizer { 37 38 static const uptr kMaxTextSize = 64 * 1024; 39 40 struct CachedMapping { 41 public: 42 bool NeedsUpdate(uptr pc) { 43 int new_pid = internal_getpid(); 44 if (last_pid == new_pid && pc && pc >= last_range_start && 45 pc < last_range_end) 46 return false; 47 last_pid = new_pid; 48 return true; 49 } 50 51 void SetModuleRange(uptr start, uptr end) { 52 last_range_start = start; 53 last_range_end = end; 54 } 55 56 private: 57 uptr last_range_start, last_range_end; 58 int last_pid; 59 }; 60 61 static CachedMapping cached_mapping; 62 static StaticSpinMutex mapping_mu; 63 64 void CovUpdateMapping(const char *coverage_dir, uptr caller_pc) { 65 if (!common_flags()->coverage_direct) return; 66 67 SpinMutexLock l(&mapping_mu); 68 69 if (!cached_mapping.NeedsUpdate(caller_pc)) 70 return; 71 72 InternalScopedString text(kMaxTextSize); 73 74 { 75 text.append("%d\n", sizeof(uptr) * 8); 76 ListOfModules modules; 77 modules.init(); 78 for (const LoadedModule &module : modules) { 79 const char *module_name = StripModuleName(module.full_name()); 80 uptr base = module.base_address(); 81 for (const auto &range : module.ranges()) { 82 if (range.executable) { 83 uptr start = range.beg; 84 uptr end = range.end; 85 text.append("%zx %zx %zx %s\n", start, end, base, module_name); 86 if (caller_pc && caller_pc >= start && caller_pc < end) 87 cached_mapping.SetModuleRange(start, end); 88 } 89 } 90 } 91 } 92 93 error_t err; 94 InternalScopedString tmp_path(64 + internal_strlen(coverage_dir)); 95 uptr res = internal_snprintf((char *)tmp_path.data(), tmp_path.size(), 96 "%s/%zd.sancov.map.tmp", coverage_dir, 97 internal_getpid()); 98 CHECK_LE(res, tmp_path.size()); 99 fd_t map_fd = OpenFile(tmp_path.data(), WrOnly, &err); 100 if (map_fd == kInvalidFd) { 101 Report("Coverage: failed to open %s for writing: %d\n", tmp_path.data(), 102 err); 103 Die(); 104 } 105 106 if (!WriteToFile(map_fd, text.data(), text.length(), nullptr, &err)) { 107 Printf("sancov.map write failed: %d\n", err); 108 Die(); 109 } 110 CloseFile(map_fd); 111 112 InternalScopedString path(64 + internal_strlen(coverage_dir)); 113 res = internal_snprintf((char *)path.data(), path.size(), "%s/%zd.sancov.map", 114 coverage_dir, internal_getpid()); 115 CHECK_LE(res, path.size()); 116 if (!RenameFile(tmp_path.data(), path.data(), &err)) { 117 Printf("sancov.map rename failed: %d\n", err); 118 Die(); 119 } 120 } 121 122 } // namespace __sanitizer 123