打印调用栈的问题

kaka1902

最近遇到一个难题：
在代码crash的时候，我有一段代码会捕获信号后打印调用栈：
调用栈是采用__build_frame_address()来获取当前调用地址的
{
int          n;
  unsigned int fpadd, fpaddnext;
  unsigned int stackadd = (unsigned int)&fpadd;

  fpadd = (unsigned int)__builtin_frame_address(1);

  for ( n = 0; n < nb; n++ )
    {
   
    tab[n]    = (void *)*(((unsigned int *)fpadd) + 1);
    fpaddnext = *(unsigned int *)fpadd;

    if ( (fpaddnext <= fpadd) || (fpaddnext > (stackadd + 0x10000)))
      {
      return (n + 1); // Next fp is outside the stack or too far
      }
    fpadd = fpaddnext;
    }
}

但是我测试了一下发现每次只能打一级调用的函数，再往下就没有了

这个问题可能跟什么相关？麻烦各位指点一下！

kaka1902

补充一下
编译环境是ARM的交叉编译工具链？
有没有可能是工具链带的libc库编译选项指定的不对？

idi0t

不懂也，不知道lZ的环境里有没有backtrace可以用

wps103

试过backtrace(), 也是打不出来东西
感觉libc的栈都无法打印，难不成真是工具链提供libc编译的时候没有添加-rdynamic -ldl？

井蛙夏虫

回复 4# wps103
posix标准保证能在信号处理函数中安全调用的函数没有__builtin_frame_address和backtrace,所以这些是未定义行为。(man 7 signal)

wps103

不在信号处理函数里面实现
做了一个实验，在宿主机上和ARM上分别测试一下代码：
宿主机：ubuntu

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

复制代码

编译：
宿主机：
gcc backtrace.c -rdynamic -g -o backtrace
交叉编译：
arm-linux-cc backtrace.c -rdynamic -g -o backtrace

运行结果：
宿主机：
stackstrace begin:
./backtrace(print_stacktrace+0x26) [0x80487ab]
./backtrace(fun1+0x33) [0x8048769]
./backtrace(fun2+0xb) [0x8048776]
./backtrace(fun3+0xb) [0x8048783]
./backtrace(main+0xb) [0x804872f]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3) [0x83d113]
./backtrace() [0x8048691]


ARM：
stackstrace begin:
/lib/ld-linux.so.3 [0x40096000]

看起来跟安全性没什么关系，可能还是编译选项的问题？
大牛们请再指教！

myworkstation

回复 1# kaka1902


    和你传的参数１有关吧。只处理一层的frame stack。__builtin_frame_address(1)。改大点试试

wps103

回复 7# myworkstation

This function is similar to __builtin_return_address, but it returns the address of the function frame rather than the return address of the function. Calling __builtin_frame_address with a value of 0 yields the frame address of the current function, a value of 1 yields the frame address of the caller of the current function, and so forth.

The frame is the area on the stack which holds local variables and saved registers. The frame address is normally the address of the first word pushed on to the stack by the function. However, the exact definition depends upon the processor and the calling convention. On the Motorola 68000, if the function has a frame, then __builtin_frame_address will return the value of the frame pointer register a6 if level is 0.

This function should be used with a nonzero argument only for debugging purposes.

从解释来看，入参并不是指定需要获取多少个stack frame，而是指定获取第几级的调用stack frame
因此改大应该也没有什么好处，不过我可以试下认为多取几级堆栈，看看究竟有没有东西


   

井蛙夏虫

回复 8# wps103
x86平台能打印，你改改试试

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <dlfcn.h>
   
4. #include <execinfo.h>
   
5. 
   
6. #define BACKTRACE_MAXDEPTH 32
   
7. 
   
8. struct layout               // 来自glibc-2.16.0/sysdeps/generic
   
9. {
   
10.       void *__unbounded next;
    
11.       void *__unbounded return_address;
    
12. };
    
13. 
    
14. int my_backtrace(void **arr, int maxsize)
    
15. {
    
16.     int cnt = 0;
    
17.     void *fp = __builtin_frame_address(0);
    
18.     struct layout *lp = (struct layout *)fp;
    
19.     while (cnt < maxsize)
    
20.     {
    
21. 
    
22.         arr[cnt++] = lp->return_address;
    
23.         if (!lp->next)
    
24.         {
    
25.             break;
    
26.         }
    
27.         lp = (struct layout*)lp->next;
    
28.     }
    
29.     return cnt;
    
30. }
    
31. 
    
32. 
    
33. void my_backtrace_symbols(void* const* arr, int size)
    
34. {
    
35.     for (int i = 1; i < size; ++i)
    
36.     {
    
37.         Dl_info info;
    
38.         if (dladdr(arr[i], &info))
    
39.             fprintf(stderr, "%s(%s+0x%x) [%p]\n", info.dli_fname, info.dli_sname, (int)arr[i] - (int)info.dli_saddr, arr[i]);
    
40.         else
    
41.             fprintf(stderr, "[%p]\n", arr[i]);
    
42.     }
    
43. }
    
44. 
    
45. void print_my_stacktrace()
    
46. {
    
47.     void * array[BACKTRACE_MAXDEPTH];
    
48.     int i=0;
    
49.     int stack_num = my_backtrace(array, BACKTRACE_MAXDEPTH);
    
50.     char ** stacktrace = backtrace_symbols(array, stack_num);
    
51.     for (i = 0; i < stack_num; ++i)
    
52.     {
    
53.         fprintf(stderr,"%s\n", stacktrace[i]);
    
54.     }
    
55.     free(stacktrace);
    
56. }
    
57. 
    
58. void fun1()
    
59. {
    
60.     fprintf(stderr,"stackstrace begin:\n");
    
61.     print_my_stacktrace();
    
62. }
    
63. 
    
64. void fun2()
    
65. {
    
66.     fun1();
    
67. }
    
68. 
    
69. void fun3()
    
70. {
    
71.     fun2();
    
72. }
    
73. 
    
74. int main(void)
    
75. {
    
76.     fun3();
    
77.     return 0;
    
78. }
    

复制代码

编译指令

1. gcc print_backtrace.c -ldl -rdynamic -D_GNU_SOURCE -std=gnu99 -Wall

复制代码

结果

1. stackstrace begin:
   
2. ./a.out(print_my_stacktrace+0x26) [0x80488a5]
   
3. ./a.out(fun1+0x33) [0x804893a]
   
4. ./a.out(fun2+0xb) [0x8048947]
   
5. ./a.out(fun3+0xb) [0x8048954]
   
6. ./a.out(main+0xb) [0x8048961]
   
7. /lib/libc.so.6(__libc_start_main+0xf3) [0x4a0066b3]
   

复制代码