brk(), sbrk() 用法详解【转】

转自：http://blog.csdn.net/sgbfblog/article/details/7772153

贴上原文地址，好不容易找到了：brk(), sbrk() -- 改变数据段长度

brk() , sbrk() 的声明如下：

[cpp]  view plain  copy

 

 

1. #include <unistd.h>  
2. int brk(void *addr);  
3. void *sbrk(intptr_t increment);  

这两个函数都用来改变 "program break" (程序间断点)的位置，这个位置可参考下图：

如 man 里说的：

引用

brk()  and  sbrk() change the location of the program break, which defines the end of the process's data segment (i.e., the program break is the first location after the end of the uninitialized data segment). 

brk() 和 sbrk() 改变 "program brek" 的位置，这个位置定义了进程数据段的终止处(也就是说，program break 是在未初始化数据段终止处后的第一个位置)。
如此翻译过来，似乎会让人认为这个 program break 是和上图中矛盾的，上图中的 program break 是在堆的增长方向的第一个位置处(堆和栈的增长方向是相对的)，而按照说明手册来理解，似乎是在 bss segment 结束那里(因为未初始化数据段一般认为是 bss segment)。

首先说明一点，一个程序一旦编译好后，text segment ，data segment 和 bss segment 是确定下来的，这也可以通过 objdump 观察到。下面通过一个程序来测试这个 program break 是不是在 bss segment 结束那里：

[cpp]  view plain  copy

 

 

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <stdlib.h>  
4. #include <sys/time.h>  
5. #include <sys/resource.h>  
6.    
7.    
8. int bssvar;    //声明一个味定义的变量，它会放在 bss segment 中  
9.    
10.    
11. int main(void)  
12. {  
13.     char *pmem;  
14.     long heap_gap_bss;  
15.    
16.    
17.     printf ("end of bss section:%p\n", (long)&bssvar + 4);  
18.    
19.    
20.     pmem = (char *)malloc(32);          //从堆中分配一块内存区，一般从堆的开始处获取  
21.     if (pmem == NULL) {  
22.         perror("malloc");  
23.         exit (EXIT_FAILURE);  
24.     }  
25.    
26.    
27.     printf ("pmem:%p\n", pmem);  
28.    
29.    
30. //计算堆的开始地址和 bss segment 结束处得空隙大小，注意每次加载程序时这个空隙都是变化的，但是在同一次加载中它不会改变  
31.     heap_gap_bss = (long)pmem - (long)&bssvar - 4;            
32.     printf ("1-gap between heap and bss:%lu\n", heap_gap_bss);  
33.    
34.    
35.     free (pmem);   //释放内存，归还给堆  
36.        
37.     sbrk(32);        //调整 program break 位置(假设现在不知道这个位置在堆头还是堆尾)  
38.      pmem = (char *)malloc(32);   //再一次获取内存区  
39.         if (pmem == NULL) {  
40.                 perror("malloc");  
41.                 exit (EXIT_FAILURE);  
42.         }  
43.    
44.    
45.         printf ("pmem:%p\n", pmem);   //检查和第一次获取的内存区的起始地址是否一样  
46.     heap_gap_bss = (long)pmem - (long)&bssvar - 4;  //计算调整 program break 后的空隙  
47.     printf ("2-gap between heap and bss:%lu\n", heap_gap_bss);  
48.    
49.    
50.     free(pmem);   //释放  
51.     return 0;  
52. }  

下面，我们分别运行两次程序，并查看其输出：

引用

[beyes@localhost C]$ ./sbrk 
end of bss section:0x8049938
pmem:0x82ec008
1-gap between heap and bss:2762448
pmem:0x82ec008
2-gap between heap and bss:2762448
[beyes@localhost C]$ ./sbrk 
end of bss section:0x8049938
pmem:0x8dbc008
1-gap between heap and bss:14100176
pmem:0x8dbc008
2-gap between heap and bss:14100176

从上面的输出中，可以发现几点：
1. bss 段一旦在在程序编译好后，它的地址就已经规定下来。
2. 一般及简单的情况下，使用 malloc() 申请的内存，释放后，仍然归还回原处，再次申请同样大小的内存区时，还是从第 1 次那里获得。
3. bss segment 结束处和堆的开始处的空隙大小，并不因为 sbrk() 的调整而改变，也就是说明了 program break 不是调整堆头部。

所以，man 手册里所说的  “program break 是在未初始化数据段终止处后的第一个位置” ，不能将这个位置理解为堆头部。这时，可以猜想应该是在堆尾部，也就是堆增长方向的最前方。下面用程序进行检验：

当 sbrk() 中的参数为 0 时，我们可以找到 program break 的位置。那么根据这一点，检查一下每次在程序加载时，系统给堆的分配是不是等同大小的：

[cpp]  view plain  copy

 

 

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <stdlib.h>  
4. #include <sys/time.h>  
5. #include <sys/resource.h>  
6.    
7.    
8. int main(void)  
9. {  
10.         void *tret;  
11.         char *pmem;  
12.    
13.    
14.    
15.         pmem = (char *)malloc(32);  
16.         if (pmem == NULL) {  
17.                 perror("malloc");  
18.                 exit (EXIT_FAILURE);  
19.         }  
20.    
21.    
22.         printf ("pmem:%p\n", pmem);  
23.    
24.         tret = sbrk(0);  
25.         if (tret != (void *)-1)  
26.                 printf ("heap size on each load: %lu\n", (long)tret - (long)pmem);  
27.    
28.    
29.     return 0;  
30. }  

运行上面的程序 3 次：

引用

[beyes@localhost C]$ ./sbrk 
pmem:0x80c9008
heap size on each load: 135160
[beyes@localhost C]$ ./sbrk 
pmem:0x9682008
heap size on each load: 135160
[beyes@localhost C]$ ./sbrk 
pmem:0x9a7d008
heap size on each load: 135160
[beyes@localhost C]$ ./sbrk 
pmem:0x8d92008
heap size on each load: 135160
[beyes@localhost C]$ vi sbrk.c

从输出可以看到，虽然堆的头部地址在每次程序加载后都不一样，但是每次加载后，堆的大小默认分配是一致的。但是这不是不能改的，可以使用 sysctl 命令修改一下内核参数：

引用

#sysctl -w kernel/randomize_va_space=0

这么做之后，再运行 3 次这个程序看看：

引用

[beyes@localhost C]$ ./sbrk 
pmem:0x804a008
heap size on each load: 135160
[beyes@localhost C]$ ./sbrk 
pmem:0x804a008
heap size on each load: 135160
[beyes@localhost C]$ ./sbrk 
pmem:0x804a008
heap size on each load: 135160

从输出看到，每次加载后，堆头部的其实地址都一样了。但我们不需要这么做，每次堆都一样，容易带来缓冲区溢出攻击(以前老的 linux 内核就是特定地址加载的)，所以还是需要保持 randomize_va_space 这个内核变量值为 1 。

下面就来验证 sbrk() 改变的 program break 位置在堆的增长方向处：

[cpp]  view plain  copy

 

 

1. #include <stdio.h>  
2. #include <unistd.h>  
3. #include <stdlib.h>  
4. #include <sys/time.h>  
5. #include <sys/resource.h>  
6.    
7.    
8. int main(void)  
9. {  
10.         void *tret;  
11.         char *pmem;  
12.         int i;  
13.         long sbrkret;  
14.    
15.        pmem = (char *)malloc(32);  
16.         if (pmem == NULL) {  
17.                 perror("malloc");  
18.                 exit (EXIT_FAILURE);  
19.         }  
20.    
21.    
22.         printf ("pmem:%p\n", pmem);  
23.    
24.          for (i = 0; i < 65; i++) {  
25.                 sbrk(1);  
26.                 printf ("%d\n", sbrk(0) - (long)pmem - 0x20ff8);   //0x20ff8 就是堆和 bss段 之间的空隙常数；改变后要用 sbrk(0) 再次获取更新后的program break位置  
27.         }  
28.        free(pmem);  
29.    
30.           
31.        return 0;  
32. }  

运行输出：

引用

[beyes@localhost C]$ ./sbrk 
pmem:0x804a008
1
2
3
4
5

... ...
61
62
63
64

从输出看到，sbrk(1) 每次让堆往栈的方向增加 1 个字节的大小空间。

而 brk() 这个函数的参数是一个地址，假如你已经知道了堆的起始地址，还有堆的大小，那么你就可以据此修改 brk() 中的地址参数已达到调整堆的目的。

实际上，在应用程序中，基本不直接使用这两个函数，取而代之的是 malloc() 一类函数，这一类库函数的执行效率会更高。还需要注意一点，当使用 malloc() 分配过大的空间，比如超出 0x20ff8 这个常数(在我的系统(Fedora15)上是这样，别的系统可能会有变)时，malloc 不再从堆中分配空间，而是使用 mmap() 这个系统调用从映射区寻找可用的内存空间。