1 //===-- sanitizer_coverage_mapping.cc -------------------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Mmap-based implementation of sanitizer coverage.
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.
15 // $pid.sancov.map describes process memory layout in the following text-based
17 // <pointer size in bits> // 1 line, 32 or 64
18 // <mapping start> <mapping end> <base address> <dso name> // repeated
20 // Mapping lines are NOT sorted. This file is updated every time memory layout
21 // is changed (i.e. in dlopen() and dlclose() interceptors).
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.
27 // To convert these 2 files to the usual .sancov format, run sancov.py rawunpack
30 //===----------------------------------------------------------------------===//
32 #include "sanitizer_allocator_internal.h"
33 #include "sanitizer_libc.h"
34 #include "sanitizer_procmaps.h"
36 namespace __sanitizer {
38 static const uptr kMaxNumberOfModules = 1 << 14;
39 static const uptr kMaxTextSize = 64 * 1024;
41 struct CachedMapping {
43 bool NeedsUpdate(uptr pc) {
44 int new_pid = internal_getpid();
45 if (last_pid == new_pid && pc && pc >= last_range_start &&
52 void SetModuleRange(uptr start, uptr end) {
53 last_range_start = start;
58 uptr last_range_start, last_range_end;
62 static CachedMapping cached_mapping;
63 static StaticSpinMutex mapping_mu;
65 void CovUpdateMapping(uptr caller_pc) {
66 if (!common_flags()->coverage || !common_flags()->coverage_direct) return;
68 SpinMutexLock l(&mapping_mu);
70 if (!cached_mapping.NeedsUpdate(caller_pc))
73 InternalScopedString text(kMaxTextSize);
74 InternalScopedBuffer<LoadedModule> modules(kMaxNumberOfModules);
75 CHECK(modules.data());
76 int n_modules = GetListOfModules(modules.data(), kMaxNumberOfModules,
79 text.append("%d\n", sizeof(uptr) * 8);
80 for (int i = 0; i < n_modules; ++i) {
81 const char *module_name = StripModuleName(modules[i].full_name());
82 for (unsigned j = 0; j < modules[i].n_ranges(); ++j) {
83 if (modules[i].address_range_executable(j)) {
84 uptr start = modules[i].address_range_start(j);
85 uptr end = modules[i].address_range_end(j);
86 uptr base = modules[i].base_address();
87 text.append("%zx %zx %zx %s\n", start, end, base, module_name);
88 if (caller_pc && caller_pc >= start && caller_pc < end)
89 cached_mapping.SetModuleRange(start, end);
95 InternalScopedString tmp_path(64 +
96 internal_strlen(common_flags()->coverage_dir));
97 uptr res = internal_snprintf((char *)tmp_path.data(), tmp_path.size(),
98 "%s/%zd.sancov.map.tmp", common_flags()->coverage_dir,
100 CHECK_LE(res, tmp_path.size());
101 uptr map_fd = OpenFile(tmp_path.data(), true);
102 if (internal_iserror(map_fd)) {
103 Report(" Coverage: failed to open %s for writing\n", tmp_path.data());
107 res = internal_write(map_fd, text.data(), text.length());
108 if (internal_iserror(res, &err)) {
109 Printf("sancov.map write failed: %d\n", err);
112 internal_close(map_fd);
114 InternalScopedString path(64 + internal_strlen(common_flags()->coverage_dir));
115 res = internal_snprintf((char *)path.data(), path.size(), "%s/%zd.sancov.map",
116 common_flags()->coverage_dir, internal_getpid());
117 CHECK_LE(res, path.size());
118 res = internal_rename(tmp_path.data(), path.data());
119 if (internal_iserror(res, &err)) {
120 Printf("sancov.map rename failed: %d\n", err);
125 } // namespace __sanitizer