Alexey Samsonov | 230c3be | 2012-06-06 09:26:25 +0000 | [diff] [blame] | 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" |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 15 | #include "sanitizer_flags.h" |
Alexey Samsonov | 230c3be | 2012-06-06 09:26:25 +0000 | [diff] [blame] | 16 | #include "sanitizer_libc.h" |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 17 | #include "sanitizer_stacktrace.h" |
| 18 | #include "sanitizer_symbolizer.h" |
Alexey Samsonov | 4c49666 | 2012-06-15 07:00:31 +0000 | [diff] [blame] | 19 | |
Alexey Samsonov | 230c3be | 2012-06-06 09:26:25 +0000 | [diff] [blame] | 20 | namespace __sanitizer { |
| 21 | |
Kostya Serebryany | 859778a | 2013-01-31 14:11:21 +0000 | [diff] [blame] | 22 | const char *SanitizerToolName = "SanitizerTool"; |
| 23 | |
Kostya Serebryany | f67ec2b | 2012-11-23 15:38:49 +0000 | [diff] [blame] | 24 | uptr GetPageSizeCached() { |
| 25 | static uptr PageSize; |
| 26 | if (!PageSize) |
| 27 | PageSize = GetPageSize(); |
| 28 | return PageSize; |
| 29 | } |
| 30 | |
Alexander Potapenko | dedba5d | 2013-01-18 16:44:27 +0000 | [diff] [blame] | 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>". |
Peter Collingbourne | 0c547de | 2013-05-17 16:17:19 +0000 | [diff] [blame] | 35 | fd_t report_fd = kStderrFd; |
Reid Kleckner | 923bac7 | 2013-09-05 03:19:57 +0000 | [diff] [blame] | 36 | |
| 37 | // Set via __sanitizer_set_report_path. |
| 38 | bool log_to_file = false; |
| 39 | char report_path_prefix[sizeof(report_path_prefix)]; |
| 40 | |
Alexander Potapenko | dedba5d | 2013-01-18 16:44:27 +0000 | [diff] [blame] | 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|. |
Reid Kleckner | 923bac7 | 2013-09-05 03:19:57 +0000 | [diff] [blame] | 43 | uptr report_fd_pid = 0; |
Kostya Serebryany | 81dfbb7 | 2012-09-14 04:35:14 +0000 | [diff] [blame] | 44 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame^] | 45 | // PID of the tracer task in StopTheWorld. It shares the address space with the |
| 46 | // main process, but has a different PID and thus requires special handling. |
| 47 | uptr stoptheworld_tracer_pid = 0; |
| 48 | // Cached pid of parent process - if the parent process dies, we want to keep |
| 49 | // writing to the same log file. |
| 50 | uptr stoptheworld_tracer_ppid = 0; |
| 51 | |
Sergey Matveev | 90629fb | 2013-08-26 13:20:31 +0000 | [diff] [blame] | 52 | static DieCallbackType DieCallback; |
| 53 | void SetDieCallback(DieCallbackType callback) { |
Alexey Samsonov | 591616d | 2012-09-11 09:44:48 +0000 | [diff] [blame] | 54 | DieCallback = callback; |
| 55 | } |
| 56 | |
Sergey Matveev | 90629fb | 2013-08-26 13:20:31 +0000 | [diff] [blame] | 57 | DieCallbackType GetDieCallback() { |
| 58 | return DieCallback; |
| 59 | } |
| 60 | |
Alexey Samsonov | 591616d | 2012-09-11 09:44:48 +0000 | [diff] [blame] | 61 | void NORETURN Die() { |
| 62 | if (DieCallback) { |
| 63 | DieCallback(); |
| 64 | } |
Alexey Samsonov | f882247 | 2013-02-20 13:54:32 +0000 | [diff] [blame] | 65 | internal__exit(1); |
Alexey Samsonov | 591616d | 2012-09-11 09:44:48 +0000 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | static CheckFailedCallbackType CheckFailedCallback; |
| 69 | void SetCheckFailedCallback(CheckFailedCallbackType callback) { |
| 70 | CheckFailedCallback = callback; |
| 71 | } |
| 72 | |
| 73 | void NORETURN CheckFailed(const char *file, int line, const char *cond, |
| 74 | u64 v1, u64 v2) { |
| 75 | if (CheckFailedCallback) { |
| 76 | CheckFailedCallback(file, line, cond, v1, v2); |
| 77 | } |
Dmitry Vyukov | e3c35c7 | 2013-01-11 15:07:49 +0000 | [diff] [blame] | 78 | Report("Sanitizer CHECK failed: %s:%d %s (%lld, %lld)\n", file, line, cond, |
| 79 | v1, v2); |
Alexey Samsonov | 591616d | 2012-09-11 09:44:48 +0000 | [diff] [blame] | 80 | Die(); |
| 81 | } |
| 82 | |
Alexey Samsonov | cffe2f5 | 2012-06-07 05:38:26 +0000 | [diff] [blame] | 83 | uptr ReadFileToBuffer(const char *file_name, char **buff, |
| 84 | uptr *buff_size, uptr max_len) { |
Kostya Serebryany | f67ec2b | 2012-11-23 15:38:49 +0000 | [diff] [blame] | 85 | uptr PageSize = GetPageSizeCached(); |
| 86 | uptr kMinFileLen = PageSize; |
Alexey Samsonov | cffe2f5 | 2012-06-07 05:38:26 +0000 | [diff] [blame] | 87 | uptr read_len = 0; |
| 88 | *buff = 0; |
| 89 | *buff_size = 0; |
| 90 | // The files we usually open are not seekable, so try different buffer sizes. |
| 91 | for (uptr size = kMinFileLen; size <= max_len; size *= 2) { |
Peter Collingbourne | 9578a3e | 2013-05-08 14:43:49 +0000 | [diff] [blame] | 92 | uptr openrv = OpenFile(file_name, /*write*/ false); |
| 93 | if (internal_iserror(openrv)) return 0; |
| 94 | fd_t fd = openrv; |
Alexey Samsonov | cffe2f5 | 2012-06-07 05:38:26 +0000 | [diff] [blame] | 95 | UnmapOrDie(*buff, *buff_size); |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame^] | 96 | *buff = (char*)MmapOrDie(size, __func__); |
Alexey Samsonov | cffe2f5 | 2012-06-07 05:38:26 +0000 | [diff] [blame] | 97 | *buff_size = size; |
| 98 | // Read up to one page at a time. |
| 99 | read_len = 0; |
| 100 | bool reached_eof = false; |
Kostya Serebryany | f67ec2b | 2012-11-23 15:38:49 +0000 | [diff] [blame] | 101 | while (read_len + PageSize <= size) { |
| 102 | uptr just_read = internal_read(fd, *buff + read_len, PageSize); |
Alexey Samsonov | cffe2f5 | 2012-06-07 05:38:26 +0000 | [diff] [blame] | 103 | if (just_read == 0) { |
| 104 | reached_eof = true; |
| 105 | break; |
| 106 | } |
| 107 | read_len += just_read; |
| 108 | } |
| 109 | internal_close(fd); |
| 110 | if (reached_eof) // We've read the whole file. |
| 111 | break; |
| 112 | } |
| 113 | return read_len; |
| 114 | } |
| 115 | |
Sergey Matveev | 15bb32b | 2013-05-13 11:58:48 +0000 | [diff] [blame] | 116 | typedef bool UptrComparisonFunction(const uptr &a, const uptr &b); |
| 117 | |
| 118 | template<class T> |
| 119 | static inline bool CompareLess(const T &a, const T &b) { |
| 120 | return a < b; |
| 121 | } |
| 122 | |
Alexey Samsonov | 4c49666 | 2012-06-15 07:00:31 +0000 | [diff] [blame] | 123 | void SortArray(uptr *array, uptr size) { |
Sergey Matveev | 15bb32b | 2013-05-13 11:58:48 +0000 | [diff] [blame] | 124 | InternalSort<uptr*, UptrComparisonFunction>(&array, size, CompareLess); |
Alexey Samsonov | 4c49666 | 2012-06-15 07:00:31 +0000 | [diff] [blame] | 125 | } |
| 126 | |
Kostya Serebryany | cc75259 | 2012-12-06 06:10:31 +0000 | [diff] [blame] | 127 | // We want to map a chunk of address space aligned to 'alignment'. |
| 128 | // We do it by maping a bit more and then unmaping redundant pieces. |
| 129 | // We probably can do it with fewer syscalls in some OS-dependent way. |
| 130 | void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) { |
Bill Wendling | 2dae63a | 2012-12-06 07:43:17 +0000 | [diff] [blame] | 131 | // uptr PageSize = GetPageSizeCached(); |
Kostya Serebryany | cc75259 | 2012-12-06 06:10:31 +0000 | [diff] [blame] | 132 | CHECK(IsPowerOfTwo(size)); |
| 133 | CHECK(IsPowerOfTwo(alignment)); |
| 134 | uptr map_size = size + alignment; |
| 135 | uptr map_res = (uptr)MmapOrDie(map_size, mem_type); |
| 136 | uptr map_end = map_res + map_size; |
| 137 | uptr res = map_res; |
| 138 | if (res & (alignment - 1)) // Not aligned. |
Dmitry Vyukov | 3617ad7 | 2012-12-06 15:42:54 +0000 | [diff] [blame] | 139 | res = (map_res + alignment) & ~(alignment - 1); |
Kostya Serebryany | cc75259 | 2012-12-06 06:10:31 +0000 | [diff] [blame] | 140 | uptr end = res + size; |
| 141 | if (res != map_res) |
| 142 | UnmapOrDie((void*)map_res, res - map_res); |
| 143 | if (end != map_end) |
| 144 | UnmapOrDie((void*)end, map_end - end); |
| 145 | return (void*)res; |
| 146 | } |
| 147 | |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 148 | const char *StripPathPrefix(const char *filepath, |
| 149 | const char *strip_path_prefix) { |
| 150 | if (filepath == 0) return 0; |
| 151 | if (strip_path_prefix == 0) return filepath; |
| 152 | const char *pos = internal_strstr(filepath, strip_path_prefix); |
| 153 | if (pos == 0) return filepath; |
| 154 | pos += internal_strlen(strip_path_prefix); |
| 155 | if (pos[0] == '.' && pos[1] == '/') |
| 156 | pos += 2; |
| 157 | return pos; |
| 158 | } |
| 159 | |
Alexey Samsonov | bb4697f | 2013-11-14 09:41:24 +0000 | [diff] [blame] | 160 | void PrintSourceLocation(InternalScopedString *buffer, const char *file, |
| 161 | int line, int column) { |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 162 | CHECK(file); |
Alexey Samsonov | bb4697f | 2013-11-14 09:41:24 +0000 | [diff] [blame] | 163 | buffer->append("%s", |
| 164 | StripPathPrefix(file, common_flags()->strip_path_prefix)); |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 165 | if (line > 0) { |
Alexey Samsonov | bb4697f | 2013-11-14 09:41:24 +0000 | [diff] [blame] | 166 | buffer->append(":%d", line); |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 167 | if (column > 0) |
Alexey Samsonov | bb4697f | 2013-11-14 09:41:24 +0000 | [diff] [blame] | 168 | buffer->append(":%d", column); |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 169 | } |
| 170 | } |
| 171 | |
Alexey Samsonov | bb4697f | 2013-11-14 09:41:24 +0000 | [diff] [blame] | 172 | void PrintModuleAndOffset(InternalScopedString *buffer, const char *module, |
| 173 | uptr offset) { |
| 174 | buffer->append("(%s+0x%zx)", |
| 175 | StripPathPrefix(module, common_flags()->strip_path_prefix), |
| 176 | offset); |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 177 | } |
| 178 | |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 179 | void ReportErrorSummary(const char *error_message) { |
Alexey Samsonov | 694d856 | 2013-11-14 08:56:59 +0000 | [diff] [blame] | 180 | if (!common_flags()->print_summary) |
| 181 | return; |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 182 | InternalScopedBuffer<char> buff(kMaxSummaryLength); |
| 183 | internal_snprintf(buff.data(), buff.size(), |
| 184 | "SUMMARY: %s: %s", SanitizerToolName, error_message); |
| 185 | __sanitizer_report_error_summary(buff.data()); |
| 186 | } |
| 187 | |
Kostya Serebryany | 2673fd8 | 2013-02-06 12:36:49 +0000 | [diff] [blame] | 188 | void ReportErrorSummary(const char *error_type, const char *file, |
| 189 | int line, const char *function) { |
Alexey Samsonov | 694d856 | 2013-11-14 08:56:59 +0000 | [diff] [blame] | 190 | if (!common_flags()->print_summary) |
| 191 | return; |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 192 | InternalScopedBuffer<char> buff(kMaxSummaryLength); |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 193 | internal_snprintf( |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 194 | buff.data(), buff.size(), "%s %s:%d %s", error_type, |
Alexey Samsonov | 90b0f1e | 2013-10-04 08:55:03 +0000 | [diff] [blame] | 195 | file ? StripPathPrefix(file, common_flags()->strip_path_prefix) : "??", |
| 196 | line, function ? function : "??"); |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 197 | ReportErrorSummary(buff.data()); |
| 198 | } |
| 199 | |
| 200 | void ReportErrorSummary(const char *error_type, StackTrace *stack) { |
Alexey Samsonov | 694d856 | 2013-11-14 08:56:59 +0000 | [diff] [blame] | 201 | if (!common_flags()->print_summary) |
| 202 | return; |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 203 | AddressInfo ai; |
Alexey Samsonov | 50cdc5a | 2013-11-01 18:00:22 +0000 | [diff] [blame] | 204 | #if !SANITIZER_GO |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame^] | 205 | if (stack->size > 0 && Symbolizer::Get()->CanReturnFileLineInfo()) { |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 206 | // Currently, we include the first stack frame into the report summary. |
| 207 | // Maybe sometimes we need to choose another frame (e.g. skip memcpy/etc). |
| 208 | uptr pc = StackTrace::GetPreviousInstructionPc(stack->trace[0]); |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame^] | 209 | Symbolizer::Get()->SymbolizePC(pc, &ai, 1); |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 210 | } |
Alexey Samsonov | 50cdc5a | 2013-11-01 18:00:22 +0000 | [diff] [blame] | 211 | #endif |
Alexey Samsonov | 2fb0872 | 2013-11-01 17:02:14 +0000 | [diff] [blame] | 212 | ReportErrorSummary(error_type, ai.file, ai.line, ai.function); |
Kostya Serebryany | 2673fd8 | 2013-02-06 12:36:49 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Alexey Samsonov | 7847d77 | 2013-09-10 14:36:16 +0000 | [diff] [blame] | 215 | LoadedModule::LoadedModule(const char *module_name, uptr base_address) { |
| 216 | full_name_ = internal_strdup(module_name); |
| 217 | base_address_ = base_address; |
| 218 | n_ranges_ = 0; |
| 219 | } |
| 220 | |
| 221 | void LoadedModule::addAddressRange(uptr beg, uptr end) { |
| 222 | CHECK_LT(n_ranges_, kMaxNumberOfAddressRanges); |
| 223 | ranges_[n_ranges_].beg = beg; |
| 224 | ranges_[n_ranges_].end = end; |
| 225 | n_ranges_++; |
| 226 | } |
| 227 | |
| 228 | bool LoadedModule::containsAddress(uptr address) const { |
| 229 | for (uptr i = 0; i < n_ranges_; i++) { |
| 230 | if (ranges_[i].beg <= address && address < ranges_[i].end) |
| 231 | return true; |
| 232 | } |
| 233 | return false; |
| 234 | } |
| 235 | |
Bob Wilson | dbd69cc | 2013-11-15 07:18:15 +0000 | [diff] [blame] | 236 | char *StripModuleName(const char *module) { |
| 237 | if (module == 0) |
| 238 | return 0; |
| 239 | const char *short_module_name = internal_strrchr(module, '/'); |
| 240 | if (short_module_name) |
| 241 | short_module_name += 1; |
| 242 | else |
| 243 | short_module_name = module; |
| 244 | return internal_strdup(short_module_name); |
| 245 | } |
| 246 | |
Stephen Hines | 2d1fdb2 | 2014-05-28 23:58:16 -0700 | [diff] [blame^] | 247 | static atomic_uintptr_t g_total_mmaped; |
| 248 | |
| 249 | void IncreaseTotalMmap(uptr size) { |
| 250 | if (!common_flags()->mmap_limit_mb) return; |
| 251 | uptr total_mmaped = |
| 252 | atomic_fetch_add(&g_total_mmaped, size, memory_order_relaxed) + size; |
| 253 | if ((total_mmaped >> 20) > common_flags()->mmap_limit_mb) { |
| 254 | // Since for now mmap_limit_mb is not a user-facing flag, just CHECK. |
| 255 | uptr mmap_limit_mb = common_flags()->mmap_limit_mb; |
| 256 | common_flags()->mmap_limit_mb = 0; // Allow mmap in CHECK. |
| 257 | RAW_CHECK(total_mmaped >> 20 < mmap_limit_mb); |
| 258 | } |
| 259 | } |
| 260 | |
| 261 | void DecreaseTotalMmap(uptr size) { |
| 262 | if (!common_flags()->mmap_limit_mb) return; |
| 263 | atomic_fetch_sub(&g_total_mmaped, size, memory_order_relaxed); |
| 264 | } |
| 265 | |
Alexey Samsonov | 230c3be | 2012-06-06 09:26:25 +0000 | [diff] [blame] | 266 | } // namespace __sanitizer |
Kostya Serebryany | 81dfbb7 | 2012-09-14 04:35:14 +0000 | [diff] [blame] | 267 | |
Alexey Samsonov | ac8564e | 2012-11-02 09:23:36 +0000 | [diff] [blame] | 268 | using namespace __sanitizer; // NOLINT |
| 269 | |
| 270 | extern "C" { |
Kostya Serebryany | 81dfbb7 | 2012-09-14 04:35:14 +0000 | [diff] [blame] | 271 | void __sanitizer_set_report_path(const char *path) { |
Dmitry Vyukov | b48c2b2 | 2013-10-15 12:25:29 +0000 | [diff] [blame] | 272 | if (!path) |
| 273 | return; |
Kostya Serebryany | 81dfbb7 | 2012-09-14 04:35:14 +0000 | [diff] [blame] | 274 | uptr len = internal_strlen(path); |
Alexander Potapenko | dedba5d | 2013-01-18 16:44:27 +0000 | [diff] [blame] | 275 | if (len > sizeof(report_path_prefix) - 100) { |
Kostya Serebryany | 81dfbb7 | 2012-09-14 04:35:14 +0000 | [diff] [blame] | 276 | Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n", |
| 277 | path[0], path[1], path[2], path[3], |
| 278 | path[4], path[5], path[6], path[7]); |
| 279 | Die(); |
| 280 | } |
Alexey Samsonov | f3457cb | 2012-11-02 09:38:47 +0000 | [diff] [blame] | 281 | if (report_fd != kStdoutFd && |
| 282 | report_fd != kStderrFd && |
| 283 | report_fd != kInvalidFd) |
| 284 | internal_close(report_fd); |
Dmitry Vyukov | b48c2b2 | 2013-10-15 12:25:29 +0000 | [diff] [blame] | 285 | report_fd = kInvalidFd; |
| 286 | log_to_file = false; |
| 287 | if (internal_strcmp(path, "stdout") == 0) { |
| 288 | report_fd = kStdoutFd; |
| 289 | } else if (internal_strcmp(path, "stderr") == 0) { |
| 290 | report_fd = kStderrFd; |
| 291 | } else { |
| 292 | internal_strncpy(report_path_prefix, path, sizeof(report_path_prefix)); |
| 293 | report_path_prefix[len] = '\0'; |
| 294 | log_to_file = true; |
| 295 | } |
Alexey Samsonov | ac8564e | 2012-11-02 09:23:36 +0000 | [diff] [blame] | 296 | } |
Alexander Potapenko | 2574257 | 2012-12-10 13:10:40 +0000 | [diff] [blame] | 297 | |
Kostya Serebryany | 2673fd8 | 2013-02-06 12:36:49 +0000 | [diff] [blame] | 298 | void __sanitizer_report_error_summary(const char *error_summary) { |
Nick Lewycky | 47fcd76 | 2013-10-23 07:45:53 +0000 | [diff] [blame] | 299 | Printf("%s\n", error_summary); |
Kostya Serebryany | 2673fd8 | 2013-02-06 12:36:49 +0000 | [diff] [blame] | 300 | } |
Alexey Samsonov | ac8564e | 2012-11-02 09:23:36 +0000 | [diff] [blame] | 301 | } // extern "C" |