浅谈Linux系统中的异常堆栈跟踪的简单实现

在linux中做c/c++开发经常会遇到一些不可预知的问题导致程序崩溃，同时崩溃后也没留下任何代码运行痕迹，因此，堆栈跟踪技术就显得非要重要了。本文将简单介绍linux中c/c++程序运行时堆栈获取，首先来看backtrace系列函数——使用范围适合于没有安装gdb或者想要快速理清楚函数调用顺序的情况 ，头文件execinfo.h

int backtrace (void **buffer, int size);

该函数用来获取当前线程的调用堆栈，获取的信息将会被存放在buffer中，它是一个指针数组。参数size用来指定buffer中可以保存多少个void* 元素。函数返回值是实际获取的指针个数，最大不超过size大小在buffer中的指针实际是从堆栈中获取的返回地址,每一个堆栈框架有一个返回地址。注意某些编译器的优化选项对获取正确的调用堆栈有干扰，另外内联函数没有堆栈框架；删除框架指针也会使无法正确解析堆栈内容。

char **backtrace_symbols (void *const *buffer, int size);

该函数将从backtrace函数获取的信息转化为一个字符串数组。参数buffer是从backtrace函数获取的数组指针，size是该数组中的元素个数(backtrace的返回值)，函数返回值是一个指向字符串数组的指针,它的大小同buffer相同。每个字符串包含了一个相对于buffer中对应元素的可打印信息。它包括函数名，函数的偏移地址和实际的返回地址。backtrace_symbols生成的字符串都是malloc出来的，但是不要最后一个一个的free，因为backtrace_symbols会根据backtrace给出的callstack层数，一次性的将malloc出来一块内存释放，所以，只需要在最后free返回指针就ok了。

void backtrace_symbols_fd (void *const *buffer, int size, int fd);  

该函数与backtrace_symbols函数具有相同的功能，不同的是它不会给调用者返回字符串数组，而是将结果写入文件描述符为fd的文件中，每个函数对应一行。它不需要调用malloc函数，因此适用于有可能调用该函数会失败的情况。

在c++程序中还需要关注一下函数：

/**
* 用于将backtrace_symbols函数所返回的字符串解析成对应的函数名，便于理解
* 头文件  cxxabi.h
* 名字空间	abi
* @param mangled_name a nul-terminated character string containing the name to be demangled.
* @param output_buffer  a region of memory, allocated with malloc, of *length bytes, into which the demangled name is stored. if output_buffer is not long enough, it is expanded using realloc. 
*     output_buffer may instead be null; in that case, the demangled name is placed in a region of memory allocated with malloc. 
* @param length  if length is non-null, the length of the buffer containing the demangled name is placed in *length.
* @param status  *status is set to one of the following values:
*        0: the demangling operation succeeded.
*       -1: a memory allocation failiure occurred.
*       -2: mangled_name is not a valid name under the c++ abi mangling rules.
*       -3: one of the arguments is invalid.
*/
char *__cxa_demangle (const char *mangled_name, char *output_buffer, size_t *length, int *status);

接下来一步一步的讲解如何使用以上这些函数来获取程序的堆栈

 一、第一版代码如下

#define max_frames 100
void getstacktrace (std::string* stack)
{
  void* addresses[max_frames];
  int size = backtrace (addresses, max_frames);
  std::unique_ptr<char*, void(*)(void*)> symbols {
    backtrace_symbols (addresses, size),
    std::free
  };
  for (int i = 0; i < size; ++i) {
    stack->append (symbols.get()[i]);
    stack->append ("\n");
  }
}

void testfunc (std::string& stack, int value)
{
  while (--value);
  getstacktrace (&stack);
}
int main(int argc, char* argv[])
{
  std::string stack;
  testfunc (stack, 5);
  std::cout << stack << std::endl;
  return 0;
}

编译成可执行文件stacktrace后执行输出如下结果：

./stacktrace(_z13getstacktracepss+0x27) [0x4035d5]
./stacktrace(_z8testfuncrssi+0x2a) [0x4036e6]
./stacktrace(main+0x2d) [0x403715]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf5) [0x7f7302027de5]
./stacktrace() [0x403139]

从输出的结果中可以得知程序的调用过程，但是看起来比较难以理解。让我们来稍微改动一下getstacktrace函数。

二、进阶版代码，在第一点中的代码基础上改动

void demanglesymbol (std::string* symbol)
{
  size_t size = 0;
  int status = -4;
  char temp[256] = {'\0'};
  //first, try to demangle a c++ name
  if (1 == sscanf (symbol->c_str (), "%*[^(]%*[^_]%[^)+]", temp)) {
    std::unique_ptr<char, void(*)(void*)> demangled {
      abi::__cxa_demangle (temp, null, &size, &status),
      std::free
    };
    if (demangled.get ()) {
      symbol->clear ();
      symbol->append (demangled.get ());
      return;
    }
  }
  //if that didn't work, try to get a regular c symbol
  if (1 == sscanf(symbol->c_str (), "%255s", temp)) {
    symbol->clear ();
    symbol->append (temp);
  }
}

void getstacktrace (std::string* stack)
{
  void* addresses[max_frames];
  int size = backtrace (addresses, max_frames);
  std::unique_ptr<char*, void(*)(void*)> symbols {
    backtrace_symbols (addresses, size),
    std::free
  };
  for (int i = 0; i < size; ++i) {
    std::string demangled (symbols.get()[i]);
    demanglesymbol (&demangled);
    stack->append (demangled);
    stack->append ("\n");
  }
}

该版本通过__cxa_demangle来将backtrace_symbols返回的字符串逐个解析成可以方便看懂的字符串，由于__cxa_demangle只能解析_z13getstacktracepss这样的字符串，所以使用sscanf来简单的截取backtrace_symbols函数返回的数据，当然，现在已不这么提倡使用sscanf函数了。编译成可执行文件stacktrace后执行输出如下结果：

getstacktrace(std::string*)
testfunc(std::string&, int)
./stacktrace(main+0x2d)
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf5)
./stacktrace()

从输出的结果中可以得知程序的调用过程，但是少了一些其他的信息，让我们来改动一下demanglesymbol函数

三、进进介版代码，在第一，第二点的代码基础上改动

// the prefix used for mangled symbols, per the itanium c++ abi:
// http://www.codesourcery.com/cxx-abi/abi.html#mangling
const char kmangledsymbolprefix[] = "_z";
// characters that can be used for symbols, generated by ruby:
// (('a'..'z').to_a+('a'..'z').to_a+('0'..'9').to_a + ['_']).join
const char ksymbolcharacters[] = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz0123456789_";
// demangles c++ symbols in the given text. example:
// "out/debug/base_unittests(_zn10stacktracec1ev+0x20) [0x817778c]"
// =>
// "out/debug/base_unittests(stacktrace::stacktrace()+0x20) [0x817778c]"
void demanglesymbol (std::string* symbol)
{
  std::string::size_type search_from = 0;
  while (search_from < symbol->size ()) {
    // look for the start of a mangled symbol from search_from
    std::string::size_type mangled_start = symbol->find (kmangledsymbolprefix, search_from);
    if (mangled_start == std::string::npos) {
      break; // mangled symbol not found
    }
    // look for the end of the mangled symbol
    std::string::size_type mangled_end = symbol->find_first_not_of (ksymbolcharacters, mangled_start);
    if (mangled_end == std::string::npos) {
      mangled_end = symbol->size ();
    }
    std::string mangled_symbol = std::move (symbol->substr (mangled_start, mangled_end - mangled_start));
    // try to demangle the mangled symbol candidate
    int status = -4; // some arbitrary value to eliminate the compiler warning
    std::unique_ptr<char, void(*)(void*)> demangled_symbol {
      abi::__cxa_demangle (mangled_symbol.c_str (), nullptr, 0, &status),
      std::free
    };
    // 0 demangling is success
    if (0 == status) {
      // remove the mangled symbol
      symbol->erase (mangled_start, mangled_end - mangled_start);
      // insert the demangled symbol
      symbol->insert (mangled_start, demangled_symbol.get ());
      // next time, we will start right after the demangled symbol
      search_from = mangled_start + strlen (demangled_symbol.get ());
    }
    else {
      // failed to demangle. retry after the "_z" we just found
      search_from = mangled_start + 2;
    }
  }
}

该版本的demanglesymbol函数与第二版的demanglesymbol函数稍有改动，该版本主要是找到_z13getstacktracepss这样的字符串给__cxa_demangle函数解析，最后将解析后的内容替换掉原来的内容，编译成可执行文件stacktrace后执行输出结果入下：

./stacktrace(getstacktrace(std::string*)+0x27) [0x403720]
./stacktrace(testfunc(std::string&, int)+0x2a) [0x4038c0]
./stacktrace(main+0x2d) [0x4038ef]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf5) [0x7fb9d560bde5]
./stacktrace() [0x403279]

以上输出结果在代码调试中能给我们带来很多的信息，但是还是少了一些辅助信息，例如：文件名、函数所在文件的代码行、进程或者线程号（这个在多线中很重要）。更多内容可以参考开源项目libunwind或者google-coredumper。

以上这篇浅谈linux系统中的异常堆栈跟踪的简单实现就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。