| //===-- sanitizer_common.cc -----------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file is shared between AddressSanitizer and ThreadSanitizer |
| // run-time libraries. |
| //===----------------------------------------------------------------------===// |
| |
| #include "sanitizer_common.h" |
| #include "sanitizer_allocator_internal.h" |
| #include "sanitizer_flags.h" |
| #include "sanitizer_libc.h" |
| #include "sanitizer_placement_new.h" |
| #include "sanitizer_stacktrace_printer.h" |
| #include "sanitizer_symbolizer.h" |
| |
| namespace __sanitizer { |
| |
| const char *SanitizerToolName = "SanitizerTool"; |
| |
| atomic_uint32_t current_verbosity; |
| |
| uptr GetPageSizeCached() { |
| static uptr PageSize; |
| if (!PageSize) |
| PageSize = GetPageSize(); |
| return PageSize; |
| } |
| |
| StaticSpinMutex report_file_mu; |
| ReportFile report_file = {&report_file_mu, kStderrFd, "", "", 0}; |
| |
| void RawWrite(const char *buffer) { |
| report_file.Write(buffer, internal_strlen(buffer)); |
| } |
| |
| void ReportFile::ReopenIfNecessary() { |
| mu->CheckLocked(); |
| if (fd == kStdoutFd || fd == kStderrFd) return; |
| |
| uptr pid = internal_getpid(); |
| // If in tracer, use the parent's file. |
| if (pid == stoptheworld_tracer_pid) |
| pid = stoptheworld_tracer_ppid; |
| if (fd != kInvalidFd) { |
| // If the report file is already opened by the current process, |
| // do nothing. Otherwise the report file was opened by the parent |
| // process, close it now. |
| if (fd_pid == pid) |
| return; |
| else |
| internal_close(fd); |
| } |
| |
| internal_snprintf(full_path, kMaxPathLength, "%s.%zu", path_prefix, pid); |
| uptr openrv = OpenFile(full_path, WrOnly); |
| if (internal_iserror(openrv)) { |
| const char *ErrorMsgPrefix = "ERROR: Can't open file: "; |
| internal_write(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix)); |
| internal_write(kStderrFd, full_path, internal_strlen(full_path)); |
| Die(); |
| } |
| fd = openrv; |
| fd_pid = pid; |
| } |
| |
| void ReportFile::SetReportPath(const char *path) { |
| if (!path) |
| return; |
| uptr len = internal_strlen(path); |
| if (len > sizeof(path_prefix) - 100) { |
| Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n", |
| path[0], path[1], path[2], path[3], |
| path[4], path[5], path[6], path[7]); |
| Die(); |
| } |
| |
| SpinMutexLock l(mu); |
| if (fd != kStdoutFd && fd != kStderrFd && fd != kInvalidFd) |
| internal_close(fd); |
| fd = kInvalidFd; |
| if (internal_strcmp(path, "stdout") == 0) { |
| fd = kStdoutFd; |
| } else if (internal_strcmp(path, "stderr") == 0) { |
| fd = kStderrFd; |
| } else { |
| internal_snprintf(path_prefix, kMaxPathLength, "%s", path); |
| } |
| } |
| |
| // PID of the tracer task in StopTheWorld. It shares the address space with the |
| // main process, but has a different PID and thus requires special handling. |
| uptr stoptheworld_tracer_pid = 0; |
| // Cached pid of parent process - if the parent process dies, we want to keep |
| // writing to the same log file. |
| uptr stoptheworld_tracer_ppid = 0; |
| |
| static DieCallbackType InternalDieCallback, UserDieCallback; |
| void SetDieCallback(DieCallbackType callback) { |
| InternalDieCallback = callback; |
| } |
| void SetUserDieCallback(DieCallbackType callback) { |
| UserDieCallback = callback; |
| } |
| |
| DieCallbackType GetDieCallback() { |
| return InternalDieCallback; |
| } |
| |
| void NORETURN Die() { |
| if (UserDieCallback) |
| UserDieCallback(); |
| if (InternalDieCallback) |
| InternalDieCallback(); |
| internal__exit(1); |
| } |
| |
| static CheckFailedCallbackType CheckFailedCallback; |
| void SetCheckFailedCallback(CheckFailedCallbackType callback) { |
| CheckFailedCallback = callback; |
| } |
| |
| void NORETURN CheckFailed(const char *file, int line, const char *cond, |
| u64 v1, u64 v2) { |
| if (CheckFailedCallback) { |
| CheckFailedCallback(file, line, cond, v1, v2); |
| } |
| Report("Sanitizer CHECK failed: %s:%d %s (%lld, %lld)\n", file, line, cond, |
| v1, v2); |
| Die(); |
| } |
| |
| uptr ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size, |
| uptr max_len, int *errno_p) { |
| uptr PageSize = GetPageSizeCached(); |
| uptr kMinFileLen = PageSize; |
| uptr read_len = 0; |
| *buff = 0; |
| *buff_size = 0; |
| // The files we usually open are not seekable, so try different buffer sizes. |
| for (uptr size = kMinFileLen; size <= max_len; size *= 2) { |
| uptr openrv = OpenFile(file_name, RdOnly); |
| if (internal_iserror(openrv, errno_p)) return 0; |
| fd_t fd = openrv; |
| UnmapOrDie(*buff, *buff_size); |
| *buff = (char*)MmapOrDie(size, __func__); |
| *buff_size = size; |
| // Read up to one page at a time. |
| read_len = 0; |
| bool reached_eof = false; |
| while (read_len + PageSize <= size) { |
| uptr just_read = internal_read(fd, *buff + read_len, PageSize); |
| if (internal_iserror(just_read, errno_p)) { |
| UnmapOrDie(*buff, *buff_size); |
| return 0; |
| } |
| if (just_read == 0) { |
| reached_eof = true; |
| break; |
| } |
| read_len += just_read; |
| } |
| internal_close(fd); |
| if (reached_eof) // We've read the whole file. |
| break; |
| } |
| return read_len; |
| } |
| |
| typedef bool UptrComparisonFunction(const uptr &a, const uptr &b); |
| |
| template<class T> |
| static inline bool CompareLess(const T &a, const T &b) { |
| return a < b; |
| } |
| |
| void SortArray(uptr *array, uptr size) { |
| InternalSort<uptr*, UptrComparisonFunction>(&array, size, CompareLess); |
| } |
| |
| // We want to map a chunk of address space aligned to 'alignment'. |
| // We do it by maping a bit more and then unmaping redundant pieces. |
| // We probably can do it with fewer syscalls in some OS-dependent way. |
| void *MmapAlignedOrDie(uptr size, uptr alignment, const char *mem_type) { |
| // uptr PageSize = GetPageSizeCached(); |
| CHECK(IsPowerOfTwo(size)); |
| CHECK(IsPowerOfTwo(alignment)); |
| uptr map_size = size + alignment; |
| uptr map_res = (uptr)MmapOrDie(map_size, mem_type); |
| uptr map_end = map_res + map_size; |
| uptr res = map_res; |
| if (res & (alignment - 1)) // Not aligned. |
| res = (map_res + alignment) & ~(alignment - 1); |
| uptr end = res + size; |
| if (res != map_res) |
| UnmapOrDie((void*)map_res, res - map_res); |
| if (end != map_end) |
| UnmapOrDie((void*)end, map_end - end); |
| return (void*)res; |
| } |
| |
| const char *StripPathPrefix(const char *filepath, |
| const char *strip_path_prefix) { |
| if (filepath == 0) return 0; |
| if (strip_path_prefix == 0) return filepath; |
| const char *res = filepath; |
| if (const char *pos = internal_strstr(filepath, strip_path_prefix)) |
| res = pos + internal_strlen(strip_path_prefix); |
| if (res[0] == '.' && res[1] == '/') |
| res += 2; |
| return res; |
| } |
| |
| const char *StripModuleName(const char *module) { |
| if (module == 0) |
| return 0; |
| if (const char *slash_pos = internal_strrchr(module, '/')) |
| return slash_pos + 1; |
| return module; |
| } |
| |
| void ReportErrorSummary(const char *error_message) { |
| if (!common_flags()->print_summary) |
| return; |
| InternalScopedString buff(kMaxSummaryLength); |
| buff.append("SUMMARY: %s: %s", SanitizerToolName, error_message); |
| __sanitizer_report_error_summary(buff.data()); |
| } |
| |
| #ifndef SANITIZER_GO |
| void ReportErrorSummary(const char *error_type, const AddressInfo &info) { |
| if (!common_flags()->print_summary) |
| return; |
| InternalScopedString buff(kMaxSummaryLength); |
| buff.append("%s ", error_type); |
| RenderFrame(&buff, "%L %F", 0, info, common_flags()->strip_path_prefix); |
| ReportErrorSummary(buff.data()); |
| } |
| #endif |
| |
| LoadedModule::LoadedModule(const char *module_name, uptr base_address) { |
| full_name_ = internal_strdup(module_name); |
| base_address_ = base_address; |
| ranges_.clear(); |
| } |
| |
| void LoadedModule::clear() { |
| InternalFree(full_name_); |
| while (!ranges_.empty()) { |
| AddressRange *r = ranges_.front(); |
| ranges_.pop_front(); |
| InternalFree(r); |
| } |
| } |
| |
| void LoadedModule::addAddressRange(uptr beg, uptr end, bool executable) { |
| void *mem = InternalAlloc(sizeof(AddressRange)); |
| AddressRange *r = new(mem) AddressRange(beg, end, executable); |
| ranges_.push_back(r); |
| } |
| |
| bool LoadedModule::containsAddress(uptr address) const { |
| for (Iterator iter = ranges(); iter.hasNext();) { |
| const AddressRange *r = iter.next(); |
| if (r->beg <= address && address < r->end) |
| return true; |
| } |
| return false; |
| } |
| |
| static atomic_uintptr_t g_total_mmaped; |
| |
| void IncreaseTotalMmap(uptr size) { |
| if (!common_flags()->mmap_limit_mb) return; |
| uptr total_mmaped = |
| atomic_fetch_add(&g_total_mmaped, size, memory_order_relaxed) + size; |
| // Since for now mmap_limit_mb is not a user-facing flag, just kill |
| // a program. Use RAW_CHECK to avoid extra mmaps in reporting. |
| RAW_CHECK((total_mmaped >> 20) < common_flags()->mmap_limit_mb); |
| } |
| |
| void DecreaseTotalMmap(uptr size) { |
| if (!common_flags()->mmap_limit_mb) return; |
| atomic_fetch_sub(&g_total_mmaped, size, memory_order_relaxed); |
| } |
| |
| bool TemplateMatch(const char *templ, const char *str) { |
| if (str == 0 || str[0] == 0) |
| return false; |
| bool start = false; |
| if (templ && templ[0] == '^') { |
| start = true; |
| templ++; |
| } |
| bool asterisk = false; |
| while (templ && templ[0]) { |
| if (templ[0] == '*') { |
| templ++; |
| start = false; |
| asterisk = true; |
| continue; |
| } |
| if (templ[0] == '$') |
| return str[0] == 0 || asterisk; |
| if (str[0] == 0) |
| return false; |
| char *tpos = (char*)internal_strchr(templ, '*'); |
| char *tpos1 = (char*)internal_strchr(templ, '$'); |
| if (tpos == 0 || (tpos1 && tpos1 < tpos)) |
| tpos = tpos1; |
| if (tpos != 0) |
| tpos[0] = 0; |
| const char *str0 = str; |
| const char *spos = internal_strstr(str, templ); |
| str = spos + internal_strlen(templ); |
| templ = tpos; |
| if (tpos) |
| tpos[0] = tpos == tpos1 ? '$' : '*'; |
| if (spos == 0) |
| return false; |
| if (start && spos != str0) |
| return false; |
| start = false; |
| asterisk = false; |
| } |
| return true; |
| } |
| |
| } // namespace __sanitizer |
| |
| using namespace __sanitizer; // NOLINT |
| |
| extern "C" { |
| void __sanitizer_set_report_path(const char *path) { |
| report_file.SetReportPath(path); |
| } |
| |
| void __sanitizer_report_error_summary(const char *error_summary) { |
| Printf("%s\n", error_summary); |
| } |
| |
| SANITIZER_INTERFACE_ATTRIBUTE |
| void __sanitizer_set_death_callback(void (*callback)(void)) { |
| SetUserDieCallback(callback); |
| } |
| } // extern "C" |