linux进程地址空间详解（转载）

linux进程地址空间详解（转载）

 在前面的《对一个程序在内存中的分析 》中很好的描述了程序在内存中的布局，这里对这个结果做些总结和实验验证。下面以Linux为例（实验结果显示windows上的结果也一样）。

       我们还是利用前面看到过的这个图，如下图：32位X86机器的内存布局图，内存主要分为栈、堆、BSS段、数据段、代码段5个段。

 

       代码段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。程序在被载入内存后，会被分为很多小的区（section），有一个rodata区（也就是常量区），常量区的数据内存中的位置为代码段，存放的数据为字符串、const修饰的常量（全局的或是静态的，局部的存放在栈中）、如Char* s=”Hello,World”，那么指针s所指向的字符串”Hello,World“存放在rodata区，而这个字符串的地址也就是指针s存放在数据段中（程序载入内存中为.data区）。再如，static char *const s=”hello,world";那么这时候不仅"hello，world"字符串存放在rodata区，指针s也同样。

 

       数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量或者静态变量的一块内存区域。数据段属于静态内存分配。原则上数据段所对应的内存区数据是可以改变的。这里没有提到局部变量，这是因为局部变量一般都存放在栈中。局部变量不管是否有const修饰都存放在栈中，例如char *const lcp="999";字符窜"999"存放在代码段的rodata区，这个没有说的，而它对应的地址lcp指针存放在栈中;

 

      BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。例如全局变量int i;静态变量static int si;都存放在这里面。

 

      堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减），要注意的是，当分配的数据大小操作内核的限制时，内核采用匿名映射的方式实现而不是从堆中分配内存。

 

       栈(stack)：栈又称堆栈， 是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段或代码段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。

在进程被载入内存中时，基本上被分裂成许多小的节（section）。我们比较关注的是几个主要的节：

（1） .text 节
    .text 节基本上相当于二进制可执行文件的.text部分，它包含了完成程序任务的机器指令。
该节标记为只读，如果发生写操作，会造成segmentation fault。在进程最初被加载到内存中开始，该节的大小就被固定。

（2）.data 节
    .data节用来存储初始化过的变量，如：全局int a =0 ; 该节的大小在运行时固定的。

（3）.bss 节
     栈下节（below stack section ,即.bss）用来存储为初始化的变量，如：int a; 该节的大小在运行时固定的。

（4） 堆节
      堆节（heap section）用来存储动态分配的变量，位置从内存的低地址向高地址增长。内存的分配和释放通过malloc() 和 free() 函数控制。

（5） 栈节
      栈节（stack section）用来跟踪函数调用（可能是递归的），在大多数系统上从内存的高地址向低地址增长。
同时，栈这种增长方式，导致了缓冲区溢出的可能性。

 （6）.rodata节

      常量区，全局或静态const变量、指针存放区。

（7）环境/参数节
       环境/参数节（environment/arguments section）用来存储系统环境变量的一份复制文件，
进程在运行时可能需要。例如，运行中的进程，可以通过环境变量来访问路径、shell 名称、主机名等信息。
该节是可写的，因此在格式串（format string）和缓冲区溢出（buffer overflow）攻击中都可以使用该节。
另外，命令行参数也保持在该区域中。

 

我们以Linux为例，看下面的代码：

[cpp] view plaincopyprint?

 

1. <span style="font-size:18px;">#include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. char a[100]="22222222";  
5.   
6. int b[100];  
7.   
8. int c;  
9.   
10. char * p="11111111";  
11.   
12. const int ci=9;  
13.   
14. char *const cp="88888";  
15.   
16. int main()  
17. {  
18.       
19.     int li;  
20.       
21.     char *lp="66666";  
22.       
23.     char la[100]="4444444";  
24.       
25.     static int si;  
26.       
27.     static int sii=5;  
28.       
29.     const int lci=2;  
30.       
31.     char *const lcp="89999";  
32.       
33.     static char *const scp="kkkkk";  
34.       
35.     char *mc=(char*)malloc(100);  
36.       
37.     printf("a[0]:%c\np[0]:%c\nla[0]:%c\nlp[0]:%c\n",a[0],p[0],la[0],lp[0]);  
38.       
39.     printf("hello world\n");  
40.     return 1;  
41. }</span>  

为验证我们在代码中的注释，我们对上面代码在fedora12上编译：

gcc -S segment.c 

上面编译命令生成segment.c对应的汇编代码：

.file "segment.c"

;a为全局.data区

.globl a

.data

.align 32

.type a, @object

.size a, 100

a:

.string "22222222"

.zero 91

;b和c为.comm也就是BSS区

.comm b,400,32

.comm c,4,4

.globl p

.section .rodata

;全局p内容，即字符串为.rodata区

.LC0:

.string "11111111"

;全局p指针，即字符串的地址为.data区

.data

.align 4

.type p, @object

.size p, 4

p:

.long .LC0

.globl ci

.section .rodata

.align 4

;全局变量ci位于.rodata区

.type ci, @object

.size ci, 4

ci:

.long 9

;全局cp内容和地址都位于.rodata区

.globl cp

.LC1:

.string "88888"

.align 4

.type cp, @object

.size cp, 4

cp:

.long .LC1

;下面为代码中的其余字符串常量，位于.rodata区

.LC2:

.string "66666"

.LC3:

.string "89999"

.align 4

.LC4:

.string "a[0]:%c\np[0]:%c\nla[0]:%c\nlp[0]:%c\n"

.LC5:

.string "hello world"

;.text区，主要存放代码

.text

.globl main

.type main, @function

main:

pushl �p

movl %esp, �p

andl $-16, %esp

pushl �i

pushl %esi

pushl �x

subl $164, %esp

movl $.LC2, 144(%esp)

movl $875836468, 40(%esp)

movl $3421236, 44(%esp)

leal 48(%esp), �x

movl $0, �x

movl $23, �x

movl �x, �i

movl �x, �x

rep stosl

movl $2, 148(%esp)

movl $.LC3, 152(%esp)

movl $100, (%esp)

call malloc

movl �x, 156(%esp)

movl 144(%esp), �x

movzbl (�x), �x

movsbl %al, %esi

movzbl 40(%esp), �x

movsbl %al, �x

movl p, �x

movzbl (�x), �x

movsbl %al, �x

movzbl a, �x

movsbl %al, �x

movl $.LC4, �x

movl %esi, 16(%esp)

movl �x, 12(%esp)

movl �x, 8(%esp)

movl �x, 4(%esp)

movl �x, (%esp)

call printf

movl $.LC5, (%esp)

call puts

movl $1, �x

addl $164, %esp

popl �x

popl %esi

popl �i

movl �p, %esp

popl �p

ret

.size main, .-main

.section .rodata

.LC6:

;scp和他的内容都放在.rodata

.string "kkkkk"

.align 4

.type scp.2177, @object

.size scp.2177, 4

scp.2177:

.long .LC6

.data

;sii存放在.data

.align 4

.type sii.2174, @object

.size sii.2174, 4

sii.2174:

.long 5

;局部si放在.comm

.local si.2173

.comm si.2173,4,4

.ident "GCC: (GNU) 4.4.2 20091027 (Red Hat 4.4.2-7)"

.section .note.GNU-stack,"",@progbits

 

       对应上面的C代码，不难看出，和我们预想的完全一样，其中关键的地方我用不用的颜色标出来了，从汇编代码中我们同样可以看出，存放于栈中的局部数据其变量并没有出现在汇编代码中，是的，因为他直接存在了栈中，在程序中直接从栈中获得就没有必要用变量来访问了。

 

       我们把这段代码最终还是编译成ELF可执行文件segment.out，然后我们用下面的命令看一下该可自行文件装入内存后的区域划分：

objdump -D segment.out > obj.txt

 

      生成的内容放在了obj.txt文件中，该文件很长，不过我们只看这里我们关心的几个地方，如下：

segment.out:     file format elf32-i386

Disassembly of section .interp:

 

Disassembly of section .plt:

08048304 <__gmon_start__@plt-0x10>:

 8048304: ff 35 80 97 04 08     pushl  0x8049780

 804830a: ff 25 84 97 04 08     jmp    *0x8049784

 8048310: 00 00                 add    %al,(�x)

...

08048314 <__gmon_start__@plt>:

 8048314: ff 25 88 97 04 08     jmp    *0x8049788

 804831a: 68 00 00 00 00        push   $0x0

 804831f: e9 e0 ff ff ff        jmp    8048304 <_init+0x30>

08048324 <__libc_start_main@plt>:

 8048324: ff 25 8c 97 04 08     jmp    *0x804978c

 804832a: 68 08 00 00 00        push   $0x8

 804832f: e9 d0 ff ff ff        jmp    8048304 <_init+0x30>

08048334 <printf@plt>:

 8048334: ff 25 90 97 04 08     jmp    *0x8049790

 804833a: 68 10 00 00 00        push   $0x10

 804833f: e9 c0 ff ff ff        jmp    8048304 <_init+0x30>

08048344 <malloc@plt>:

 8048344: ff 25 94 97 04 08     jmp    *0x8049794

 804834a: 68 18 00 00 00        push   $0x18

 804834f: e9 b0 ff ff ff        jmp    8048304 <_init+0x30>

08048354 <puts@plt>:

 8048354: ff 25 98 97 04 08     jmp    *0x8049798

 804835a: 68 20 00 00 00        push   $0x20

 804835f: e9 a0 ff ff ff        jmp    8048304 <_init+0x30>

 

Disassembly of section .text:

08048370 <_start>:

...

08048424 <main>:

...

Disassembly of section .fini:

0804858c <_fini>:

...

 

Disassembly of section .rodata:

080485a8 <_fp_hw>:

 80485a8: 03 00                 add    (�x),�x

...

080485ac <_IO_stdin_used>:

 80485ac: 01 00                 add    �x,(�x)

 80485ae: 02 00                 add    (�x),%al

080485b0 <__dso_handle>:

 80485b0: 00 00                 add    %al,(�x)

 80485b2: 00 00                 add    %al,(�x)

 80485b4: 31 31                 xor    %esi,(�x)

 80485b6: 31 31                 xor    %esi,(�x)

 80485b8: 31 31                 xor    %esi,(�x)

 80485ba: 31 31                 xor    %esi,(�x)

 80485bc: 00 00                 add    %al,(�x)

...

080485c0 <ci>:

 80485c0: 09 00                 or     �x,(�x)

 80485c2: 00 00                 add    %al,(�x)

 80485c4: 38 38                 cmp    %bh,(�x)

 80485c6: 38 38                 cmp    %bh,(�x)

 80485c8: 38 00                 cmp    %al,(�x)

...

080485cc <cp>:

 80485cc: c4 85 04 08 36 36     les    0x36360804(�p),�x

 80485d2: 36 36 36 00 38        add    %bh,%ss:(�x)

 80485d7: 39 39                 cmp    �i,(�x)

 80485d9: 39 39                 cmp    �i,(�x)

 80485db: 00 61 5b              add    %ah,0x5b(�x)

 80485de: 30 5d 3a              xor    %bl,0x3a(�p)

 80485e1: 25 63 0a 70 5b        and    $0x5b700a63,�x

 80485e6: 30 5d 3a              xor    %bl,0x3a(�p)

 80485e9: 25 63 0a 6c 61        and    $0x616c0a63,�x

 80485ee: 5b                    pop    �x

 80485ef: 30 5d 3a              xor    %bl,0x3a(�p)

 80485f2: 25 63 0a 6c 70        and    $0x706c0a63,�x

 80485f7: 5b                    pop    �x

 80485f8: 30 5d 3a              xor    %bl,0x3a(�p)

 80485fb: 25 63 0a 00 68        and    $0x68000a63,�x

 8048600: 65                    gs

 8048601: 6c                    insb   (%dx),%es:(�i)

 8048602: 6c                    insb   (%dx),%es:(�i)

 8048603: 6f                    outsl  %ds:(%esi),(%dx)

 8048604: 20 77 6f              and    %dh,0x6f(�i)

 8048607: 72 6c                 jb     8048675 <scp.2177+0x61>

 8048609: 64 00 6b 6b           add    %ch,%fs:0x6b(�x)

 804860d: 6b 6b 6b 00           imul   $0x0,0x6b(�x),�p

 8048611: 00 00                 add    %al,(�x)

...

08048614 <scp.2177>:

 8048614: 0b                    .byte 0xb

 8048615: 86 04 08              xchg   %al,(�x,�x,1)

Disassembly of section .eh_frame_hdr:

...

 

Disassembly of section .data:

080497a0 <__data_start>:

...

080497c0 <a>:

 80497c0: 32 32                 xor    (�x),%dh

 80497c2: 32 32                 xor    (�x),%dh

 80497c4: 32 32                 xor    (�x),%dh

 80497c6: 32 32                 xor    (�x),%dh

...

08049824 <p>:

 8049824: b4 85                 mov    $0x85,%ah

 8049826: 04 08                 add    $0x8,%al

08049828 <sii.2174>:

 8049828: 05                    .byte 0x5

 8049829: 00 00                 add    %al,(�x)

...

 

Disassembly of section .bss:

08049840 <completed.5934>:

 8049840: 00 00                 add    %al,(�x)

...

08049844 <dtor_idx.5936>:

 8049844: 00 00                 add    %al,(�x)

...

08049848 <si.2173>:

...

08049860 <b>:

...

080499f0 <c>:

 80499f0: 00 00                 add    %al,(�x)

...

Disassembly of section .comment:

...

      从不同颜色标出数据可以很清楚的看出，上面的的数据和前面我们分析的汇编代码完全一致。Windwos的情况类似，可以在工程->设置->C/C++分类中设置为Listing Files然后在列表中选择Assembly with Source Code,这样在debug或release文件夹下会生成C对应的汇编代码。当然也可以在调试的过程中直接看其每条C语句对应的汇编代码。