文章目录
前言
Linux x86_64 基于FP栈回溯请参考：Linux x86_64 dump_stack（）函数基于FP栈回溯
回溯（backtrace）是指当前线程中正在活动的函数调用列表。通常情况下，检查程序的回溯信息是通过使用外部调试器（如 gdb）来实现的。然而，有时候从程序内部以编程方式获取回溯信息也是很有用的，例如用于日志记录或诊断目的。
头文件 execinfo.h 声明了三个函数，用于获取和操作当前线程的回溯信息。
NAME
backtrace, backtrace_symbols, backtrace_symbols_fd - support for application self-debugging
SYNOPSIS
#include <execinfo.h>
int backtrace(void **buffer, int size);
char **backtrace_symbols(void *const *buffer, int size);
void backtrace_symbols_fd(void *const *buffer, int size, int fd);
使用它们的时候有一下几点需要我们注意的地方：
（1）backtrace的实现依赖于栈指针（fp寄存器），在gcc编译过程中任何非零的优化等级（-On参数）或加入了栈指针优化参数-fomit-frame-pointer后多将不能正确得到程序栈信息；
（2）backtrace_symbols的实现需要符号名称的支持，在gcc编译过程中需要加入-rdynamic参数；
（3）内联函数没有栈帧，它在编译过程中被展开在调用的位置；
（4）尾调用优化（Tail-call Optimization）将复用当前函数栈，而不再生成新的函数栈，这将导致栈信息不能正确被获取。
一、demo演示
#include <stdio.h>
#include <execinfo.h>
#include <stdlib.h>
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
void dump_stack(void)
{
//定义一个 void 类型的指针数组 array，用于存储返回地址。
void *array[16];
//使用 backtrace 函数获取当前程序的函数调用栈信息，并将返回地址存储在 array 数组中。
//返回实际存储的返回地址数量size。
size_t size = backtrace(array, ARRAY_SIZE(array));
//使用 backtrace_symbols 函数，将返回地址数组 array 和大小 size 作为参数，获取每个返回地址对应的函数名称，并将函数名称字符串数组的指针存储在 strings 中。
char **strings = backtrace_symbols(array, size);
size_t i;
//打印获取到的函数调用栈帧的数量，即 size。
printf("Obtained %zd stack frames.\n", size);
//遍历 strings 数组，逐行打印每个函数名称以及相关栈回溯信息。
for (i = 0; i < size; i++)
printf("%s\n", strings[i]);
free(strings);
}
void func_c(void)
{
dump_stack();
}
void func_b(void)
{
func_c();
}
void func_a(void)
{
func_b();
}
int main()
{
func_a();
return 0;
}
# gcc backtrace.c
# ./a.out
Obtained 7 stack frames.
./a.out() [0x40067c]
./a.out() [0x400701]
./a.out() [0x40070c]
./a.out() [0x400717]
./a.out() [0x400722]
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7f93f0d3e555]
./a.out() [0x400599]
# gcc -rdynamic backtrace.c
# ./a.out
Obtained 7 stack frames.
./a.out(dump_stack+0x1f) [0x4008ec]
./a.out(func_c+0x9) [0x400971]
./a.out(func_b+0x9) [0x40097c]
./a.out(func_a+0x9) [0x400987]
./a.out(main+0x9) [0x400992]
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7fec54d7d555]
./a.out() [0x400809]
要取符号名称。对于使用 GNU 链接器的系统，需要使用 -rdynamic 链接器选项：
-rdynamic
Pass the flag -export-dynamic to the ELF linker, on targets that support it. This instructs the linker to add all symbols, not only used ones, to the dynamic symbol
table. This option is needed for some uses of "dlopen" or to allow obtaining backtraces from within a program.
-rdynamic 是一个编译器选项，它会在支持的目标平台上将 -export-dynamic 标志传递给 ELF 链接器。这指示链接器将所有符号（而不仅仅是被使用的符号）添加到动态符号表中。
这个选项在某些情况下非常有用，特别是在以下两个方面：
（1）dlopen 函数的使用：dlopen 是一个动态链接库加载函数，它允许在程序运行时加载和链接共享库。当使用 dlopen 动态加载共享库时，如果需要从加载的库中调用函数，那么这些函数的符号必须在动态符号表中。通过使用 -rdynamic 选项，可以将所有符号（包括未被程序直接使用的符号）添加到动态符号表中，使得动态加载的库能够正确地解析和调用这些符号。
（2）在程序内部获取回溯信息：回溯（backtrace）是指在程序执行期间获取函数调用栈的信息。当使用像 backtrace 或 backtrace_symbols 这样的函数时，需要访问所有函数的符号信息，而不仅仅是已使用的符号。通过使用 -rdynamic 选项，可以确保所有符号都包含在动态符号表中，从而使得获取回溯信息时能够正确地解析函数名称。
二、函数解析
NAME
backtrace, backtrace_symbols, backtrace_symbols_fd - support for application self-debugging
SYNOPSIS
#include <execinfo.h>
int backtrace(void **buffer, int size);
char **backtrace_symbols(void *const *buffer, int size);
void backtrace_symbols_fd(void *const *buffer, int size, int fd);
2.1 backtrace函数
int backtrace(void **buffer, int size);
backtrace() 函数返回调用程序的函数调用栈，将其填充到由 buffer 指向的数组中。函数调用栈是指当前程序中正在活动的函数调用序列。buffer 数组中的每个项都是 void* 类型，表示对应堆栈帧的返回地址。
size 参数指定了 buffer 数组中可以存储的地址的最大数量。如果函数调用栈超过了指定的 size，那么将返回与最近的 size 个函数调用相对应的地址；若要获取完整的函数调用栈，请确保 buffer 和 size 足够大。
换句话说，如果函数调用栈超过了给定的 size，则最旧的函数调用将被截断，只有最近的函数调用的地址将存储在 buffer 中。如果需要完整的函数调用栈信息，应提供足够大的 buffer 和 size。
其声明：
/* Store up to SIZE return address of the current program state in
ARRAY and return the exact number of values stored. */
extern int backtrace (void **__array, int __size) __nonnull ((1));
backtrace函数的目的是将当前程序状态的返回地址存储在指定大小的数组中，并返回实际存储的返回地址数量。
返回类型：int，表示返回的是一个整数值，即实际存储的返回地址数量
参数：有两个参数
void **__array：指向 void* 类型的指针数组的指针，用于存储返回地址
int __size：表示存储空间的大小，即数组的大小
函数属性：__nonnull ((1)) 表示第一个参数 __array 不能为空指针
backtrace 函数是一个在调试和错误排查过程中常用的函数，它可以用于获取当前程序的函数调用栈信息。
该函数的作用是在运行时获取当前程序的返回地址，并将这些地址存储在指定的数组中。返回地址表示程序执行到当前位置时将要返回的地址，也就是当前函数执行完后将要执行的下一条指令的地址。
通过获取返回地址，并将其存储在数组中，我们可以构建一个表示函数调用栈的数据结构。函数调用栈是一个记录函数调用关系的堆栈结构，每个堆栈帧表示一个函数调用，其中包含函数的返回地址和相关的参数和局部变量等信息。
2.2 backtrace_symbols
char **backtrace_symbols(void *const *buffer, int size);
backtrace_symbols() 函数将由 buffer 返回的地址集合转换为一个字符串数组，用于以符号方式描述这些地址。size 参数指定了 buffer 中地址的数量。每个地址的符号表示包括函数名称（如果可以确定）、函数的十六进制偏移量以及实际的返回地址（以十六进制表示）。backtrace_symbols() 的函数结果是指向字符串指针数组的地址。该数组是由 backtrace_symbols() 动态分配的内存块，需要由调用者使用 free() 函数进行释放。（指针数组指向的字符串本身不需要也不应该被释放。）
使用 backtrace_symbols() 函数，可以将返回的地址转换为可读性更好的字符串形式，以便更方便地理解和分析函数调用栈信息。
需要注意的是，返回的字符串数组是通过 malloc() 动态分配的内存块，因此需要在使用完毕后手动释放，以避免内存泄漏。
其声明：
/* Return names of functions from the backtrace list in ARRAY in a newly
malloc()ed memory block. */
extern char **backtrace_symbols (void *const *__array, int __size)
__THROW __nonnull ((1));
backtrace_symbols函数用于从给定的返回地址数组中获取函数名称，并将这些函数名称以字符串数组的形式返回。
返回类型：char **，表示返回一个指向字符指针的指针，即字符串数组的指针
参数：有两个参数
void *const *__array：指向 void* 类型的指针数组的指针，用于存储返回地址
int __size：表示存储返回地址的数组的大小
函数属性：__THROW 表示函数不会抛出异常，__nonnull ((1)) 表示第一个参数 __array 不能为空指针
backtrace_symbols 函数是一个用于获取函数调用栈信息中函数名称的常用函数。它根据给定的返回地址数组，在新分配的内存块中动态生成一个字符串数组，其中每个字符串表示相应返回地址对应的函数名称。
函数调用栈是一个记录函数调用关系的堆栈结构，其中每个堆栈帧表示一个函数调用，包含函数的返回地址和其他相关信息。backtrace_symbols 函数可以通过返回地址数组来获取函数调用栈中每个函数的名称。
三、使用backtrace来定位段错误位置
一般导致segment fault错误的原因都是程序中非法访问了某块内存。当操作系统的内存保护机制发现某个进程访问了非法内存的时候会向此进程发送一个SIGSEGV信号，而如果此进程中没有相应的信号处理函数的话，就会执行默认的动作，一般都是直接杀死进程。这样进程就会在shell中提示一个segment fault并退出。
利用backtrace来定位段错误位置，当程序收到SIGSEGV信号（比如：内存访问越界）时，输出程序的调用堆栈，以方便定位崩溃点。
参考博客：在Linux中如何利用backtrace信息解决问题
3.1 静态链接情况下的段错误信息分析定位
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h> /* for signal */
#include <execinfo.h> /* for backtrace() */
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
void dump_stack(void)
{
void *array[16];
size_t size = backtrace(array, ARRAY_SIZE(array));
char **strings = backtrace_symbols(array, size);
size_t i;
printf("Obtained %zd stack frames.\n", size);
for (i = 0; i < size; i++)
printf("%s\n", strings[i]);
free(strings);
}
void signal_handler(int signo)
{
printf("=========>>>catch signal %d <<<=========\n", signo);
printf("Dump stack start...\n");
dump_stack();
printf("Dump stack end...\n");
signal(signo, SIG_DFL); /* 恢复信号默认处理 */
raise(signo); /* 重新发送信号 */
}
void func_c(void)
{
int *p = NULL;
*p = 1; //空指针赋值 -- 出错
}
void func_b(void)
{
func_c();
}
void func_a(void)
{
func_b();
}
int main(int argc, char *argv[])
{
signal(SIGSEGV, signal_handler); /* 为SIGSEGV信号安装新的处理函数 */
func_a();
return 0;
}
通常情况系，程序发生段错误时系统会发送SIGSEGV信号给程序，缺省处理是退出函数。我们可以使用 signal(SIGSEGV，&my_signal_handler)；函数来接管SIGSEGV信号的处理，程序在发生段错误后，自动调用我们准备好的函数，从而在那个函数里来获取当前函数调用栈。
/* Signals. */
......
#define SIGSEGV 11 /* Segmentation violation (ANSI). */
在 Linux 中，SIGSEGV 是一种表示段错误（Segmentation Fault）的信号。当程序访问无效的内存地址或者试图对只读内存进行写操作时，操作系统会发送 SIGSEGV 信号给程序，表示发生了段错误。
SIGSEGV 信号是由操作系统发送给进程的，它表示进程执行了非法的内存访问操作。当进程接收到 SIGSEGV 信号时，默认情况下会导致进程终止并生成一个核心转储文件（core dump），用于调试和分析。
上面导致 SIGSEGV 信号的情况：
解引用空指针：当程序试图访问空指针所指向的内存地址时，会触发 SIGSEGV 信号。
处理 SIGSEGV 信号的一种常见方法是使用信号处理函数（Signal Handler）。可以注册一个信号处理函数来捕获和处理 SIGSEGV 信号，从而在程序遇到段错误时采取适当的措施，例如记录错误信息、进行恢复操作或终止程序。
# gcc -g -rdynamic backtrace1.c
# ./a.out
=========>>>catch signal 11 <<<=========
Dump stack start...
Obtained 9 stack frames.
./a.out(dump_stack+0x1f) [0x4009dc]
./a.out(signal_handler+0x2e) [0x400a86]
/lib64/libc.so.6(+0x36400) [0x7f04e3b50400]
./a.out(func_c+0x10) [0x400abb]
./a.out(func_b+0x9) [0x400acc]
./a.out(func_a+0x9) [0x400ad7]
./a.out(main+0x23) [0x400afc]
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7f04e3b3c555]
./a.out() [0x4008f9]
Dump stack end...
段错误(吐核)
# addr2line -e a.out 0x400abb
backtrace1.c:40
backtrace1.c文件第40行：
*p = 1; //空指针赋值 -- 出错
NAME
addr2line - convert addresses into file names and line numbers
-e filename
--exe=filename
Specify the name of the executable for which addresses should be translated. The default file is a.out.
addr2line（地址到文件名和行号的转换工具）将地址转换为文件名和行号。给定一个可执行文件中的地址或可重定位对象中的节偏移量，它使用调试信息来确定与之相关联的文件名和行号。
要使用的可执行文件或可重定位对象可以通过 -e 选项指定。默认情况下，使用的文件是 a.out。要使用的可重定位对象中的节可以通过 -j 选项指定。
3.2 动态链接情况下的段错误信息分析定位
#include <stdio.h>
void func_c(void)
{
int *p = NULL;
*p = 1;
}
void func_b(void)
{
func_c();
}
void func_a(void)
{
func_b();
}
gcc -g -rdynamic func.c -fPIC -shared -o libfunc.so
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h> /* for signal */
#include <execinfo.h> /* for backtrace() */
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
void dump_stack(void)
{
void *array[16];
size_t size = backtrace(array, ARRAY_SIZE(array));
char **strings = backtrace_symbols(array, size);
size_t i;
printf("Obtained %zd stack frames.\n", size);
for (i = 0; i < size; i++)
printf("%s\n", strings[i]);
free(strings);
}
void signal_handler(int signo)
{
printf("=========>>>catch signal %d <<<=========\n", signo);
printf("Dump stack start...\n");
dump_stack();
printf("Dump stack end...\n");
signal(signo, SIG_DFL); /* 恢复信号默认处理 */
raise(signo); /* 重新发送信号 */
}
int main(int argc, char *argv[])
{
signal(SIGSEGV, signal_handler); /* 为SIGSEGV信号安装新的处理函数 */
func_a();
return 0;
}
# gcc -g -rdynamic backtrace2.c -L. -lfunc -Wl,-rpath=.
# ./a.out
=========>>>catch signal 11 <<<=========
Dump stack start...
Obtained 9 stack frames.
./a.out(dump_stack+0x1f) [0x40098c]
./a.out(signal_handler+0x2e) [0x400a36]
/lib64/libc.so.6(+0x36400) [0x7fcc5b063400]
./libfunc.so(func_c+0x10) [0x7fcc5b3fb705]
./libfunc.so(func_b+0x9) [0x7fcc5b3fb716]
./libfunc.so(func_a+0x9) [0x7fcc5b3fb721]
./a.out(main+0x28) [0x400a83]
/lib64/libc.so.6(__libc_start_main+0xf5) [0x7fcc5b04f555]
./a.out() [0x4008a9]
Dump stack end...
段错误(吐核)
出错的位置：
./libfunc.so(func_c+0x10) [0x7fcc5b3fb705]
# nm libfunc.so | grep func_c
00000000000006f5 T func_c
0x6f5 + 0x10 = 0x705
# addr2line -e libfunc.so 0x705
func.c:6
参考资料
在Linux中如何利用backtrace信息解决问题
Linux 栈回溯
Linux下使用backtrace捕获死机堆栈信息
139
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
