• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_libc.h"
16 
17 namespace __sanitizer {
18 
19 const char *SanitizerToolName = "SanitizerTool";
20 uptr SanitizerVerbosity = 0;
21 
GetPageSizeCached()22 uptr GetPageSizeCached() {
23   static uptr PageSize;
24   if (!PageSize)
25     PageSize = GetPageSize();
26   return PageSize;
27 }
28 
29 static bool log_to_file = false;  // Set to true by __sanitizer_set_report_path
30 
31 // By default, dump to stderr. If |log_to_file| is true and |report_fd_pid|
32 // isn't equal to the current PID, try to obtain file descriptor by opening
33 // file "report_path_prefix.<PID>".
34 static fd_t report_fd = kStderrFd;
35 static char report_path_prefix[4096];  // Set via __sanitizer_set_report_path.
36 // PID of process that opened |report_fd|. If a fork() occurs, the PID of the
37 // child thread will be different from |report_fd_pid|.
38 static int report_fd_pid = 0;
39 
40 static void (*DieCallback)(void);
SetDieCallback(void (* callback)(void))41 void SetDieCallback(void (*callback)(void)) {
42   DieCallback = callback;
43 }
44 
Die()45 void NORETURN Die() {
46   if (DieCallback) {
47     DieCallback();
48   }
49   internal__exit(1);
50 }
51 
52 static CheckFailedCallbackType CheckFailedCallback;
SetCheckFailedCallback(CheckFailedCallbackType callback)53 void SetCheckFailedCallback(CheckFailedCallbackType callback) {
54   CheckFailedCallback = callback;
55 }
56 
CheckFailed(const char * file,int line,const char * cond,u64 v1,u64 v2)57 void NORETURN CheckFailed(const char *file, int line, const char *cond,
58                           u64 v1, u64 v2) {
59   if (CheckFailedCallback) {
60     CheckFailedCallback(file, line, cond, v1, v2);
61   }
62   Report("Sanitizer CHECK failed: %s:%d %s (%lld, %lld)\n", file, line, cond,
63                                                             v1, v2);
64   Die();
65 }
66 
MaybeOpenReportFile()67 static void MaybeOpenReportFile() {
68   if (!log_to_file || (report_fd_pid == GetPid())) return;
69   InternalScopedBuffer<char> report_path_full(4096);
70   internal_snprintf(report_path_full.data(), report_path_full.size(),
71                     "%s.%d", report_path_prefix, GetPid());
72   fd_t fd = OpenFile(report_path_full.data(), true);
73   if (fd == kInvalidFd) {
74     report_fd = kStderrFd;
75     log_to_file = false;
76     Report("ERROR: Can't open file: %s\n", report_path_full.data());
77     Die();
78   }
79   if (report_fd != kInvalidFd) {
80     // We're in the child. Close the parent's log.
81     internal_close(report_fd);
82   }
83   report_fd = fd;
84   report_fd_pid = GetPid();
85 }
86 
PrintsToTty()87 bool PrintsToTty() {
88   MaybeOpenReportFile();
89   return internal_isatty(report_fd);
90 }
91 
RawWrite(const char * buffer)92 void RawWrite(const char *buffer) {
93   static const char *kRawWriteError = "RawWrite can't output requested buffer!";
94   uptr length = (uptr)internal_strlen(buffer);
95   MaybeOpenReportFile();
96   if (length != internal_write(report_fd, buffer, length)) {
97     internal_write(report_fd, kRawWriteError, internal_strlen(kRawWriteError));
98     Die();
99   }
100 }
101 
ReadFileToBuffer(const char * file_name,char ** buff,uptr * buff_size,uptr max_len)102 uptr ReadFileToBuffer(const char *file_name, char **buff,
103                       uptr *buff_size, uptr max_len) {
104   uptr PageSize = GetPageSizeCached();
105   uptr kMinFileLen = PageSize;
106   uptr read_len = 0;
107   *buff = 0;
108   *buff_size = 0;
109   // The files we usually open are not seekable, so try different buffer sizes.
110   for (uptr size = kMinFileLen; size <= max_len; size *= 2) {
111     fd_t fd = OpenFile(file_name, /*write*/ false);
112     if (fd == kInvalidFd) return 0;
113     UnmapOrDie(*buff, *buff_size);
114     *buff = (char*)MmapOrDie(size, __FUNCTION__);
115     *buff_size = size;
116     // Read up to one page at a time.
117     read_len = 0;
118     bool reached_eof = false;
119     while (read_len + PageSize <= size) {
120       uptr just_read = internal_read(fd, *buff + read_len, PageSize);
121       if (just_read == 0) {
122         reached_eof = true;
123         break;
124       }
125       read_len += just_read;
126     }
127     internal_close(fd);
128     if (reached_eof)  // We've read the whole file.
129       break;
130   }
131   return read_len;
132 }
133 
134 // We don't want to use std::sort to avoid including <algorithm>, as
135 // we may end up with two implementation of std::sort - one in instrumented
136 // code, and the other in runtime.
137 // qsort() from stdlib won't work as it calls malloc(), which results
138 // in deadlock in ASan allocator.
139 // We re-implement in-place sorting w/o recursion as straightforward heapsort.
SortArray(uptr * array,uptr size)140 void SortArray(uptr *array, uptr size) {
141   if (size < 2)
142     return;
143   // Stage 1: insert elements to the heap.
144   for (uptr i = 1; i < size; i++) {
145     uptr j, p;
146     for (j = i; j > 0; j = p) {
147       p = (j - 1) / 2;
148       if (array[j] > array[p])
149         Swap(array[j], array[p]);
150       else
151         break;
152     }
153   }
154   // Stage 2: swap largest element with the last one,
155   // and sink the new top.
156   for (uptr i = size - 1; i > 0; i--) {
157     Swap(array[0], array[i]);
158     uptr j, max_ind;
159     for (j = 0; j < i; j = max_ind) {
160       uptr left = 2 * j + 1;
161       uptr right = 2 * j + 2;
162       max_ind = j;
163       if (left < i && array[left] > array[max_ind])
164         max_ind = left;
165       if (right < i && array[right] > array[max_ind])
166         max_ind = right;
167       if (max_ind != j)
168         Swap(array[j], array[max_ind]);
169       else
170         break;
171     }
172   }
173 }
174 
175 // We want to map a chunk of address space aligned to 'alignment'.
176 // We do it by maping a bit more and then unmaping redundant pieces.
177 // We probably can do it with fewer syscalls in some OS-dependent way.
MmapAlignedOrDie(uptr size,uptr alignment,const char * mem_type)178 void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) {
179 // uptr PageSize = GetPageSizeCached();
180   CHECK(IsPowerOfTwo(size));
181   CHECK(IsPowerOfTwo(alignment));
182   uptr map_size = size + alignment;
183   uptr map_res = (uptr)MmapOrDie(map_size, mem_type);
184   uptr map_end = map_res + map_size;
185   uptr res = map_res;
186   if (res & (alignment - 1))  // Not aligned.
187     res = (map_res + alignment) & ~(alignment - 1);
188   uptr end = res + size;
189   if (res != map_res)
190     UnmapOrDie((void*)map_res, res - map_res);
191   if (end != map_end)
192     UnmapOrDie((void*)end, map_end - end);
193   return (void*)res;
194 }
195 
ReportErrorSummary(const char * error_type,const char * file,int line,const char * function)196 void ReportErrorSummary(const char *error_type, const char *file,
197                         int line, const char *function) {
198   const int kMaxSize = 1024;  // We don't want a summary too long.
199   InternalScopedBuffer<char> buff(kMaxSize);
200   internal_snprintf(buff.data(), kMaxSize, "%s: %s %s:%d %s",
201                     SanitizerToolName, error_type,
202                     file ? file : "??", line, function ? function : "??");
203   __sanitizer_report_error_summary(buff.data());
204 }
205 
206 }  // namespace __sanitizer
207 
208 using namespace __sanitizer;  // NOLINT
209 
210 extern "C" {
__sanitizer_set_report_path(const char * path)211 void __sanitizer_set_report_path(const char *path) {
212   if (!path) return;
213   uptr len = internal_strlen(path);
214   if (len > sizeof(report_path_prefix) - 100) {
215     Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n",
216            path[0], path[1], path[2], path[3],
217            path[4], path[5], path[6], path[7]);
218     Die();
219   }
220   internal_strncpy(report_path_prefix, path, sizeof(report_path_prefix));
221   report_path_prefix[len] = '\0';
222   report_fd = kInvalidFd;
223   log_to_file = true;
224 }
225 
__sanitizer_set_report_fd(int fd)226 void __sanitizer_set_report_fd(int fd) {
227   if (report_fd != kStdoutFd &&
228       report_fd != kStderrFd &&
229       report_fd != kInvalidFd)
230     internal_close(report_fd);
231   report_fd = fd;
232 }
233 
__sanitizer_sandbox_on_notify(void * reserved)234 void NOINLINE __sanitizer_sandbox_on_notify(void *reserved) {
235   (void)reserved;
236   PrepareForSandboxing();
237 }
238 
__sanitizer_report_error_summary(const char * error_summary)239 void __sanitizer_report_error_summary(const char *error_summary) {
240   Printf("SUMMARY: %s\n", error_summary);
241 }
242 }  // extern "C"
243