1 //===-- sanitizer_procmaps_common.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 // Information about the process mappings (common parts).
11 //===----------------------------------------------------------------------===//
12
13 #include "sanitizer_platform.h"
14
15 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
16 SANITIZER_OPENBSD || SANITIZER_SOLARIS
17
18 #include "sanitizer_common.h"
19 #include "sanitizer_placement_new.h"
20 #include "sanitizer_procmaps.h"
21
22 namespace __sanitizer {
23
24 static ProcSelfMapsBuff cached_proc_self_maps;
25 static StaticSpinMutex cache_lock;
26
TranslateDigit(char c)27 static int TranslateDigit(char c) {
28 if (c >= '0' && c <= '9')
29 return c - '0';
30 if (c >= 'a' && c <= 'f')
31 return c - 'a' + 10;
32 if (c >= 'A' && c <= 'F')
33 return c - 'A' + 10;
34 return -1;
35 }
36
37 // Parse a number and promote 'p' up to the first non-digit character.
ParseNumber(const char ** p,int base)38 static uptr ParseNumber(const char **p, int base) {
39 uptr n = 0;
40 int d;
41 CHECK(base >= 2 && base <= 16);
42 while ((d = TranslateDigit(**p)) >= 0 && d < base) {
43 n = n * base + d;
44 (*p)++;
45 }
46 return n;
47 }
48
IsDecimal(char c)49 bool IsDecimal(char c) {
50 int d = TranslateDigit(c);
51 return d >= 0 && d < 10;
52 }
53
ParseDecimal(const char ** p)54 uptr ParseDecimal(const char **p) {
55 return ParseNumber(p, 10);
56 }
57
IsHex(char c)58 bool IsHex(char c) {
59 int d = TranslateDigit(c);
60 return d >= 0 && d < 16;
61 }
62
ParseHex(const char ** p)63 uptr ParseHex(const char **p) {
64 return ParseNumber(p, 16);
65 }
66
AddAddressRanges(LoadedModule * module)67 void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
68 // data_ should be unused on this platform
69 CHECK(!data_);
70 module->addAddressRange(start, end, IsExecutable(), IsWritable());
71 }
72
MemoryMappingLayout(bool cache_enabled)73 MemoryMappingLayout::MemoryMappingLayout(bool cache_enabled) {
74 // FIXME: in the future we may want to cache the mappings on demand only.
75 if (cache_enabled)
76 CacheMemoryMappings();
77
78 // Read maps after the cache update to capture the maps/unmaps happening in
79 // the process of updating.
80 ReadProcMaps(&data_.proc_self_maps);
81 if (cache_enabled && data_.proc_self_maps.mmaped_size == 0)
82 LoadFromCache();
83
84 Reset();
85 }
86
Error() const87 bool MemoryMappingLayout::Error() const {
88 return data_.current == nullptr;
89 }
90
~MemoryMappingLayout()91 MemoryMappingLayout::~MemoryMappingLayout() {
92 // Only unmap the buffer if it is different from the cached one. Otherwise
93 // it will be unmapped when the cache is refreshed.
94 if (data_.proc_self_maps.data != cached_proc_self_maps.data)
95 UnmapOrDie(data_.proc_self_maps.data, data_.proc_self_maps.mmaped_size);
96 }
97
Reset()98 void MemoryMappingLayout::Reset() {
99 data_.current = data_.proc_self_maps.data;
100 }
101
102 // static
CacheMemoryMappings()103 void MemoryMappingLayout::CacheMemoryMappings() {
104 ProcSelfMapsBuff new_proc_self_maps;
105 ReadProcMaps(&new_proc_self_maps);
106 // Don't invalidate the cache if the mappings are unavailable.
107 if (new_proc_self_maps.mmaped_size == 0)
108 return;
109 SpinMutexLock l(&cache_lock);
110 if (cached_proc_self_maps.mmaped_size)
111 UnmapOrDie(cached_proc_self_maps.data, cached_proc_self_maps.mmaped_size);
112 cached_proc_self_maps = new_proc_self_maps;
113 }
114
LoadFromCache()115 void MemoryMappingLayout::LoadFromCache() {
116 SpinMutexLock l(&cache_lock);
117 if (cached_proc_self_maps.data)
118 data_.proc_self_maps = cached_proc_self_maps;
119 }
120
DumpListOfModules(InternalMmapVectorNoCtor<LoadedModule> * modules)121 void MemoryMappingLayout::DumpListOfModules(
122 InternalMmapVectorNoCtor<LoadedModule> *modules) {
123 Reset();
124 InternalScopedString module_name(kMaxPathLength);
125 MemoryMappedSegment segment(module_name.data(), module_name.size());
126 for (uptr i = 0; Next(&segment); i++) {
127 const char *cur_name = segment.filename;
128 if (cur_name[0] == '\0')
129 continue;
130 // Don't subtract 'cur_beg' from the first entry:
131 // * If a binary is compiled w/o -pie, then the first entry in
132 // process maps is likely the binary itself (all dynamic libs
133 // are mapped higher in address space). For such a binary,
134 // instruction offset in binary coincides with the actual
135 // instruction address in virtual memory (as code section
136 // is mapped to a fixed memory range).
137 // * If a binary is compiled with -pie, all the modules are
138 // mapped high at address space (in particular, higher than
139 // shadow memory of the tool), so the module can't be the
140 // first entry.
141 uptr base_address = (i ? segment.start : 0) - segment.offset;
142 LoadedModule cur_module;
143 cur_module.set(cur_name, base_address);
144 segment.AddAddressRanges(&cur_module);
145 modules->push_back(cur_module);
146 }
147 }
148
GetMemoryProfile(fill_profile_f cb,uptr * stats,uptr stats_size)149 void GetMemoryProfile(fill_profile_f cb, uptr *stats, uptr stats_size) {
150 char *smaps = nullptr;
151 uptr smaps_cap = 0;
152 uptr smaps_len = 0;
153 if (!ReadFileToBuffer("/proc/self/smaps", &smaps, &smaps_cap, &smaps_len))
154 return;
155 uptr start = 0;
156 bool file = false;
157 const char *pos = smaps;
158 while (pos < smaps + smaps_len) {
159 if (IsHex(pos[0])) {
160 start = ParseHex(&pos);
161 for (; *pos != '/' && *pos > '\n'; pos++) {}
162 file = *pos == '/';
163 } else if (internal_strncmp(pos, "Rss:", 4) == 0) {
164 while (!IsDecimal(*pos)) pos++;
165 uptr rss = ParseDecimal(&pos) * 1024;
166 cb(start, rss, file, stats, stats_size);
167 }
168 while (*pos++ != '\n') {}
169 }
170 UnmapOrDie(smaps, smaps_cap);
171 }
172
173 } // namespace __sanitizer
174
175 #endif
176