Linux下查看函数被那些函数调用过？

 一、问题

有个打印log的函数，想知道该函数执行的时候，之前执行了哪些函数?

二、分析

在应用程序打印函数栈需要通过函数backtrace()，该函数对应头文件如下：

1. #include <execinfo.h> 

1、三个与打印调用栈相关的函数

打印函数栈需要使用到以下3个函数

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

函数功能：用于获取当前线程的调用堆栈。参数：buffer：它是一个指针数组，函数获取的当前线程的调用堆栈将会被存放在buffer中。在buffer中的指针实际是从堆栈中获取的返回地址,每一个堆栈 框架有一个返回地址。size：用来指定buffer中可以保存多少个void*元素。返回值：实际获取的指针个数,最大不超过size大小。

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

函数功能：将从backtrace函数获取的信息转化为一个字符串数组。参数：buffer：从backtrace函数获取的数组指针。size：是该数组中的元素个数(backtrace函数的返回值)。返回值：是一个指向字符串数组的指针,它的大小同buffer相同。每个字符串包含了一个相对于buffer中对应元素的 可打印信息。它包括函数名，函数的偏移地址，和实际的返回地址。

注：

• 1、只有使用ELF二进制格式的程序才能获取函数名称和偏移地址。在其他系统，只有16进制的返回地址能被获取。另外,需要传递相应的标志给链接器,以能支持函数名功能即编译选项-rdynamic。
• 2、backtrace_symbols生成的字符串都是malloc出来的，最后需要free该块内存。

1. void backtrace_symbols_fd (void *const *buffer, int size, int fd) 

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

2. 链接库

在编译的时候需要加上**-rdynamic**选项。

1. -rdynamic 
2.      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. 

该选项让链接器将所有符号添加到动态符号表中，这样才能将函数地址翻译成函数名，否则打印的结果是不会打印函数名的。

另外，这个选项不会处理static函数，所以，static函数的符号无法得到。

3. 举例

1. #include <execinfo.h> 
2. #include <stdio.h> 
3. #include <stdlib.h> 
4. #include <unistd.h> 
5.   
6. void fun1(); 
7. void fun2(); 
8. void fun3(); 
9.   
10. void print_stacktrace(); 
11.   
12. void print_stacktrace() 
13. { 
14.     int size = 16; 
15.     void * array[100]; 
16.   
17.     int stack_num = backtrace(array, size); 
18.   
19.  char ** stacktrace = backtrace_symbols(array, stack_num); 
20.   
21.  backtrace_symbols_fd(array,size,STDOUT_FILENO); 
22.   
23. #if 0 
24.     char ** stacktrace = backtrace_symbols(array, stack_num); 
25.   
26.     for (int i = 0; i < stack_num; ++i) 
27.     { 
28.         printf("%s\n", stacktrace[i]); 
29.     } 
30.     free(stacktrace); 
31. #endif 
32. } 
33. void fun1() 
34. { 
35.     printf("stackstrace begin:\n"); 
36.     print_stacktrace(); 
37. } 
38. void fun2() 
39. { 
40.     fun1(); 
41. } 
42. void fun3() 
43. { 
44.     fun2(); 
45. } 
46. int main() 
47. { 
48.     fun3(); 
49. } 
50.   

编译运行gcc编译时加上-rdynamic参数，通知链接器支持函数名功能(不加-rdynamic参数则无函数名打印)：

1. gcc 123.c -o run -rdynamic -g 

执行结果：

4. 补充 address2line

同一个函数可以在代码中多个地方调用，如果我们只是知道函数，要想知道在哪里调用了该函数，可以通过address2line命令来完成，我们用第2步中编译出来的test2来做实验(address2line的-f选项可以打出函数名, -C选项也可以demangle)：

address2line

三、内核代码中如何打印函数栈?

在Linux内核中提供了一个可以打印出内核调用堆栈的函数 dump_stack()。

该函数在我们调试内核的过程中可以打印出函数调用关系，该函数可以帮助我们进行内核调试，以及让我们了解内核的调用关系。

1. 头文件

该函数头文件为：

1. #include <asm/ptrace.h> 

使用方式：

直接在想要查看的函数中添加

1. dump_stack(); 

2. 举例

测试代码如下：hello.c

1.  1 #include <linux/init.h> 
2.  2 #include <linux/module.h> 
3.  3 #include <asm/ptrace.h> 
4.  4  
5.  6 MODULE_LICENSE("GPL"); 
6.  7 MODULE_AUTHOR("PD"); 
7.  8 void aaa(int a); 
8.  9 void bbb(int b); 
9. 10 void ccc(int c); 
10. 11 
11. 14 void ccc(int c) 
12. 15 { 
13. 16     printk(KERN_SOH"cccc \n"); 
14. 17     dump_stack(); 
15. 18     printk("c is %d\n",c); 
16. 19 } 
17. 20 void bbb(int b) 
18. 21 { 
19. 22     int c = b + 10; 
20. 23     printk(KERN_SOH"bbbb \n"); 
21. 24     ccc(c); 
22. 25 } 
23. 26 void aaa(int a) 
24. 27 { 
25. 28     int b = a + 10; 
26. 29     printk(KERN_SOH"aaaa \n"); 
27. 30     bbb(b); 
28. 31 } 
29. 32  
30. 34 static int hello_init(void) 
31. 35 { 
32. 36     int a = 10;                                                                 
33. 37  
34. 38     aaa(a); 
35. 39     printk(KERN_SOH"hello_init \n"); 
36. 40  
37. 41     return 0; 
38. 42 } 
39. 43 static void hello_exit(void) 
40. 44 { 
41. 45     printk("hello_exit \n"); 
42. 46     return; 
43. 47 } 
44. 48  
45. 49 module_init(hello_init); //insmod 
46. 50 module_exit(hello_exit);//rmmod 

Makefile

1. ifneq ($(KERNELRELEASE),) 
2. obj-m:=hello.o 
3. else 
4. KDIR :=/lib/modules/$(shell uname -r)/build 
5. PWD  :=$(shell pwd) 
6. all: 
7.  make -C $(KDIR) M=$(PWD) modules 
8. clean: 
9.  rm -f *.ko *.o *.mod.o *.symvers *.cmd  *.mod.c *.order 
10. endif 

编译安装模块

1. dmesg -c 
2. make 
3. insmod hello.ko 

【注意】 都在root权限下操作

结果

可以看到在函数ccc中使用dump_stack()打印出了ccc的函数调用栈。

在内核开发中，我们可以使用dump_stack()来打印相关信息，同时在内核源码学习中也可以用来了解函数调用关系。

原文地址：https://mp.weixin.qq.com/s/odyYVeDpO_1NcS8U_QE0AQ