首页 > 代码库 > 栈回溯技术

栈回溯技术

 转载于:http://blog.csdn.net/yangzhiloveyou/article/details/9042137

1.    前言

段错误、非法地址访问等问题导致程序崩溃的现象屡屡发生,如果能找到发生错误的函数,往往一眼就能看出BUG所在——对于这类比较简单的问题,比如使用空指针进行读写等,利用栈回溯技术可以很快定位。但是对于数组溢出、内存泄漏等问题导致的程序错误,往往隐藏很深,它们并不当场发作,即使我们一步一步跟踪到发生错误的语句时,也经常会让人觉得“这个地方根本不可能出错啊”——错误在很早以前就隐藏下来了,只不过是这个“不可能出错的语句”触发了它。了解栈的作用、堆的实现,可以让我们脑中对程序的运行、函数的调用、变量的操作有个感官的了解,对解决这类问题会有所帮助。

 

       关键词:堆栈回溯堆实现栈作用

2.    栈的作用

一个程序包含代码段、数据段、BSS段、堆、栈;其中数据段用来中存储初始值不为0的全局数据,BSS段用来存储初始值为0的全局数据,堆用于动态内存分配,栈用于实现函数调用、存储局部变量。比如对于如下程序:

程序1 section.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 int *g_pBuf;

06 int g_iCount = 10;

07

08 int main(int argc, char **argv)

09 {

10     char str[2];

11     g_pBuf = malloc(g_iCount);

12     printf("Address of main       = 0x%08x\n", (unsigned int)main);

13     printf("Address of g_pBuf     = 0x%08x\n", (unsigned int)&g_pBuf);

14     printf("Address of g_iCount   = 0x%08x\n", (unsigned int)&g_iCount);

15     printf("Address of malloc buf  = 0x%08x\n", (unsigned int)g_pBuf);

16     printf("Address of local buf str  = 0x%08x\n", (unsigned int)str);

17

18     return 0;

19 }

使用如下命令编译得到可执行文件section,反汇编文件section.dis:

arm_v5t_le-gcc  -o  section  section.c -static

arm_v5t_le-objdump -D section > section.dis

 

PU S980上的linux环境下,这个程序的输出结果为:

Address of main       = 0x000082b8

Address of g_pBuf     = 0x00082998

Address of g_iCount   = 0x00080bd0

Address of malloc buf  = 0x00083f80

Address of local buf str  = 0xbec80b36

 

        其中main函数的地址为0x000082b8,它处于代码段中;全局变量g_pBuf位于BSS段;全局变量g_iCount位于数据段;使用malloc分配出来的内存地址为0x00083f80,它位于堆中;局部变量str数组的开始地址为0xbec80b36,位于栈中。它们的分布图示如下:

 

1 程序各段示意图

 

栈的作用有二:

①     保存调用者的环境——某些寄存器的值、返回地址

②     存储局部变量

 

现在通过一个简单的例子来说明栈的作用:

程序2 call.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 void A(int a);

06 void B(int b);

07 void C(int c);

08

09 void A(int a)

10 {

11     printf("%d: A call B\n", a);

12     B(2);

13 }

14

15 void B(int b)

16 {

17     printf("%d: B call C\n", b);

18     C(3);

19 }

20

21 void C(int c)

22 {

23     printf("%d: function C\n", c);

24 }

25

26 int main(int argc, char **argv)

27 {  

28     A(1);

29     return 0;

30 }

 

使用如下命令编译得到可执行文件call,反汇编文件call.dis:

arm_v5t_le-gcc -o  call  call.c  -static

arm_v5t_le-objdump -D call > call.dis

 

此程序的调用关系为main > A > B > C,现在来看看栈如何变化:

 

2 函数调用中栈的变化

 

       上图中,main、A、B、C四个函数的栈大小都是16字节,返回地址都存在栈偏移地址为16的地方。我们是如何知道这点的呢?需要阅读反汇编代码:

……

000082b8 <A>:

    82b8:       e92d4800        push    {fp, lr}

    82bc:       e28db004        add     fp, sp, #4      ; 0x4

    82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

    82c4:       e50b0008        str     r0, [fp, #-8]

    82c8:       e59f0014        ldr     r0, [pc, #20]   ; 82e4 <A+0x2c>

    82cc:       e51b1008        ldr     r1, [fp, #-8]

    82d0:       eb0003f8        bl      92b8 <_IO_printf>

    82d4:       e3a00002        mov     r0, #2  ; 0x2

    82d8:       eb000002        bl      82e8 <B>

    82dc:       e24bd004        sub     sp, fp, #4      ; 0x4

    82e0:       e8bd8800        pop     {fp, pc}

    82e4:       00064584        .word   0x00064584

 

000082e8 <B>:

    82e8:       e92d4800        push    {fp, lr}

    82ec:       e28db004        add     fp, sp, #4      ; 0x4

    82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

    82f4:       e50b0008        str     r0, [fp, #-8]

    82f8:       e59f0014        ldr     r0, [pc, #20]   ; 8314 <B+0x2c>

    82fc:       e51b1008        ldr     r1, [fp, #-8]

    8300:       eb0003ec        bl      92b8 <_IO_printf>

    8304:       e3a00003        mov     r0, #3  ; 0x3

    8308:       eb000002        bl      8318 <C>

    830c:       e24bd004        sub     sp, fp, #4      ; 0x4

    8310:       e8bd8800        pop     {fp, pc}

    8314:       00064594        .word   0x00064594

 

00008318 <C>:

    8318:       e92d4800        push    {fp, lr}

    831c:       e28db004        add     fp, sp, #4      ; 0x4

    8320:       e24dd008        sub     sp, sp, #8      ; 0x8

    8324:       e50b0008        str     r0, [fp, #-8]

    8328:       e59f000c        ldr     r0, [pc, #12]   ; 833c <C+0x24>

    832c:       e51b1008        ldr     r1, [fp, #-8]

    8330:       eb0003e0        bl      92b8 <_IO_printf>

    8334:       e24bd004        sub     sp, fp, #4      ; 0x4

    8338:       e8bd8800        pop     {fp, pc}

    833c:       000645a4        .word   0x000645a4

 

00008340 <main>:

    8340:       e92d4800        push    {fp, lr}

    8344:       e28db004        add     fp, sp, #4      ; 0x4

    8348:       e24dd008        sub     sp, sp, #8      ; 0x8

    834c:       e50b0008        str     r0, [fp, #-8]

    8350:       e50b100c        str     r1, [fp, #-12]

8354:       e3a00001        mov     r0, #1  ; 0x1

8358:       ebffffd6        bl      82b8 <A>

835c:       e3a03000        mov     r3, #0  ; 0x0

8360:       e1a00003        mov     r0, r3

8364:       e24bd004        sub     sp, fp, #4      ; 0x4

8368:       e8bd8800        pop     {fp, pc}

 

       上面红色的指令:

push    {fp, lr}”表示将fp,lr 寄存器进行压栈,同时 sp – 4×2,即向下移动 8 个字节。

sub     sp, sp, #8”表示将 sp 寄存器的值减 8,即向下移动 8 个字节。

pop     {fp, pc}”表示弹出栈顶值到 fp, lr 寄存器,同时 sp+4×2,即向上移动 8 个字节。

       局部变量也是存储在栈中,当一个函数的局部变量越多,它的栈越大。

 

       从上图可知:栈中保存着函数的返回地址、局部变量等,那么我们可以从这些返回地址来确定函数的调用关系、调用顺序。这就是下节介绍的栈回溯。

3.    栈回溯

将程序2稍加修改,见程序3第23、24、30、32四行:

程序3 stack.c

01 #include <stdlib.h>

02 #include <string.h>

03 #include <stdio.h>

04

05 void A(int a);

06 void B(int b);

07 void C(int c);

08

09 void A(int a)

10 {

11     printf("%d: A call B\n", a);

12     B(2);

13 }

14

15 void B(int b)

16 {

17     printf("%d: B call C\n", b);

18     C(3);

19 }

20

21 void C(int c)

22 {

23     char *p = (char *)c;

24     *p = ‘A’;

25     printf("%d: function C\n", c);

26 }

27

28 int main(int argc, char **argv)

29 {   

30      char a;

31     A(1);

32     C(&a);

33     return 0;

34 }

 

       第23、24两行必然导致段错误而使得程序崩溃,linux内核当发现发生段错误时,会打印出栈信息。我们可以使用栈回溯的方法找到发生错误的原因。

使用如下命令编译得到可执行文件stack,反汇编文件stack.dis:

       arm_v5t_le-gcc -g -o stack stack.c -static

       arm_v5t_le-objdump -dS stack > stack.dis

 

运行结果如下(注意:如果你是通过telnet来运行程序,可以使用dmesg命令看到这些栈信息):

/ # ./stack

1: A call B

2: B call C

<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

<1>pgd = c3ca0000

<1>[00000003] *pgd=81b86031, *pte=00000000, *ppte=00000000

<4>

<4>Pid: 662, comm:                stack

<4>CPU: 0

<4>PC is at 0x8338

<4>LR is at 0x830c

<4>pc : [<00008338>]    lr : [<0000830c>]    Not tainted

<4>sp : be897af0  ip : 00000001  fp : be897b04

<4>r10: 00000000  r9 : 00008ac8  r8 : 00008b10

<4>r7 : 00000000  r6 : 00000000  r5 : 00081fe8  r4 : 00000000

<4>r3 : 00000041  r2 : 00000003  r1 : 00000000  r0 : 00000003

<4>Flags: nZCv  IRQs on  FIQs on  Mode USER_32  Segment user

<4>Control: 5317F

<4>Table: 83CA0000  DAC: 00000015

<4>usr stack info

<4>stack mem: sp = be897af0

4> be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

   247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

   00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 00008354

   00004c69 6e757800 000000

<4> be897b24 03be897b 0003be89 000003be 00000003 b4000000 45b40000 0645b400

<4> 000645b4 03000645 00030006 00000300 00000003 14000000 7b140000 897b1400

<4> be897b14 0cbe897b 830cbe89 00830cbe 0000830c a4000083 45a40000 0645a400

……

<4>Backtrace: [<000082fc>] (0x82fc) from [<be897b14>] (0xbe897b14)

<4>Backtrace aborted due to bad frame pointer <000645b4>

<4>Code: e51b3010 e50b3008 e51b2008 e3a03041 (e5c23000)

~ $

 

上面的蓝色部分

<4>PC is at 0x8338

<4>LR is at 0x830c

表示导致崩溃的指令的地址为0x8338,返回地址为0x830c。一个典型的进程的地址空间为:

~ $ cat /proc/660/maps

00008000-00112000 r-xp 00000000 1f:07 27         /bin/busybox

0011a000-0011b000 rw-p 0010a000 1f:07 27         /bin/busybox

0011b000-001ce000 rwxp 0011b000 00:00 0          [heap]

40000000-40001000 rw-p 40000000 00:00 0

bea24000-bea4e000 rwxp bea24000 00:00 0          [stack]

 

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x8338 -f -e stack

C

/home/sanya/yjt/bt/stack.c:24

linux-S980:/home/sanya/yjt/bt #

 

结合此程序的反汇编程序进行回溯:

PC is at 0x8338所在函数的部分反汇编代码摘录如下:

00008318 <C>:

 

void C(int c)

{

    8318:       e92d4800        push    {fp, lr}

    831c:       e28db004        add     fp, sp, #4      ; 0x4

    8320:       e24dd010        sub     sp, sp, #16     ; 0x10

    8324:       e50b0010        str     r0, [fp, #-16]

    char *p = (char *)c;

    8328:       e51b3010        ldr     r3, [fp, #-16]

    832c:       e50b3008        str     r3, [fp, #-8]

    *p = ‘A‘;

    8330:       e51b2008        ldr     r2, [fp, #-8]

    8334:       e3a03041        mov     r3, #65 ; 0x41

PC->8338:       e5c23000        strb    r3, [r2]

    printf("%d: function C\n", c);

    833c:       e59f000c        ldr     r0, [pc, #12]   ; 8350 <C+0x38>

    8340:       e51b1010        ldr     r1, [fp, #-16]

    8344:       eb0003e3        bl      92d8 <_IO_printf>

}

    8348:       e24bd004        sub     sp, fp, #4      ; 0x4

    834c:       e8bd8800        pop     {fp, pc}

8350:       000645c4        .word   0x000645c4

 

下面对涉及的每个函数进行分析:

1.  函数C的堆栈:

  8318:       e92d4800        push    {fp, lr}

  831c:       e28db004        add     fp, sp, #4      ; 0x4

  8320:       e24dd010        sub     sp, sp, #16     ; 0x10

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

 

可知 lr 为 0x0000830c,根据这个地址值,

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x830c -f -e stack

B

/home/sanya/yjt/bt/stack.c:19

linux-S980:/home/sanya/yjt/bt #

在stack.dis中可以再次找到这个地址处于函数B的范围内。

 

2. 函数B的堆栈:

函数B的汇编指令如下:

void B(int b)

{

    82e8:       e92d4800        push    {fp, lr}

    82ec:       e28db004        add     fp, sp, #4      ; 0x4

    82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

    82f4:       e50b0008        str     r0, [fp, #-8]

    printf("%d: B call C\n", b);

    82f8:       e59f0014        ldr     r0, [pc, #20]   ; 8314 <B+0x2c>

    82fc:       e51b1008        ldr     r1, [fp, #-8]

    8300:       eb0003f4        bl      92d8 <_IO_printf>

    C(3);

    8304:       e3a00003        mov     r0, #3  ; 0x3

    8308:       eb000002        bl      8318 <C>

}

    830c:       e24bd004        sub     sp, fp, #4      ; 0x4

    8310:       e8bd8800        pop     {fp, pc}

8314:       000645b4        .word   0x000645b4

 

 

       由

82e8:       e92d4800        push    {fp, lr}

    82ec:       e28db004        add     fp, sp, #4      ; 0x4

82f0:       e24dd008        sub     sp, sp, #8      ; 0x8

可知函数B的堆栈大小为16字节,函数B执行完后的返回地址 lr 存储在其堆栈偏移地址最外层。函数B栈的的数据紧挨着函数C的栈,取出罗列如下:

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

从上面信息可以知道,函数B的返回地址lr 为 000082dc,根据这个地址值,

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x82dc -f -e stack

A

/home/sanya/yjt/bt/stack.c:13

stack.dis可知处于函数A的地址范围内。

 

3. 函数A的堆栈:

函数A的汇编指令如下:

void A(int a)

{

    82b8:       e92d4800        push    {fp, lr}

    82bc:       e28db004        add     fp, sp, #4      ; 0x4

    82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

    82c4:       e50b0008        str     r0, [fp, #-8]

    printf("%d: A call B\n", a);

    82c8:       e59f0014        ldr     r0, [pc, #20]   ; 82e4 <A+0x2c>

    82cc:       e51b1008        ldr     r1, [fp, #-8]

    82d0:       eb000400        bl      92d8 <_IO_printf>

    B(2);

    82d4:       e3a00002        mov     r0, #2  ; 0x2

    82d8:       eb000002        bl      82e8 <B>

}

    82dc:       e24bd004        sub     sp, fp, #4      ; 0x4

    82e0:       e8bd8800        pop     {fp, pc}

    82e4:       000645a4        .word   0x000645a4

 

       由

82b8:       e92d4800        push    {fp, lr}

    82bc:       e28db004        add     fp, sp, #4      ; 0x4

    82c0:       e24dd008        sub     sp, sp, #8      ; 0x8

可知函数A的堆栈大小为16字节,函数B执行完后的返回地址 lr 存储在其堆栈偏移地址最外层。函数A栈的的数据紧挨着函数B的栈,取出罗列如下:

be897b24 03000000 b4450600 03000000 147b89be 0000830c a4450600 02000000

247b89be 000082dc 00000000 01000000 3c7b89be 00008370 647e89be 01000000

00000000 108b0000 00000000 000085b4 00000000 647e89be 01000000 54830000

00004c69 6e757800 000000

       从上面信息可以知道,函数A的返回地址为0x00008370

linux-S980:/home/sanya/yjt/bt # arm_v5t_le-addr2line 0x8370 -f -e stack

main

/home/sanya/yjt/bt/stack.c:32

linux-S980:/home/sanya/yjt/bt #

stack.dis可知处于函数main的地址范围内。

 

       至此,可以知道main调用A、A调用B、B再调用C时,在函数C中导致程序崩溃。现在认真看一下函数C:

21 void C(int c)

22 {

23     char *p = (char *)c;

24     *p = ‘A’;

25     printf("%d: function C\n", c);

26 }

       这个函数太过简单,可以一眼就知道第23、24行代码有问题。但是如果函数C有上千行代码呢?除了睁大眼睛检查C代码外,我们还可以根据它的反汇编码来差错——内核打印出来的栈信息的前面还有些有用的信息:

<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

<1>pgd = c3ca0000

<1>[00000003] *pgd=81b86031, *pte=00000000, *ppte=00000000

<4>

<4>Pid: 662, comm:                stack

<4>CPU: 0

<4>PC is at 0x8338

<4>LR is at 0x830c

<4>pc : [<00008338>]    lr : [<0000830c>]    Not tainted

<4>sp : be897af0  ip : 00000001  fp : be897b04

<4>r10: 00000000  r9 : 00008ac8  r8 : 00008b10

<4>r7 : 00000000  r6 : 00000000  r5 : 00081fe8  r4 : 00000000

<4>r3 : 00000041  r2 : 00000003  r1 : 00000000  r0 : 00000003

<4>Flags: nZCv  IRQs on  FIQs on  Mode USER_32  Segment user

<4>Control: 5317F

 

       现在回过头来看看函数C的反汇编码,从中找出出错的原因:

00008318 <C>:

 

void C(int c)

{

    8318:       e92d4800        push    {fp, lr}

    831c:       e28db004        add     fp, sp, #4      ; 0x4

    8320:       e24dd010        sub     sp, sp, #16     ; 0x10

    8324:       e50b0010        str     r0, [fp, #-16]

    char *p = (char *)c;

    8328:       e51b3010        ldr     r3, [fp, #-16]

    832c:       e50b3008        str     r3, [fp, #-8]

    *p = ‘A‘;

    8330:       e51b2008        ldr     r2, [fp, #-8]

    8334:       e3a03041        mov     r3, #65 ; 0x41

    8338:       e5c23000        strb    r3, [r2]

    printf("%d: function C\n", c);

    833c:       e59f000c        ldr     r0, [pc, #12]   ; 8350 <C+0x38>

    8340:       e51b1010        ldr     r1, [fp, #-16]

    8344:       eb0003e3        bl      92d8 <_IO_printf>

}

    8348:       e24bd004        sub     sp, fp, #4      ; 0x4

    834c:       e8bd8800        pop     {fp, pc}

8350:       000645c4        .word   0x000645c4

 

       出错的指令为“8338:       e5c23000        strb    r3, [r2]”,它将寄存器r3的值存到地址(r2)中,只存储1个字节。根据内核打印出来的寄存器值可知r3 : 00000041  r2 : 00000003,写地址为0x03,当然<2>stack: unhandled page fault (11) at 0x00000003, code 0x817

——这不是可写的地址。

       阅读汇编代码是件困难的事情,没有其他办法时再用这方法吧。

栈回溯技术