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
22namespace __sanitizer {
23
24static ProcSelfMapsBuff cached_proc_self_maps;
25static StaticSpinMutex cache_lock;
26
27static 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.
38static 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
49bool IsDecimal(char c) {
50  int d = TranslateDigit(c);
51  return d >= 0 && d < 10;
52}
53
54uptr ParseDecimal(const char **p) {
55  return ParseNumber(p, 10);
56}
57
58bool IsHex(char c) {
59  int d = TranslateDigit(c);
60  return d >= 0 && d < 16;
61}
62
63uptr ParseHex(const char **p) {
64  return ParseNumber(p, 16);
65}
66
67void MemoryMappedSegment::AddAddressRanges(LoadedModule *module) {
68  // data_ should be unused on this platform
69  CHECK(!data_);
70  module->addAddressRange(start, end, IsExecutable(), IsWritable());
71}
72
73MemoryMappingLayout::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
87bool MemoryMappingLayout::Error() const {
88  return data_.current == nullptr;
89}
90
91MemoryMappingLayout::~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
98void MemoryMappingLayout::Reset() {
99  data_.current = data_.proc_self_maps.data;
100}
101
102// static
103void 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
115void 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
121void 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
149void 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