240 lines
6.9 KiB
C++
240 lines
6.9 KiB
C++
/*
|
|
* sysutils.cpp
|
|
*
|
|
* Created on: Dec 28, 2019
|
|
* Author: nnosov
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
|
|
#include <elfutils/libdwfl.h>
|
|
#include <cxxabi.h>
|
|
#include <execinfo.h>
|
|
#include <dwarf.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "sysutils.h"
|
|
#include "logger/log.h"
|
|
|
|
#define USE_LIBUNWIND
|
|
|
|
#ifdef USE_LIBUNWIND
|
|
#include <libunwind.h>
|
|
#endif
|
|
|
|
#include "common.h"
|
|
#include "dwarf_operations.h"
|
|
#include "allocator.h"
|
|
#include "dwarf_stack.h"
|
|
|
|
// dwfl_addrsegment() possibly can be used to check address validity
|
|
// dwarf_getattrs() allows to enumerate all DIE attributes
|
|
// dwarf_getfuncs() allows to enumerate functions within CU
|
|
|
|
bool __pst_handler::get_dwarf_function(pst_function* fun)
|
|
{
|
|
Dwarf_Addr mod_cu = 0;
|
|
// get CU(Compilation Unit) debug definition
|
|
ctx.module = dwfl_addrmodule(ctx.dwfl, fun->pc);
|
|
Dwarf_Die* cdie = dwfl_module_addrdie(ctx.module, fun->pc, &mod_cu);
|
|
//Dwarf_Die* cdie = dwfl_addrdie(dwfl, addr, &mod_bias);
|
|
if(!cdie) {
|
|
ctx.log(SEVERITY_INFO, "Failed to find DWARF DIE for address %X", fun->pc);
|
|
return false;
|
|
}
|
|
|
|
if(dwarf_tag(cdie) != DW_TAG_compile_unit) {
|
|
ctx.log(SEVERITY_DEBUG, "Skipping non-cu die. DWARF tag: 0x%X, name = %s", dwarf_tag(cdie), dwarf_diename(cdie));
|
|
return false;
|
|
}
|
|
|
|
Dwarf_Die result;
|
|
if(dwarf_child(cdie, &result)) {
|
|
ctx.log(SEVERITY_ERROR, "No child DIE found for CU %s", dwarf_diename(cdie));
|
|
return false;
|
|
}
|
|
|
|
bool nret = false;
|
|
|
|
do {
|
|
int tag = dwarf_tag(&result);
|
|
if(tag == DW_TAG_subprogram || tag == DW_TAG_entry_point || tag == DW_TAG_inlined_subroutine) {
|
|
//ctx.log(SEVERITY_DEBUG, "function die name %s", dwarf_diename(&result));
|
|
if(!strcmp(fun->name.c_str(), dwarf_diename(&result))) {
|
|
return fun->handle_dwarf(&result);
|
|
}
|
|
}
|
|
} while(dwarf_siblingof(&result, &result) == 0);
|
|
|
|
return nret;
|
|
}
|
|
|
|
pst_function* __pst_handler::add_function(__pst_function* parent)
|
|
{
|
|
pst_function* f = new pst_function(&ctx, parent);
|
|
functions.InsertLast(f);
|
|
|
|
return f;
|
|
}
|
|
|
|
void __pst_handler::del_function(pst_function* f)
|
|
{
|
|
functions.Remove(f);
|
|
delete f;
|
|
}
|
|
|
|
void __pst_handler::clear()
|
|
{
|
|
for(pst_function* f = (pst_function*)functions.First(); f; f = (pst_function*)functions.First()) {
|
|
functions.Remove(f);
|
|
delete f;
|
|
}
|
|
}
|
|
|
|
pst_function* __pst_handler::next_function(pst_function* f)
|
|
{
|
|
pst_function* next = NULL;
|
|
if(!f) {
|
|
next = (pst_function*)functions.First();
|
|
} else {
|
|
next = (pst_function*)functions.Next(f);
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
pst_function* __pst_handler::last_function()
|
|
{
|
|
return (pst_function*)functions.Last();
|
|
}
|
|
|
|
bool __pst_handler::handle_dwarf()
|
|
{
|
|
ctx.clean_print(&ctx);
|
|
Dl_info info;
|
|
|
|
//for(pst_function* fun = next_function(NULL); fun; fun = next_function(fun)) {
|
|
for(pst_function* fun = (pst_function*)functions.Last(); fun; fun = (pst_function*)functions.Prev(fun)) {
|
|
dladdr((void*)(fun->pc), &info);
|
|
ctx.module = dwfl_addrmodule(ctx.dwfl, fun->pc);
|
|
ctx.base_addr = (uint64_t)info.dli_fbase;
|
|
ctx.log(SEVERITY_INFO, "Function %s(...): module name: %s, base address: %p, CFA: %#lX", fun->name.c_str(), info.dli_fname, info.dli_fbase, fun->parent ? fun->parent->sp : 0);
|
|
ctx.curr_frame = &fun->cursor;
|
|
ctx.sp = fun->sp;
|
|
ctx.cfa = fun->cfa;
|
|
|
|
ctx.curr_frame = &fun->cursor;
|
|
get_dwarf_function(fun);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void __pst_handler::print_dwarf()
|
|
{
|
|
ctx.clean_print(&ctx);
|
|
ctx.print(&ctx, "DWARF-based stack trace information:\n");
|
|
uint32_t idx = 0;
|
|
for(pst_function* function = next_function(NULL); function; function = next_function(function)) {
|
|
ctx.print(&ctx, "[%-2u] ", idx); idx++;
|
|
function->print_dwarf();
|
|
ctx.print(&ctx, "\n");
|
|
}
|
|
}
|
|
|
|
char *debuginfo_path = NULL;
|
|
Dwfl_Callbacks callbacks = {
|
|
.find_elf = dwfl_linux_proc_find_elf,
|
|
.find_debuginfo = dwfl_standard_find_debuginfo,
|
|
.section_address = dwfl_offline_section_address,
|
|
.debuginfo_path = &debuginfo_path,
|
|
};
|
|
|
|
#include <dlfcn.h>
|
|
|
|
bool __pst_handler::unwind()
|
|
{
|
|
ctx.clean_print(&ctx);
|
|
#ifdef REG_RIP // x86_64
|
|
caller = (void *) ctx.hcontext->uc_mcontext.gregs[REG_RIP];
|
|
ctx.sp = ctx.hcontext->uc_mcontext.gregs[REG_RSP];
|
|
ctx.log(SEVERITY_DEBUG, "Original caller's SP: %#lX", ctx.sp);
|
|
#elif defined(REG_EIP) // x86_32
|
|
caller_address = (void *) uctx->uc_mcontext.gregs[REG_EIP]);
|
|
#elif defined(__arm__)
|
|
caller_address = (void *) uctx->uc_mcontext.arm_pc);
|
|
#elif defined(__aarch64__)
|
|
caller_address = (void *) uctx->uc_mcontext.pc);
|
|
#elif defined(__ppc__) || defined(__powerpc) || defined(__powerpc__) || defined(__POWERPC__)
|
|
caller_address = (void *) uctx->uc_mcontext.regs->nip);
|
|
#elif defined(__s390x__)
|
|
caller_address = (void *) uctx->uc_mcontext.psw.addr);
|
|
#elif defined(__APPLE__) && defined(__x86_64__)
|
|
caller_address = (void *) uctx->uc_mcontext->__ss.__rip);
|
|
#else
|
|
# error "unknown architecture!"
|
|
#endif
|
|
|
|
//handle = dlopen(NULL, RTLD_NOW);
|
|
Dl_info info;
|
|
dladdr(caller, &info);
|
|
ctx.base_addr = (uint64_t)info.dli_fbase;
|
|
ctx.log(SEVERITY_INFO, "Process address information: PC address: %p, base address: %p, object name: %s", caller, info.dli_fbase, info.dli_fname);
|
|
|
|
ctx.dwfl = dwfl_begin(&callbacks);
|
|
if(ctx.dwfl == NULL) {
|
|
ctx.print(&ctx, "Failed to initialize libdw session for parse stack frames");
|
|
return false;
|
|
}
|
|
|
|
if(dwfl_linux_proc_report(ctx.dwfl, getpid()) != 0 || dwfl_report_end(ctx.dwfl, NULL, NULL) !=0) {
|
|
ctx.print(&ctx, "Failed to parse debug section of executable");
|
|
return false;
|
|
}
|
|
|
|
ctx.print(&ctx, "Stack trace: caller = %p\n", caller);
|
|
|
|
unw_getcontext(&ctx.context);
|
|
unw_init_local(&ctx.cursor, &ctx.context);
|
|
ctx.curr_frame = &ctx.cursor;
|
|
for(int i = 0, skip = 1; unw_step(ctx.curr_frame) > 0; ++i) {
|
|
if(unw_get_reg(ctx.curr_frame, UNW_REG_IP, &addr)) {
|
|
ctx.log(SEVERITY_DEBUG, "Failed to get IP value");
|
|
continue;
|
|
}
|
|
unw_word_t sp;
|
|
if(unw_get_reg(ctx.curr_frame, UNW_REG_SP, &sp)) {
|
|
ctx.log(SEVERITY_DEBUG, "Failed to get SP value");
|
|
continue;
|
|
}
|
|
|
|
if(addr == (uint64_t)caller) {
|
|
skip = 0;
|
|
} else if(skip) {
|
|
ctx.log(SEVERITY_DEBUG, "Skipping frame #%d: PC = %#lX, SP = %#lX", i, addr, sp);
|
|
continue;
|
|
}
|
|
|
|
ctx.print(&ctx, "[%-2d] ", i);
|
|
ctx.module = dwfl_addrmodule(ctx.dwfl, addr);
|
|
pst_function* last = last_function();
|
|
pst_function* fun = add_function(NULL);
|
|
fun->sp = sp;
|
|
ctx.log(SEVERITY_DEBUG, "Analyze frame #%d: PC = %#lX, SP = %#lX", i, addr, sp);
|
|
if(!fun->unwind(addr)) {
|
|
del_function(fun);
|
|
} else {
|
|
if(last) {
|
|
last->parent = fun;
|
|
}
|
|
//get_frame(fun);
|
|
}
|
|
ctx.print(&ctx, "\n");
|
|
}
|
|
|
|
return true;
|
|
}
|