sanitizer_common.cc revision 694d85636b148dfcac37e5c23639baa8fe9abce9 
1//===-- sanitizer_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// This file is shared between AddressSanitizer and ThreadSanitizer
11// run-time libraries.
12//===----------------------------------------------------------------------===//
13
14#include "sanitizer_common.h"
15#include "sanitizer_flags.h"
16#include "sanitizer_libc.h"
17#include "sanitizer_stacktrace.h"
18#include "sanitizer_symbolizer.h"
19
20namespace __sanitizer {
21
22const char *SanitizerToolName = "SanitizerTool";
23
24uptr GetPageSizeCached() {
25  static uptr PageSize;
26  if (!PageSize)
27    PageSize = GetPageSize();
28  return PageSize;
29}
30
31
32// By default, dump to stderr. If |log_to_file| is true and |report_fd_pid|
33// isn't equal to the current PID, try to obtain file descriptor by opening
34// file "report_path_prefix.<PID>".
35fd_t report_fd = kStderrFd;
36
37// Set via __sanitizer_set_report_path.
38bool log_to_file = false;
39char report_path_prefix[sizeof(report_path_prefix)];
40
41// PID of process that opened |report_fd|. If a fork() occurs, the PID of the
42// child thread will be different from |report_fd_pid|.
43uptr report_fd_pid = 0;
44
45static DieCallbackType DieCallback;
46void SetDieCallback(DieCallbackType callback) {
47  DieCallback = callback;
48}
49
50DieCallbackType GetDieCallback() {
51  return DieCallback;
52}
53
54void NORETURN Die() {
55  if (DieCallback) {
56    DieCallback();
57  }
58  internal__exit(1);
59}
60
61static CheckFailedCallbackType CheckFailedCallback;
62void SetCheckFailedCallback(CheckFailedCallbackType callback) {
63  CheckFailedCallback = callback;
64}
65
66void NORETURN CheckFailed(const char *file, int line, const char *cond,
67                          u64 v1, u64 v2) {
68  if (CheckFailedCallback) {
69    CheckFailedCallback(file, line, cond, v1, v2);
70  }
71  Report("Sanitizer CHECK failed: %s:%d %s (%lld, %lld)\n", file, line, cond,
72                                                            v1, v2);
73  Die();
74}
75
76uptr ReadFileToBuffer(const char *file_name, char **buff,
77                      uptr *buff_size, uptr max_len) {
78  uptr PageSize = GetPageSizeCached();
79  uptr kMinFileLen = PageSize;
80  uptr read_len = 0;
81  *buff = 0;
82  *buff_size = 0;
83  // The files we usually open are not seekable, so try different buffer sizes.
84  for (uptr size = kMinFileLen; size <= max_len; size *= 2) {
85    uptr openrv = OpenFile(file_name, /*write*/ false);
86    if (internal_iserror(openrv)) return 0;
87    fd_t fd = openrv;
88    UnmapOrDie(*buff, *buff_size);
89    *buff = (char*)MmapOrDie(size, __FUNCTION__);
90    *buff_size = size;
91    // Read up to one page at a time.
92    read_len = 0;
93    bool reached_eof = false;
94    while (read_len + PageSize <= size) {
95      uptr just_read = internal_read(fd, *buff + read_len, PageSize);
96      if (just_read == 0) {
97        reached_eof = true;
98        break;
99      }
100      read_len += just_read;
101    }
102    internal_close(fd);
103    if (reached_eof)  // We've read the whole file.
104      break;
105  }
106  return read_len;
107}
108
109typedef bool UptrComparisonFunction(const uptr &a, const uptr &b);
110
111template<class T>
112static inline bool CompareLess(const T &a, const T &b) {
113  return a < b;
114}
115
116void SortArray(uptr *array, uptr size) {
117  InternalSort<uptr*, UptrComparisonFunction>(&array, size, CompareLess);
118}
119
120// We want to map a chunk of address space aligned to 'alignment'.
121// We do it by maping a bit more and then unmaping redundant pieces.
122// We probably can do it with fewer syscalls in some OS-dependent way.
123void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) {
124// uptr PageSize = GetPageSizeCached();
125  CHECK(IsPowerOfTwo(size));
126  CHECK(IsPowerOfTwo(alignment));
127  uptr map_size = size + alignment;
128  uptr map_res = (uptr)MmapOrDie(map_size, mem_type);
129  uptr map_end = map_res + map_size;
130  uptr res = map_res;
131  if (res & (alignment - 1))  // Not aligned.
132    res = (map_res + alignment) & ~(alignment - 1);
133  uptr end = res + size;
134  if (res != map_res)
135    UnmapOrDie((void*)map_res, res - map_res);
136  if (end != map_end)
137    UnmapOrDie((void*)end, map_end - end);
138  return (void*)res;
139}
140
141const char *StripPathPrefix(const char *filepath,
142                            const char *strip_path_prefix) {
143  if (filepath == 0) return 0;
144  if (strip_path_prefix == 0) return filepath;
145  const char *pos = internal_strstr(filepath, strip_path_prefix);
146  if (pos == 0) return filepath;
147  pos += internal_strlen(strip_path_prefix);
148  if (pos[0] == '.' && pos[1] == '/')
149    pos += 2;
150  return pos;
151}
152
153void PrintSourceLocation(const char *file, int line, int column) {
154  CHECK(file);
155  Printf("%s", StripPathPrefix(file, common_flags()->strip_path_prefix));
156  if (line > 0) {
157    Printf(":%d", line);
158    if (column > 0)
159      Printf(":%d", column);
160  }
161}
162
163void PrintModuleAndOffset(const char *module, uptr offset) {
164  Printf("(%s+0x%zx)",
165         StripPathPrefix(module, common_flags()->strip_path_prefix), offset);
166}
167
168void ReportErrorSummary(const char *error_message) {
169  if (!common_flags()->print_summary)
170    return;
171  InternalScopedBuffer<char> buff(kMaxSummaryLength);
172  internal_snprintf(buff.data(), buff.size(),
173                    "SUMMARY: %s: %s", SanitizerToolName, error_message);
174  __sanitizer_report_error_summary(buff.data());
175}
176
177void ReportErrorSummary(const char *error_type, const char *file,
178                        int line, const char *function) {
179  if (!common_flags()->print_summary)
180    return;
181  InternalScopedBuffer<char> buff(kMaxSummaryLength);
182  internal_snprintf(
183      buff.data(), buff.size(), "%s %s:%d %s", error_type,
184      file ? StripPathPrefix(file, common_flags()->strip_path_prefix) : "??",
185      line, function ? function : "??");
186  ReportErrorSummary(buff.data());
187}
188
189void ReportErrorSummary(const char *error_type, StackTrace *stack) {
190  if (!common_flags()->print_summary)
191    return;
192  AddressInfo ai;
193#if !SANITIZER_GO
194  if (stack->size > 0 && Symbolizer::Get()->IsAvailable()) {
195    // Currently, we include the first stack frame into the report summary.
196    // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc).
197    uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]);
198    Symbolizer::Get()->SymbolizeCode(pc, &ai, 1);
199  }
200#endif
201  ReportErrorSummary(error_type, ai.file, ai.line, ai.function);
202}
203
204LoadedModule::LoadedModule(const char *module_name, uptr base_address) {
205  full_name_ = internal_strdup(module_name);
206  base_address_ = base_address;
207  n_ranges_ = 0;
208}
209
210void LoadedModule::addAddressRange(uptr beg, uptr end) {
211  CHECK_LT(n_ranges_, kMaxNumberOfAddressRanges);
212  ranges_[n_ranges_].beg = beg;
213  ranges_[n_ranges_].end = end;
214  n_ranges_++;
215}
216
217bool LoadedModule::containsAddress(uptr address) const {
218  for (uptr i = 0; i < n_ranges_; i++) {
219    if (ranges_[i].beg <= address && address < ranges_[i].end)
220      return true;
221  }
222  return false;
223}
224
225}  // namespace __sanitizer
226
227using namespace __sanitizer;  // NOLINT
228
229extern "C" {
230void __sanitizer_set_report_path(const char *path) {
231  if (!path)
232    return;
233  uptr len = internal_strlen(path);
234  if (len > sizeof(report_path_prefix) - 100) {
235    Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n",
236           path[0], path[1], path[2], path[3],
237           path[4], path[5], path[6], path[7]);
238    Die();
239  }
240  if (report_fd != kStdoutFd &&
241      report_fd != kStderrFd &&
242      report_fd != kInvalidFd)
243    internal_close(report_fd);
244  report_fd = kInvalidFd;
245  log_to_file = false;
246  if (internal_strcmp(path, "stdout") == 0) {
247    report_fd = kStdoutFd;
248  } else if (internal_strcmp(path, "stderr") == 0) {
249    report_fd = kStderrFd;
250  } else {
251    internal_strncpy(report_path_prefix, path, sizeof(report_path_prefix));
252    report_path_prefix[len] = '\0';
253    log_to_file = true;
254  }
255}
256
257void NOINLINE __sanitizer_sandbox_on_notify(void *reserved) {
258  (void)reserved;
259  PrepareForSandboxing();
260}
261
262void __sanitizer_report_error_summary(const char *error_summary) {
263  Printf("%s\n", error_summary);
264}
265}  // extern "C"
266