1482 lines
49 KiB
C++
1482 lines
49 KiB
C++
// 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 <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"
|
|
|
|
namespace absl {
|
|
ABSL_NAMESPACE_BEGIN
|
|
|
|
// Value of argv[0]. Used by MaybeInitializeObjFile().
|
|
static char *argv0_value = nullptr;
|
|
|
|
void InitializeSymbolizer(const char *argv0) {
|
|
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));
|
|
}
|
|
|
|
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;
|
|
};
|
|
|
|
// 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);
|
|
|
|
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;
|
|
}
|
|
}
|
|
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)) {
|
|
if (obj->elf_type == ET_DYN &&
|
|
reinterpret_cast<uint64_t>(obj->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 = reinterpret_cast<ptrdiff_t>(obj->start_addr) - obj->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 false;
|
|
}
|
|
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.
|
|
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);
|
|
ANNOTATE_IGNORE_READS_AND_WRITES_END();
|
|
return ok;
|
|
}
|
|
|
|
ABSL_NAMESPACE_END
|
|
} // namespace absl
|