// Copyright 2018 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // This library provides Symbolize() function that symbolizes program // counters to their corresponding symbol names on linux platforms. // This library has a minimal implementation of an ELF symbol table // reader (i.e. it doesn't depend on libelf, etc.). // // The algorithm used in Symbolize() is as follows. // // 1. Go through a list of maps in /proc/self/maps and find the map // containing the program counter. // // 2. Open the mapped file and find a regular symbol table inside. // Iterate over symbols in the symbol table and look for the symbol // containing the program counter. If such a symbol is found, // obtain the symbol name, and demangle the symbol if possible. // If the symbol isn't found in the regular symbol table (binary is // stripped), try the same thing with a dynamic symbol table. // // Note that Symbolize() is originally implemented to be used in // signal handlers, hence it doesn't use malloc() and other unsafe // operations. It should be both thread-safe and async-signal-safe. // // Implementation note: // // We don't use heaps but only use stacks. We want to reduce the // stack consumption so that the symbolizer can run on small stacks. // // Here are some numbers collected with GCC 4.1.0 on x86: // - sizeof(Elf32_Sym) = 16 // - sizeof(Elf32_Shdr) = 40 // - sizeof(Elf64_Sym) = 24 // - sizeof(Elf64_Shdr) = 64 // // This implementation is intended to be async-signal-safe but uses some // functions which are not guaranteed to be so, such as memchr() and // memmove(). We assume they are async-signal-safe. #include <dlfcn.h> #include <elf.h> #include <fcntl.h> #include <link.h> // For ElfW() macro. #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <algorithm> #include <array> #include <atomic> #include <cerrno> #include <cinttypes> #include <climits> #include <cstdint> #include <cstdio> #include <cstdlib> #include <cstring> #include "absl/base/casts.h" #include "absl/base/dynamic_annotations.h" #include "absl/base/internal/low_level_alloc.h" #include "absl/base/internal/raw_logging.h" #include "absl/base/internal/spinlock.h" #include "absl/base/port.h" #include "absl/debugging/internal/demangle.h" #include "absl/debugging/internal/vdso_support.h" #include "absl/strings/string_view.h" #if defined(__FreeBSD__) && !defined(ElfW) #define ElfW(x) __ElfN(x) #endif namespace absl { ABSL_NAMESPACE_BEGIN // Value of argv[0]. Used by MaybeInitializeObjFile(). static char *argv0_value = nullptr; void InitializeSymbolizer(const char *argv0) { #ifdef ABSL_HAVE_VDSO_SUPPORT // We need to make sure VDSOSupport::Init() is called before any setuid or // chroot calls, so InitializeSymbolizer() should be called very early in the // life of a program. absl::debugging_internal::VDSOSupport::Init(); #endif if (argv0_value != nullptr) { free(argv0_value); argv0_value = nullptr; } if (argv0 != nullptr && argv0[0] != '\0') { argv0_value = strdup(argv0); } } namespace debugging_internal { namespace { // Re-runs fn until it doesn't cause EINTR. #define NO_INTR(fn) \ do { \ } while ((fn) < 0 && errno == EINTR) // On Linux, ELF_ST_* are defined in <linux/elf.h>. To make this portable // we define our own ELF_ST_BIND and ELF_ST_TYPE if not available. #ifndef ELF_ST_BIND #define ELF_ST_BIND(info) (((unsigned char)(info)) >> 4) #endif #ifndef ELF_ST_TYPE #define ELF_ST_TYPE(info) (((unsigned char)(info)) & 0xF) #endif // Some platforms use a special .opd section to store function pointers. const char kOpdSectionName[] = ".opd"; #if (defined(__powerpc__) && !(_CALL_ELF > 1)) || defined(__ia64) // Use opd section for function descriptors on these platforms, the function // address is the first word of the descriptor. enum { kPlatformUsesOPDSections = 1 }; #else // not PPC or IA64 enum { kPlatformUsesOPDSections = 0 }; #endif // This works for PowerPC & IA64 only. A function descriptor consist of two // pointers and the first one is the function's entry. const size_t kFunctionDescriptorSize = sizeof(void *) * 2; const int kMaxDecorators = 10; // Seems like a reasonable upper limit. struct InstalledSymbolDecorator { SymbolDecorator fn; void *arg; int ticket; }; int g_num_decorators; InstalledSymbolDecorator g_decorators[kMaxDecorators]; struct FileMappingHint { const void *start; const void *end; uint64_t offset; const char *filename; }; // Protects g_decorators. // We are using SpinLock and not a Mutex here, because we may be called // from inside Mutex::Lock itself, and it prohibits recursive calls. // This happens in e.g. base/stacktrace_syscall_unittest. // Moreover, we are using only TryLock(), if the decorator list // is being modified (is busy), we skip all decorators, and possibly // loose some info. Sorry, that's the best we could do. ABSL_CONST_INIT absl::base_internal::SpinLock g_decorators_mu( absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY); const int kMaxFileMappingHints = 8; int g_num_file_mapping_hints; FileMappingHint g_file_mapping_hints[kMaxFileMappingHints]; // Protects g_file_mapping_hints. ABSL_CONST_INIT absl::base_internal::SpinLock g_file_mapping_mu( absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY); // Async-signal-safe function to zero a buffer. // memset() is not guaranteed to be async-signal-safe. static void SafeMemZero(void* p, size_t size) { unsigned char *c = static_cast<unsigned char *>(p); while (size--) { *c++ = 0; } } struct ObjFile { ObjFile() : filename(nullptr), start_addr(nullptr), end_addr(nullptr), offset(0), fd(-1), elf_type(-1) { SafeMemZero(&elf_header, sizeof(elf_header)); SafeMemZero(&phdr[0], sizeof(phdr)); } char *filename; const void *start_addr; const void *end_addr; uint64_t offset; // The following fields are initialized on the first access to the // object file. int fd; int elf_type; ElfW(Ehdr) elf_header; // PT_LOAD program header describing executable code. // Normally we expect just one, but SWIFT binaries have two. std::array<ElfW(Phdr), 2> phdr; }; // Build 4-way associative cache for symbols. Within each cache line, symbols // are replaced in LRU order. enum { ASSOCIATIVITY = 4, }; struct SymbolCacheLine { const void *pc[ASSOCIATIVITY]; char *name[ASSOCIATIVITY]; // age[i] is incremented when a line is accessed. it's reset to zero if the // i'th entry is read. uint32_t age[ASSOCIATIVITY]; }; // --------------------------------------------------------------- // An async-signal-safe arena for LowLevelAlloc static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena; static base_internal::LowLevelAlloc::Arena *SigSafeArena() { return g_sig_safe_arena.load(std::memory_order_acquire); } static void InitSigSafeArena() { if (SigSafeArena() == nullptr) { base_internal::LowLevelAlloc::Arena *new_arena = base_internal::LowLevelAlloc::NewArena( base_internal::LowLevelAlloc::kAsyncSignalSafe); base_internal::LowLevelAlloc::Arena *old_value = nullptr; if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena, std::memory_order_release, std::memory_order_relaxed)) { // We lost a race to allocate an arena; deallocate. base_internal::LowLevelAlloc::DeleteArena(new_arena); } } } // --------------------------------------------------------------- // An AddrMap is a vector of ObjFile, using SigSafeArena() for allocation. class AddrMap { public: AddrMap() : size_(0), allocated_(0), obj_(nullptr) {} ~AddrMap() { base_internal::LowLevelAlloc::Free(obj_); } int Size() const { return size_; } ObjFile *At(int i) { return &obj_[i]; } ObjFile *Add(); void Clear(); private: int size_; // count of valid elements (<= allocated_) int allocated_; // count of allocated elements ObjFile *obj_; // array of allocated_ elements AddrMap(const AddrMap &) = delete; AddrMap &operator=(const AddrMap &) = delete; }; void AddrMap::Clear() { for (int i = 0; i != size_; i++) { At(i)->~ObjFile(); } size_ = 0; } ObjFile *AddrMap::Add() { if (size_ == allocated_) { int new_allocated = allocated_ * 2 + 50; ObjFile *new_obj_ = static_cast<ObjFile *>(base_internal::LowLevelAlloc::AllocWithArena( new_allocated * sizeof(*new_obj_), SigSafeArena())); if (obj_) { memcpy(new_obj_, obj_, allocated_ * sizeof(*new_obj_)); base_internal::LowLevelAlloc::Free(obj_); } obj_ = new_obj_; allocated_ = new_allocated; } return new (&obj_[size_++]) ObjFile; } // --------------------------------------------------------------- enum FindSymbolResult { SYMBOL_NOT_FOUND = 1, SYMBOL_TRUNCATED, SYMBOL_FOUND }; class Symbolizer { public: Symbolizer(); ~Symbolizer(); const char *GetSymbol(const void *const pc); private: char *CopyString(const char *s) { int len = strlen(s); char *dst = static_cast<char *>( base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena())); ABSL_RAW_CHECK(dst != nullptr, "out of memory"); memcpy(dst, s, len + 1); return dst; } ObjFile *FindObjFile(const void *const start, size_t size) ABSL_ATTRIBUTE_NOINLINE; static bool RegisterObjFile(const char *filename, const void *const start_addr, const void *const end_addr, uint64_t offset, void *arg); SymbolCacheLine *GetCacheLine(const void *const pc); const char *FindSymbolInCache(const void *const pc); const char *InsertSymbolInCache(const void *const pc, const char *name); void AgeSymbols(SymbolCacheLine *line); void ClearAddrMap(); FindSymbolResult GetSymbolFromObjectFile(const ObjFile &obj, const void *const pc, const ptrdiff_t relocation, char *out, int out_size, char *tmp_buf, int tmp_buf_size); enum { SYMBOL_BUF_SIZE = 3072, TMP_BUF_SIZE = 1024, SYMBOL_CACHE_LINES = 128, }; AddrMap addr_map_; bool ok_; bool addr_map_read_; char symbol_buf_[SYMBOL_BUF_SIZE]; // tmp_buf_ will be used to store arrays of ElfW(Shdr) and ElfW(Sym) // so we ensure that tmp_buf_ is properly aligned to store either. alignas(16) char tmp_buf_[TMP_BUF_SIZE]; static_assert(alignof(ElfW(Shdr)) <= 16, "alignment of tmp buf too small for Shdr"); static_assert(alignof(ElfW(Sym)) <= 16, "alignment of tmp buf too small for Sym"); SymbolCacheLine symbol_cache_[SYMBOL_CACHE_LINES]; }; static std::atomic<Symbolizer *> g_cached_symbolizer; } // namespace static int SymbolizerSize() { #if defined(__wasm__) || defined(__asmjs__) int pagesize = getpagesize(); #else int pagesize = sysconf(_SC_PAGESIZE); #endif return ((sizeof(Symbolizer) - 1) / pagesize + 1) * pagesize; } // Return (and set null) g_cached_symbolized_state if it is not null. // Otherwise return a new symbolizer. static Symbolizer *AllocateSymbolizer() { InitSigSafeArena(); Symbolizer *symbolizer = g_cached_symbolizer.exchange(nullptr, std::memory_order_acquire); if (symbolizer != nullptr) { return symbolizer; } return new (base_internal::LowLevelAlloc::AllocWithArena( SymbolizerSize(), SigSafeArena())) Symbolizer(); } // Set g_cached_symbolize_state to s if it is null, otherwise // delete s. static void FreeSymbolizer(Symbolizer *s) { Symbolizer *old_cached_symbolizer = nullptr; if (!g_cached_symbolizer.compare_exchange_strong(old_cached_symbolizer, s, std::memory_order_release, std::memory_order_relaxed)) { s->~Symbolizer(); base_internal::LowLevelAlloc::Free(s); } } Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) { for (SymbolCacheLine &symbol_cache_line : symbol_cache_) { for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) { symbol_cache_line.pc[j] = nullptr; symbol_cache_line.name[j] = nullptr; symbol_cache_line.age[j] = 0; } } } Symbolizer::~Symbolizer() { for (SymbolCacheLine &symbol_cache_line : symbol_cache_) { for (char *s : symbol_cache_line.name) { base_internal::LowLevelAlloc::Free(s); } } ClearAddrMap(); } // We don't use assert() since it's not guaranteed to be // async-signal-safe. Instead we define a minimal assertion // macro. So far, we don't need pretty printing for __FILE__, etc. #define SAFE_ASSERT(expr) ((expr) ? static_cast<void>(0) : abort()) // Read up to "count" bytes from file descriptor "fd" into the buffer // starting at "buf" while handling short reads and EINTR. On // success, return the number of bytes read. Otherwise, return -1. static ssize_t ReadPersistent(int fd, void *buf, size_t count) { SAFE_ASSERT(fd >= 0); SAFE_ASSERT(count <= SSIZE_MAX); char *buf0 = reinterpret_cast<char *>(buf); size_t num_bytes = 0; while (num_bytes < count) { ssize_t len; NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes)); if (len < 0) { // There was an error other than EINTR. ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno); return -1; } if (len == 0) { // Reached EOF. break; } num_bytes += len; } SAFE_ASSERT(num_bytes <= count); return static_cast<ssize_t>(num_bytes); } // Read up to "count" bytes from "offset" in the file pointed by file // descriptor "fd" into the buffer starting at "buf". On success, // return the number of bytes read. Otherwise, return -1. static ssize_t ReadFromOffset(const int fd, void *buf, const size_t count, const off_t offset) { off_t off = lseek(fd, offset, SEEK_SET); if (off == (off_t)-1) { ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd, static_cast<uintmax_t>(offset), errno); return -1; } return ReadPersistent(fd, buf, count); } // Try reading exactly "count" bytes from "offset" bytes in a file // pointed by "fd" into the buffer starting at "buf" while handling // short reads and EINTR. On success, return true. Otherwise, return // false. static bool ReadFromOffsetExact(const int fd, void *buf, const size_t count, const off_t offset) { ssize_t len = ReadFromOffset(fd, buf, count, offset); return len >= 0 && static_cast<size_t>(len) == count; } // Returns elf_header.e_type if the file pointed by fd is an ELF binary. static int FileGetElfType(const int fd) { ElfW(Ehdr) elf_header; if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) { return -1; } if (memcmp(elf_header.e_ident, ELFMAG, SELFMAG) != 0) { return -1; } return elf_header.e_type; } // Read the section headers in the given ELF binary, and if a section // of the specified type is found, set the output to this section header // and return true. Otherwise, return false. // To keep stack consumption low, we would like this function to not get // inlined. static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType( const int fd, ElfW(Half) sh_num, const off_t sh_offset, ElfW(Word) type, ElfW(Shdr) * out, char *tmp_buf, int tmp_buf_size) { ElfW(Shdr) *buf = reinterpret_cast<ElfW(Shdr) *>(tmp_buf); const int buf_entries = tmp_buf_size / sizeof(buf[0]); const int buf_bytes = buf_entries * sizeof(buf[0]); for (int i = 0; i < sh_num;) { const ssize_t num_bytes_left = (sh_num - i) * sizeof(buf[0]); const ssize_t num_bytes_to_read = (buf_bytes > num_bytes_left) ? num_bytes_left : buf_bytes; const off_t offset = sh_offset + i * sizeof(buf[0]); const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read, offset); if (len % sizeof(buf[0]) != 0) { ABSL_RAW_LOG( WARNING, "Reading %zd bytes from offset %ju returned %zd which is not a " "multiple of %zu.", num_bytes_to_read, static_cast<uintmax_t>(offset), len, sizeof(buf[0])); return false; } const ssize_t num_headers_in_buf = len / sizeof(buf[0]); SAFE_ASSERT(num_headers_in_buf <= buf_entries); for (int j = 0; j < num_headers_in_buf; ++j) { if (buf[j].sh_type == type) { *out = buf[j]; return true; } } i += num_headers_in_buf; } return false; } // There is no particular reason to limit section name to 63 characters, // but there has (as yet) been no need for anything longer either. const int kMaxSectionNameLen = 64; bool ForEachSection(int fd, const std::function<bool(absl::string_view name, const ElfW(Shdr) &)> &callback) { ElfW(Ehdr) elf_header; if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) { return false; } ElfW(Shdr) shstrtab; off_t shstrtab_offset = (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx); if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) { return false; } for (int i = 0; i < elf_header.e_shnum; ++i) { ElfW(Shdr) out; off_t section_header_offset = (elf_header.e_shoff + elf_header.e_shentsize * i); if (!ReadFromOffsetExact(fd, &out, sizeof(out), section_header_offset)) { return false; } off_t name_offset = shstrtab.sh_offset + out.sh_name; char header_name[kMaxSectionNameLen]; ssize_t n_read = ReadFromOffset(fd, &header_name, kMaxSectionNameLen, name_offset); if (n_read == -1) { return false; } else if (n_read > kMaxSectionNameLen) { // Long read? return false; } absl::string_view name(header_name, strnlen(header_name, n_read)); if (!callback(name, out)) { break; } } return true; } // name_len should include terminating '\0'. bool GetSectionHeaderByName(int fd, const char *name, size_t name_len, ElfW(Shdr) * out) { char header_name[kMaxSectionNameLen]; if (sizeof(header_name) < name_len) { ABSL_RAW_LOG(WARNING, "Section name '%s' is too long (%zu); " "section will not be found (even if present).", name, name_len); // No point in even trying. return false; } ElfW(Ehdr) elf_header; if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) { return false; } ElfW(Shdr) shstrtab; off_t shstrtab_offset = (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx); if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) { return false; } for (int i = 0; i < elf_header.e_shnum; ++i) { off_t section_header_offset = (elf_header.e_shoff + elf_header.e_shentsize * i); if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) { return false; } off_t name_offset = shstrtab.sh_offset + out->sh_name; ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset); if (n_read < 0) { return false; } else if (static_cast<size_t>(n_read) != name_len) { // Short read -- name could be at end of file. continue; } if (memcmp(header_name, name, name_len) == 0) { return true; } } return false; } // Compare symbols at in the same address. // Return true if we should pick symbol1. static bool ShouldPickFirstSymbol(const ElfW(Sym) & symbol1, const ElfW(Sym) & symbol2) { // If one of the symbols is weak and the other is not, pick the one // this is not a weak symbol. char bind1 = ELF_ST_BIND(symbol1.st_info); char bind2 = ELF_ST_BIND(symbol1.st_info); if (bind1 == STB_WEAK && bind2 != STB_WEAK) return false; if (bind2 == STB_WEAK && bind1 != STB_WEAK) return true; // If one of the symbols has zero size and the other is not, pick the // one that has non-zero size. if (symbol1.st_size != 0 && symbol2.st_size == 0) { return true; } if (symbol1.st_size == 0 && symbol2.st_size != 0) { return false; } // If one of the symbols has no type and the other is not, pick the // one that has a type. char type1 = ELF_ST_TYPE(symbol1.st_info); char type2 = ELF_ST_TYPE(symbol1.st_info); if (type1 != STT_NOTYPE && type2 == STT_NOTYPE) { return true; } if (type1 == STT_NOTYPE && type2 != STT_NOTYPE) { return false; } // Pick the first one, if we still cannot decide. return true; } // Return true if an address is inside a section. static bool InSection(const void *address, const ElfW(Shdr) * section) { const char *start = reinterpret_cast<const char *>(section->sh_addr); size_t size = static_cast<size_t>(section->sh_size); return start <= address && address < (start + size); } static const char *ComputeOffset(const char *base, ptrdiff_t offset) { // Note: cast to uintptr_t to avoid undefined behavior when base evaluates to // zero and offset is non-zero. return reinterpret_cast<const char *>( reinterpret_cast<uintptr_t>(base) + offset); } // Read a symbol table and look for the symbol containing the // pc. Iterate over symbols in a symbol table and look for the symbol // containing "pc". If the symbol is found, and its name fits in // out_size, the name is written into out and SYMBOL_FOUND is returned. // If the name does not fit, truncated name is written into out, // and SYMBOL_TRUNCATED is returned. Out is NUL-terminated. // If the symbol is not found, SYMBOL_NOT_FOUND is returned; // To keep stack consumption low, we would like this function to not get // inlined. static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol( const void *const pc, const int fd, char *out, int out_size, ptrdiff_t relocation, const ElfW(Shdr) * strtab, const ElfW(Shdr) * symtab, const ElfW(Shdr) * opd, char *tmp_buf, int tmp_buf_size) { if (symtab == nullptr) { return SYMBOL_NOT_FOUND; } // Read multiple symbols at once to save read() calls. ElfW(Sym) *buf = reinterpret_cast<ElfW(Sym) *>(tmp_buf); const int buf_entries = tmp_buf_size / sizeof(buf[0]); const int num_symbols = symtab->sh_size / symtab->sh_entsize; // On platforms using an .opd section (PowerPC & IA64), a function symbol // has the address of a function descriptor, which contains the real // starting address. However, we do not always want to use the real // starting address because we sometimes want to symbolize a function // pointer into the .opd section, e.g. FindSymbol(&foo,...). const bool pc_in_opd = kPlatformUsesOPDSections && opd != nullptr && InSection(pc, opd); const bool deref_function_descriptor_pointer = kPlatformUsesOPDSections && opd != nullptr && !pc_in_opd; ElfW(Sym) best_match; SafeMemZero(&best_match, sizeof(best_match)); bool found_match = false; for (int i = 0; i < num_symbols;) { off_t offset = symtab->sh_offset + i * symtab->sh_entsize; const int num_remaining_symbols = num_symbols - i; const int entries_in_chunk = std::min(num_remaining_symbols, buf_entries); const int bytes_in_chunk = entries_in_chunk * sizeof(buf[0]); const ssize_t len = ReadFromOffset(fd, buf, bytes_in_chunk, offset); SAFE_ASSERT(len % sizeof(buf[0]) == 0); const ssize_t num_symbols_in_buf = len / sizeof(buf[0]); SAFE_ASSERT(num_symbols_in_buf <= entries_in_chunk); for (int j = 0; j < num_symbols_in_buf; ++j) { const ElfW(Sym) &symbol = buf[j]; // For a DSO, a symbol address is relocated by the loading address. // We keep the original address for opd redirection below. const char *const original_start_address = reinterpret_cast<const char *>(symbol.st_value); const char *start_address = ComputeOffset(original_start_address, relocation); #ifdef __arm__ // ARM functions are always aligned to multiples of two bytes; the // lowest-order bit in start_address is ignored by the CPU and indicates // whether the function contains ARM (0) or Thumb (1) code. We don't care // about what encoding is being used; we just want the real start address // of the function. start_address = reinterpret_cast<const char *>( reinterpret_cast<uintptr_t>(start_address) & ~1); #endif if (deref_function_descriptor_pointer && InSection(original_start_address, opd)) { // The opd section is mapped into memory. Just dereference // start_address to get the first double word, which points to the // function entry. start_address = *reinterpret_cast<const char *const *>(start_address); } // If pc is inside the .opd section, it points to a function descriptor. const size_t size = pc_in_opd ? kFunctionDescriptorSize : symbol.st_size; const void *const end_address = ComputeOffset(start_address, size); if (symbol.st_value != 0 && // Skip null value symbols. symbol.st_shndx != 0 && // Skip undefined symbols. #ifdef STT_TLS ELF_ST_TYPE(symbol.st_info) != STT_TLS && // Skip thread-local data. #endif // STT_TLS ((start_address <= pc && pc < end_address) || (start_address == pc && pc == end_address))) { if (!found_match || ShouldPickFirstSymbol(symbol, best_match)) { found_match = true; best_match = symbol; } } } i += num_symbols_in_buf; } if (found_match) { const size_t off = strtab->sh_offset + best_match.st_name; const ssize_t n_read = ReadFromOffset(fd, out, out_size, off); if (n_read <= 0) { // This should never happen. ABSL_RAW_LOG(WARNING, "Unable to read from fd %d at offset %zu: n_read = %zd", fd, off, n_read); return SYMBOL_NOT_FOUND; } ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data."); // strtab->sh_offset points into .strtab-like section that contains // NUL-terminated strings: '\0foo\0barbaz\0...". // // sh_offset+st_name points to the start of symbol name, but we don't know // how long the symbol is, so we try to read as much as we have space for, // and usually over-read (i.e. there is a NUL somewhere before n_read). if (memchr(out, '\0', n_read) == nullptr) { // Either out_size was too small (n_read == out_size and no NUL), or // we tried to read past the EOF (n_read < out_size) and .strtab is // corrupt (missing terminating NUL; should never happen for valid ELF). out[n_read - 1] = '\0'; return SYMBOL_TRUNCATED; } return SYMBOL_FOUND; } return SYMBOL_NOT_FOUND; } // Get the symbol name of "pc" from the file pointed by "fd". Process // both regular and dynamic symbol tables if necessary. // See FindSymbol() comment for description of return value. FindSymbolResult Symbolizer::GetSymbolFromObjectFile( const ObjFile &obj, const void *const pc, const ptrdiff_t relocation, char *out, int out_size, char *tmp_buf, int tmp_buf_size) { ElfW(Shdr) symtab; ElfW(Shdr) strtab; ElfW(Shdr) opd; ElfW(Shdr) *opd_ptr = nullptr; // On platforms using an .opd sections for function descriptor, read // the section header. The .opd section is in data segment and should be // loaded but we check that it is mapped just to be extra careful. if (kPlatformUsesOPDSections) { if (GetSectionHeaderByName(obj.fd, kOpdSectionName, sizeof(kOpdSectionName) - 1, &opd) && FindObjFile(reinterpret_cast<const char *>(opd.sh_addr) + relocation, opd.sh_size) != nullptr) { opd_ptr = &opd; } else { return SYMBOL_NOT_FOUND; } } // Consult a regular symbol table, then fall back to the dynamic symbol table. for (const auto symbol_table_type : {SHT_SYMTAB, SHT_DYNSYM}) { if (!GetSectionHeaderByType(obj.fd, obj.elf_header.e_shnum, obj.elf_header.e_shoff, symbol_table_type, &symtab, tmp_buf, tmp_buf_size)) { continue; } if (!ReadFromOffsetExact( obj.fd, &strtab, sizeof(strtab), obj.elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) { continue; } const FindSymbolResult rc = FindSymbol(pc, obj.fd, out, out_size, relocation, &strtab, &symtab, opd_ptr, tmp_buf, tmp_buf_size); if (rc != SYMBOL_NOT_FOUND) { return rc; } } return SYMBOL_NOT_FOUND; } namespace { // Thin wrapper around a file descriptor so that the file descriptor // gets closed for sure. class FileDescriptor { public: explicit FileDescriptor(int fd) : fd_(fd) {} FileDescriptor(const FileDescriptor &) = delete; FileDescriptor &operator=(const FileDescriptor &) = delete; ~FileDescriptor() { if (fd_ >= 0) { NO_INTR(close(fd_)); } } int get() const { return fd_; } private: const int fd_; }; // Helper class for reading lines from file. // // Note: we don't use ProcMapsIterator since the object is big (it has // a 5k array member) and uses async-unsafe functions such as sscanf() // and snprintf(). class LineReader { public: explicit LineReader(int fd, char *buf, int buf_len) : fd_(fd), buf_len_(buf_len), buf_(buf), bol_(buf), eol_(buf), eod_(buf) {} LineReader(const LineReader &) = delete; LineReader &operator=(const LineReader &) = delete; // Read '\n'-terminated line from file. On success, modify "bol" // and "eol", then return true. Otherwise, return false. // // Note: if the last line doesn't end with '\n', the line will be // dropped. It's an intentional behavior to make the code simple. bool ReadLine(const char **bol, const char **eol) { if (BufferIsEmpty()) { // First time. const ssize_t num_bytes = ReadPersistent(fd_, buf_, buf_len_); if (num_bytes <= 0) { // EOF or error. return false; } eod_ = buf_ + num_bytes; bol_ = buf_; } else { bol_ = eol_ + 1; // Advance to the next line in the buffer. SAFE_ASSERT(bol_ <= eod_); // "bol_" can point to "eod_". if (!HasCompleteLine()) { const int incomplete_line_length = eod_ - bol_; // Move the trailing incomplete line to the beginning. memmove(buf_, bol_, incomplete_line_length); // Read text from file and append it. char *const append_pos = buf_ + incomplete_line_length; const int capacity_left = buf_len_ - incomplete_line_length; const ssize_t num_bytes = ReadPersistent(fd_, append_pos, capacity_left); if (num_bytes <= 0) { // EOF or error. return false; } eod_ = append_pos + num_bytes; bol_ = buf_; } } eol_ = FindLineFeed(); if (eol_ == nullptr) { // '\n' not found. Malformed line. return false; } *eol_ = '\0'; // Replace '\n' with '\0'. *bol = bol_; *eol = eol_; return true; } private: char *FindLineFeed() const { return reinterpret_cast<char *>(memchr(bol_, '\n', eod_ - bol_)); } bool BufferIsEmpty() const { return buf_ == eod_; } bool HasCompleteLine() const { return !BufferIsEmpty() && FindLineFeed() != nullptr; } const int fd_; const int buf_len_; char *const buf_; char *bol_; char *eol_; const char *eod_; // End of data in "buf_". }; } // namespace // Place the hex number read from "start" into "*hex". The pointer to // the first non-hex character or "end" is returned. static const char *GetHex(const char *start, const char *end, uint64_t *const value) { uint64_t hex = 0; const char *p; for (p = start; p < end; ++p) { int ch = *p; if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) { hex = (hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9); } else { // Encountered the first non-hex character. break; } } SAFE_ASSERT(p <= end); *value = hex; return p; } static const char *GetHex(const char *start, const char *end, const void **const addr) { uint64_t hex = 0; const char *p = GetHex(start, end, &hex); *addr = reinterpret_cast<void *>(hex); return p; } // Normally we are only interested in "r?x" maps. // On the PowerPC, function pointers point to descriptors in the .opd // section. The descriptors themselves are not executable code, so // we need to relax the check below to "r??". static bool ShouldUseMapping(const char *const flags) { return flags[0] == 'r' && (kPlatformUsesOPDSections || flags[2] == 'x'); } // Read /proc/self/maps and run "callback" for each mmapped file found. If // "callback" returns false, stop scanning and return true. Else continue // scanning /proc/self/maps. Return true if no parse error is found. static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap( bool (*callback)(const char *filename, const void *const start_addr, const void *const end_addr, uint64_t offset, void *arg), void *arg, void *tmp_buf, int tmp_buf_size) { // Use /proc/self/task/<pid>/maps instead of /proc/self/maps. The latter // requires kernel to stop all threads, and is significantly slower when there // are 1000s of threads. char maps_path[80]; snprintf(maps_path, sizeof(maps_path), "/proc/self/task/%d/maps", getpid()); int maps_fd; NO_INTR(maps_fd = open(maps_path, O_RDONLY)); FileDescriptor wrapped_maps_fd(maps_fd); if (wrapped_maps_fd.get() < 0) { ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno); return false; } // Iterate over maps and look for the map containing the pc. Then // look into the symbol tables inside. LineReader reader(wrapped_maps_fd.get(), static_cast<char *>(tmp_buf), tmp_buf_size); while (true) { const char *cursor; const char *eol; if (!reader.ReadLine(&cursor, &eol)) { // EOF or malformed line. break; } const char *line = cursor; const void *start_address; // Start parsing line in /proc/self/maps. Here is an example: // // 08048000-0804c000 r-xp 00000000 08:01 2142121 /bin/cat // // We want start address (08048000), end address (0804c000), flags // (r-xp) and file name (/bin/cat). // Read start address. cursor = GetHex(cursor, eol, &start_address); if (cursor == eol || *cursor != '-') { ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); return false; } ++cursor; // Skip '-'. // Read end address. const void *end_address; cursor = GetHex(cursor, eol, &end_address); if (cursor == eol || *cursor != ' ') { ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line); return false; } ++cursor; // Skip ' '. // Read flags. Skip flags until we encounter a space or eol. const char *const flags_start = cursor; while (cursor < eol && *cursor != ' ') { ++cursor; } // We expect at least four letters for flags (ex. "r-xp"). if (cursor == eol || cursor < flags_start + 4) { ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line); return false; } // Check flags. if (!ShouldUseMapping(flags_start)) { continue; // We skip this map. } ++cursor; // Skip ' '. // Read file offset. uint64_t offset; cursor = GetHex(cursor, eol, &offset); ++cursor; // Skip ' '. // Skip to file name. "cursor" now points to dev. We need to skip at least // two spaces for dev and inode. int num_spaces = 0; while (cursor < eol) { if (*cursor == ' ') { ++num_spaces; } else if (num_spaces >= 2) { // The first non-space character after skipping two spaces // is the beginning of the file name. break; } ++cursor; } // Check whether this entry corresponds to our hint table for the true // filename. bool hinted = GetFileMappingHint(&start_address, &end_address, &offset, &cursor); if (!hinted && (cursor == eol || cursor[0] == '[')) { // not an object file, typically [vdso] or [vsyscall] continue; } if (!callback(cursor, start_address, end_address, offset, arg)) break; } return true; } // Find the objfile mapped in address region containing [addr, addr + len). ObjFile *Symbolizer::FindObjFile(const void *const addr, size_t len) { for (int i = 0; i < 2; ++i) { if (!ok_) return nullptr; // Read /proc/self/maps if necessary if (!addr_map_read_) { addr_map_read_ = true; if (!ReadAddrMap(RegisterObjFile, this, tmp_buf_, TMP_BUF_SIZE)) { ok_ = false; return nullptr; } } int lo = 0; int hi = addr_map_.Size(); while (lo < hi) { int mid = (lo + hi) / 2; if (addr < addr_map_.At(mid)->end_addr) { hi = mid; } else { lo = mid + 1; } } if (lo != addr_map_.Size()) { ObjFile *obj = addr_map_.At(lo); SAFE_ASSERT(obj->end_addr > addr); if (addr >= obj->start_addr && reinterpret_cast<const char *>(addr) + len <= obj->end_addr) return obj; } // The address mapping may have changed since it was last read. Retry. ClearAddrMap(); } return nullptr; } void Symbolizer::ClearAddrMap() { for (int i = 0; i != addr_map_.Size(); i++) { ObjFile *o = addr_map_.At(i); base_internal::LowLevelAlloc::Free(o->filename); if (o->fd >= 0) { NO_INTR(close(o->fd)); } } addr_map_.Clear(); addr_map_read_ = false; } // Callback for ReadAddrMap to register objfiles in an in-memory table. bool Symbolizer::RegisterObjFile(const char *filename, const void *const start_addr, const void *const end_addr, uint64_t offset, void *arg) { Symbolizer *impl = static_cast<Symbolizer *>(arg); // Files are supposed to be added in the increasing address order. Make // sure that's the case. int addr_map_size = impl->addr_map_.Size(); if (addr_map_size != 0) { ObjFile *old = impl->addr_map_.At(addr_map_size - 1); if (old->end_addr > end_addr) { ABSL_RAW_LOG(ERROR, "Unsorted addr map entry: 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s", reinterpret_cast<uintptr_t>(end_addr), filename, reinterpret_cast<uintptr_t>(old->end_addr), old->filename); return true; } else if (old->end_addr == end_addr) { // The same entry appears twice. This sometimes happens for [vdso]. if (old->start_addr != start_addr || strcmp(old->filename, filename) != 0) { ABSL_RAW_LOG(ERROR, "Duplicate addr 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s", reinterpret_cast<uintptr_t>(end_addr), filename, reinterpret_cast<uintptr_t>(old->end_addr), old->filename); } return true; } } ObjFile *obj = impl->addr_map_.Add(); obj->filename = impl->CopyString(filename); obj->start_addr = start_addr; obj->end_addr = end_addr; obj->offset = offset; obj->elf_type = -1; // filled on demand obj->fd = -1; // opened on demand return true; } // This function wraps the Demangle function to provide an interface // where the input symbol is demangled in-place. // To keep stack consumption low, we would like this function to not // get inlined. static ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size, char *tmp_buf, int tmp_buf_size) { if (Demangle(out, tmp_buf, tmp_buf_size)) { // Demangling succeeded. Copy to out if the space allows. int len = strlen(tmp_buf); if (len + 1 <= out_size) { // +1 for '\0'. SAFE_ASSERT(len < tmp_buf_size); memmove(out, tmp_buf, len + 1); } } } SymbolCacheLine *Symbolizer::GetCacheLine(const void *const pc) { uintptr_t pc0 = reinterpret_cast<uintptr_t>(pc); pc0 >>= 3; // drop the low 3 bits // Shuffle bits. pc0 ^= (pc0 >> 6) ^ (pc0 >> 12) ^ (pc0 >> 18); return &symbol_cache_[pc0 % SYMBOL_CACHE_LINES]; } void Symbolizer::AgeSymbols(SymbolCacheLine *line) { for (uint32_t &age : line->age) { ++age; } } const char *Symbolizer::FindSymbolInCache(const void *const pc) { if (pc == nullptr) return nullptr; SymbolCacheLine *line = GetCacheLine(pc); for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) { if (line->pc[i] == pc) { AgeSymbols(line); line->age[i] = 0; return line->name[i]; } } return nullptr; } const char *Symbolizer::InsertSymbolInCache(const void *const pc, const char *name) { SAFE_ASSERT(pc != nullptr); SymbolCacheLine *line = GetCacheLine(pc); uint32_t max_age = 0; int oldest_index = -1; for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) { if (line->pc[i] == nullptr) { AgeSymbols(line); line->pc[i] = pc; line->name[i] = CopyString(name); line->age[i] = 0; return line->name[i]; } if (line->age[i] >= max_age) { max_age = line->age[i]; oldest_index = i; } } AgeSymbols(line); ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache"); base_internal::LowLevelAlloc::Free(line->name[oldest_index]); line->pc[oldest_index] = pc; line->name[oldest_index] = CopyString(name); line->age[oldest_index] = 0; return line->name[oldest_index]; } static void MaybeOpenFdFromSelfExe(ObjFile *obj) { if (memcmp(obj->start_addr, ELFMAG, SELFMAG) != 0) { return; } int fd = open("/proc/self/exe", O_RDONLY); if (fd == -1) { return; } // Verify that contents of /proc/self/exe matches in-memory image of // the binary. This can fail if the "deleted" binary is in fact not // the main executable, or for binaries that have the first PT_LOAD // segment smaller than 4K. We do it in four steps so that the // buffer is smaller and we don't consume too much stack space. const char *mem = reinterpret_cast<const char *>(obj->start_addr); for (int i = 0; i < 4; ++i) { char buf[1024]; ssize_t n = read(fd, buf, sizeof(buf)); if (n != sizeof(buf) || memcmp(buf, mem, sizeof(buf)) != 0) { close(fd); return; } mem += sizeof(buf); } obj->fd = fd; } static bool MaybeInitializeObjFile(ObjFile *obj) { if (obj->fd < 0) { obj->fd = open(obj->filename, O_RDONLY); if (obj->fd < 0) { // Getting /proc/self/exe here means that we were hinted. if (strcmp(obj->filename, "/proc/self/exe") == 0) { // /proc/self/exe may be inaccessible (due to setuid, etc.), so try // accessing the binary via argv0. if (argv0_value != nullptr) { obj->fd = open(argv0_value, O_RDONLY); } } else { MaybeOpenFdFromSelfExe(obj); } } if (obj->fd < 0) { ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno); return false; } obj->elf_type = FileGetElfType(obj->fd); if (obj->elf_type < 0) { ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename, obj->elf_type); return false; } if (!ReadFromOffsetExact(obj->fd, &obj->elf_header, sizeof(obj->elf_header), 0)) { ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename); return false; } const int phnum = obj->elf_header.e_phnum; const int phentsize = obj->elf_header.e_phentsize; size_t phoff = obj->elf_header.e_phoff; size_t num_executable_load_segments = 0; for (int j = 0; j < phnum; j++) { ElfW(Phdr) phdr; if (!ReadFromOffsetExact(obj->fd, &phdr, sizeof(phdr), phoff)) { ABSL_RAW_LOG(WARNING, "%s: failed to read program header %d", obj->filename, j); return false; } phoff += phentsize; constexpr int rx = PF_X | PF_R; if (phdr.p_type != PT_LOAD || (phdr.p_flags & rx) != rx) { // Not a LOAD segment, or not executable code. continue; } if (num_executable_load_segments < obj->phdr.size()) { memcpy(&obj->phdr[num_executable_load_segments++], &phdr, sizeof(phdr)); } else { ABSL_RAW_LOG(WARNING, "%s: too many executable LOAD segments", obj->filename); break; } } if (num_executable_load_segments == 0) { // This object has no "r-x" LOAD segments. That's unexpected. ABSL_RAW_LOG(WARNING, "%s: no executable LOAD segments", obj->filename); return false; } } return true; } // The implementation of our symbolization routine. If it // successfully finds the symbol containing "pc" and obtains the // symbol name, returns pointer to that symbol. Otherwise, returns nullptr. // If any symbol decorators have been installed via InstallSymbolDecorator(), // they are called here as well. // To keep stack consumption low, we would like this function to not // get inlined. const char *Symbolizer::GetSymbol(const void *const pc) { const char *entry = FindSymbolInCache(pc); if (entry != nullptr) { return entry; } symbol_buf_[0] = '\0'; ObjFile *const obj = FindObjFile(pc, 1); ptrdiff_t relocation = 0; int fd = -1; if (obj != nullptr) { if (MaybeInitializeObjFile(obj)) { const size_t start_addr = reinterpret_cast<size_t>(obj->start_addr); if (obj->elf_type == ET_DYN && start_addr >= obj->offset) { // This object was relocated. // // For obj->offset > 0, adjust the relocation since a mapping at offset // X in the file will have a start address of [true relocation]+X. relocation = start_addr - obj->offset; // Note: some binaries have multiple "rx" LOAD segments. We must // find the right one. ElfW(Phdr) *phdr = nullptr; for (size_t j = 0; j < obj->phdr.size(); j++) { ElfW(Phdr) &p = obj->phdr[j]; if (p.p_type != PT_LOAD) { // We only expect PT_LOADs. This must be PT_NULL that we didn't // write over (i.e. we exhausted all interesting PT_LOADs). ABSL_RAW_CHECK(p.p_type == PT_NULL, "unexpected p_type"); break; } if (pc < reinterpret_cast<void *>(start_addr + p.p_memsz)) { phdr = &p; break; } } if (phdr == nullptr) { // That's unexpected. Hope for the best. ABSL_RAW_LOG( WARNING, "%s: unable to find LOAD segment for pc: %p, start_addr: %zx", obj->filename, pc, start_addr); } else { // Adjust relocation in case phdr.p_vaddr != 0. // This happens for binaries linked with `lld --rosegment`, and for // binaries linked with BFD `ld -z separate-code`. relocation -= phdr->p_vaddr - phdr->p_offset; } } fd = obj->fd; if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_, sizeof(symbol_buf_), tmp_buf_, sizeof(tmp_buf_)) == SYMBOL_FOUND) { // Only try to demangle the symbol name if it fit into symbol_buf_. DemangleInplace(symbol_buf_, sizeof(symbol_buf_), tmp_buf_, sizeof(tmp_buf_)); } } } else { #if ABSL_HAVE_VDSO_SUPPORT VDSOSupport vdso; if (vdso.IsPresent()) { VDSOSupport::SymbolInfo symbol_info; if (vdso.LookupSymbolByAddress(pc, &symbol_info)) { // All VDSO symbols are known to be short. size_t len = strlen(symbol_info.name); ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_), "VDSO symbol unexpectedly long"); memcpy(symbol_buf_, symbol_info.name, len + 1); } } #endif } if (g_decorators_mu.TryLock()) { if (g_num_decorators > 0) { SymbolDecoratorArgs decorator_args = { pc, relocation, fd, symbol_buf_, sizeof(symbol_buf_), tmp_buf_, sizeof(tmp_buf_), nullptr}; for (int i = 0; i < g_num_decorators; ++i) { decorator_args.arg = g_decorators[i].arg; g_decorators[i].fn(&decorator_args); } } g_decorators_mu.Unlock(); } if (symbol_buf_[0] == '\0') { return nullptr; } symbol_buf_[sizeof(symbol_buf_) - 1] = '\0'; // Paranoia. return InsertSymbolInCache(pc, symbol_buf_); } bool RemoveAllSymbolDecorators(void) { if (!g_decorators_mu.TryLock()) { // Someone else is using decorators. Get out. return false; } g_num_decorators = 0; g_decorators_mu.Unlock(); return true; } bool RemoveSymbolDecorator(int ticket) { if (!g_decorators_mu.TryLock()) { // Someone else is using decorators. Get out. return false; } for (int i = 0; i < g_num_decorators; ++i) { if (g_decorators[i].ticket == ticket) { while (i < g_num_decorators - 1) { g_decorators[i] = g_decorators[i + 1]; ++i; } g_num_decorators = i; break; } } g_decorators_mu.Unlock(); return true; // Decorator is known to be removed. } int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) { static int ticket = 0; if (!g_decorators_mu.TryLock()) { // Someone else is using decorators. Get out. return -2; } int ret = ticket; if (g_num_decorators >= kMaxDecorators) { ret = -1; } else { g_decorators[g_num_decorators] = {decorator, arg, ticket++}; ++g_num_decorators; } g_decorators_mu.Unlock(); return ret; } bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset, const char *filename) { SAFE_ASSERT(start <= end); SAFE_ASSERT(filename != nullptr); InitSigSafeArena(); if (!g_file_mapping_mu.TryLock()) { return false; } bool ret = true; if (g_num_file_mapping_hints >= kMaxFileMappingHints) { ret = false; } else { // TODO(ckennelly): Move this into a string copy routine. int len = strlen(filename); char *dst = static_cast<char *>( base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena())); ABSL_RAW_CHECK(dst != nullptr, "out of memory"); memcpy(dst, filename, len + 1); auto &hint = g_file_mapping_hints[g_num_file_mapping_hints++]; hint.start = start; hint.end = end; hint.offset = offset; hint.filename = dst; } g_file_mapping_mu.Unlock(); return ret; } bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset, const char **filename) { if (!g_file_mapping_mu.TryLock()) { return false; } bool found = false; for (int i = 0; i < g_num_file_mapping_hints; i++) { if (g_file_mapping_hints[i].start <= *start && *end <= g_file_mapping_hints[i].end) { // We assume that the start_address for the mapping is the base // address of the ELF section, but when [start_address,end_address) is // not strictly equal to [hint.start, hint.end), that assumption is // invalid. // // This uses the hint's start address (even though hint.start is not // necessarily equal to start_address) to ensure the correct // relocation is computed later. *start = g_file_mapping_hints[i].start; *end = g_file_mapping_hints[i].end; *offset = g_file_mapping_hints[i].offset; *filename = g_file_mapping_hints[i].filename; found = true; break; } } g_file_mapping_mu.Unlock(); return found; } } // namespace debugging_internal bool Symbolize(const void *pc, char *out, int out_size) { // Symbolization is very slow under tsan. ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN(); SAFE_ASSERT(out_size >= 0); debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer(); const char *name = s->GetSymbol(pc); bool ok = false; if (name != nullptr && out_size > 0) { strncpy(out, name, out_size); ok = true; if (out[out_size - 1] != '\0') { // strncpy() does not '\0' terminate when it truncates. Do so, with // trailing ellipsis. static constexpr char kEllipsis[] = "..."; int ellipsis_size = std::min(implicit_cast<int>(strlen(kEllipsis)), out_size - 1); memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size); out[out_size - 1] = '\0'; } } debugging_internal::FreeSymbolizer(s); ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END(); return ok; } ABSL_NAMESPACE_END } // namespace absl extern "C" bool AbslInternalGetFileMappingHint(const void **start, const void **end, uint64_t *offset, const char **filename) { return absl::debugging_internal::GetFileMappingHint(start, end, offset, filename); }