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 kMaxTextSize
= 64 * 1024;
40 struct CachedMapping
{
42 bool NeedsUpdate(uptr pc
) {
43 int new_pid
= internal_getpid();
44 if (last_pid
== new_pid
&& pc
&& pc
>= last_range_start
&&
51 void SetModuleRange(uptr start
, uptr end
) {
52 last_range_start
= start
;
57 uptr last_range_start
, last_range_end
;
61 static CachedMapping cached_mapping
;
62 static StaticSpinMutex mapping_mu
;
64 void CovUpdateMapping(const char *coverage_dir
, uptr caller_pc
) {
65 if (!common_flags()->coverage_direct
) return;
67 SpinMutexLock
l(&mapping_mu
);
69 if (!cached_mapping
.NeedsUpdate(caller_pc
))
72 InternalScopedString
text(kMaxTextSize
);
75 InternalScopedBuffer
<LoadedModule
> modules(kMaxNumberOfModules
);
76 CHECK(modules
.data());
77 int n_modules
= GetListOfModules(modules
.data(), kMaxNumberOfModules
,
78 /* filter */ nullptr);
80 text
.append("%d\n", sizeof(uptr
) * 8);
81 for (int i
= 0; i
< n_modules
; ++i
) {
82 const char *module_name
= StripModuleName(modules
[i
].full_name());
83 uptr base
= modules
[i
].base_address();
84 for (auto iter
= modules
[i
].ranges(); iter
.hasNext();) {
85 const auto *range
= iter
.next();
86 if (range
->executable
) {
87 uptr start
= range
->beg
;
88 uptr end
= range
->end
;
89 text
.append("%zx %zx %zx %s\n", start
, end
, base
, module_name
);
90 if (caller_pc
&& caller_pc
>= start
&& caller_pc
< end
)
91 cached_mapping
.SetModuleRange(start
, end
);
99 InternalScopedString
tmp_path(64 + internal_strlen(coverage_dir
));
100 uptr res
= internal_snprintf((char *)tmp_path
.data(), tmp_path
.size(),
101 "%s/%zd.sancov.map.tmp", coverage_dir
,
103 CHECK_LE(res
, tmp_path
.size());
104 fd_t map_fd
= OpenFile(tmp_path
.data(), WrOnly
, &err
);
105 if (map_fd
== kInvalidFd
) {
106 Report("Coverage: failed to open %s for writing: %d\n", tmp_path
.data(),
111 if (!WriteToFile(map_fd
, text
.data(), text
.length(), nullptr, &err
)) {
112 Printf("sancov.map write failed: %d\n", err
);
117 InternalScopedString
path(64 + internal_strlen(coverage_dir
));
118 res
= internal_snprintf((char *)path
.data(), path
.size(), "%s/%zd.sancov.map",
119 coverage_dir
, internal_getpid());
120 CHECK_LE(res
, path
.size());
121 if (!RenameFile(tmp_path
.data(), path
.data(), &err
)) {
122 Printf("sancov.map rename failed: %d\n", err
);
127 } // namespace __sanitizer