brk(); sbrk()使用

最新推荐文章于 2024-05-21 21:37:34 发布
最新推荐文章于 2024-05-21 21:37:34 发布
阅读量622 收藏 1
点赞数
分类专栏： Linux 文章标签： 内存分配 Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_N_N/article/details/80443104
版权

1. brk(); sbrk()

#include <iostream>
#include <cstring>
#include <unistd.h>

using namespace std;


void brk_test(){
    printf("堆结束地址：%p\n", sbrk(0));//sbrk(size); 以偏移方式设置堆的结束地址
    
    char *p = (char *)sbrk(0);        //偏移值为0，表示当前堆的结束地址
    brk(p + 4);                     //将堆的结束设置为 p + 4;相当于给p分配了4字节大小的空间
    printf("堆结束地址：%p\n", sbrk(0));
    
    
    p[0] = 0;
    p[3] = 3;
    p[6] = 1;       // 尽管只申请了4个char大小的位置，但是操作p[6]并不会发生错误
    p[4095] = 1;    // 正常
    // p[4096] = 1;    // Segmentation fault
    printf("%x, %x\n", p[0], p[3]);
    
    
    brk(p + 1);                     //收回3个char大小的空间
    printf("堆结束地址：%p\n", sbrk(0));
    p[3] = 1; // 正常


    brk(p);                         //恢复成最初的结束地址
    printf("堆结束地址：%p\n", sbrk(0));
    // p[3] = 1; // Segmentation fault
   
}

输出：

堆结束地址：0x7fffcb9f8000    // 以0x1000（4K， 页）对齐
堆结束地址：0x7fffcb9f8004
0, 3
堆结束地址：0x7fffcb9f8001
堆结束地址：0x7fffcb9f8000

在Linux中，页与页框的大小一般为4KB，页是虚拟内存中若干个大小相等的储存分区，页框则是每页对应的物理存储区；

所以可以看到上面输出的，堆的结束地址应该是4K对齐的(个人理解)。结束地址0x7fffcb9f8000，0x7fffcb9f8000指向的内存并不属于堆。调用 brk(p + 4) 后，相当于在堆上新申请了4字节的空间，由于页对齐的关系，虚拟内存分配到实际的物理内存时只能以4K为最小单位来分配，0x7fffcb9f8000 ~ 0x7fffcb9f8ffff为1页，所以这一页的剩余空余都属于该程序，所以操作p[6]时不会发生段错误，但这还是属于非法操作。而操作p[4096]时，p[4096]的地址是0x7fffcb9f9000，又是新的一页，而这一页并不属于该程序，没有读写权限，所以会报 'Segmentation fault' 错误。最后调用 brk(p) 恢复成初始状态后，系统收回起始地址为0x7fffcb9f8000的页，所以接着操作p[3]报 'Segmentation fault' 错误。

2. malloc(size_t size)

先看一段程序。

int malloc_test(){
    char *m1 = (char *)malloc(0x10);
    printf("m1: %p \n", m1);

    char *m2 = (char *)malloc(0x10);
    printf("m2: %p \n", m2);

    char *m3 = (char *)malloc(0x20);
    printf("m3: %p \n", m3);

    char *m4 = (char *)malloc(0x30);
    printf("m4: %p \n", m4);

    char *m5 = (char *)malloc(0x60);
    printf("m5: %p \n", m5);


    printf("m1: %08xh %08xh\n", *((int *)m1 - 1), *((int *)m1 - 2));
    printf("m2: %08x %08x\n", *((int *)m2 - 1), *((int *)m2 - 2));
    printf("m3: %08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));
    printf("m4: %08x %08x\n", *((int *)m4 - 1), *((int *)m4 - 2));
    printf("m5: %08x %08x\n", *((int *)m5 - 1), *((int *)m5 - 2));
 
}

输出：

m1: 0x7fffc71aee70
m2: 0x7fffc71af0a0
m3: 0x7fffc71af0c0
m4: 0x7fffc71af0f0
m5: 0x7fffc71af130
m1: 00000000h 00000021h
m2: 00000000 00000021
m3: 00000000 00000031
m4: 00000000 00000041
m5: 00000000 00000071

 

使用malloc申请内存时也有地址对齐的情况，0x10对齐。malloc所分配内存的前8字节，其值与申请内存的大小有关，存放的是这一块动态申请的内存的起始地址与下一块动态申请的内存的起始地址的距离(个人理解)，再加一。可以约等于系统给你分配的内存大小。（64位测试结果，32位不确定）

3. free(void *ptr)

为什么释放动态内存时只提供首地址就行了，而不用提供具体的大小？

由每块申请的内存的前8个字节可以算出这块内存的大小。

 

例1.

int malloc_test(){
    char *m1 = (char *)malloc(0x10);
    printf("m1: %p \n", m1);

    char *m2 = (char *)malloc(0x10);
    printf("m2: %p \n", m2);

    char *m3 = (char *)malloc(0x20);
    printf("m3: %p \n", m3);

    char *m4 = (char *)malloc(0x30);
    printf("m4: %p \n", m4);

    char *m5 = (char *)malloc(0x60);
    printf("m5: %p \n", m5);


    printf("m1: %08x %08x\n", *((int *)m1 - 1), *((int *)m1 - 2));
    printf("m2: %08x %08x\n", *((int *)m2 - 1), *((int *)m2 - 2));
    printf("m3: %08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));
    printf("m4: %08x %08x\n", *((int *)m4 - 1), *((int *)m4 - 2));
    printf("m5: %08x %08x\n", *((int *)m5 - 1), *((int *)m5 - 2));
 

    // *(m5 - 2) = 0x31;
    free(m3);   // 释放m3
    printf("\n释放m3后，m3：%08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));  // 并没有变化

    char *m6 = (char *)malloc(0x20);    // 申请和m3相同大小的内存
    printf("m6: %p \n", m6);
    printf("m6: %08x %08x\n", *((int *)m6 - 1), *((int *)m6 - 2));

}

输出：

m1: 0x7fffbd602e70
m2: 0x7fffbd6030a0
m3: 0x7fffbd6030c0
m4: 0x7fffbd6030f0
m5: 0x7fffbd603130
m1: 00000000 00000021
m2: 00000000 00000021
m3: 00000000 00000031
m4: 00000000 00000041
m5: 00000000 00000071

释放m3后，m3：00000000 00000031
m6: 0x7fffbd6030c0
m6: 00000000 00000031

可以看到，free掉m3后，m3前8个字节存的值并没有变化。

再次申请和m3大小相同的m6时，系统把原来m3的内存分配给了m6。

所以malloc并不一定是从堆的尾部开始分配新的内存，优先分配堆内的、大小合适的废弃内存。

 

例2.

int malloc_test(){
    char *m1 = (char *)malloc(0x10);
    printf("m1: %p \n", m1);

    char *m2 = (char *)malloc(0x10);
    printf("m2: %p \n", m2);

    char *m3 = (char *)malloc(0x20);
    printf("m3: %p \n", m3);

    char *m4 = (char *)malloc(0x30);
    printf("m4: %p \n", m4);

    char *m5 = (char *)malloc(0x60);
    printf("m5: %p \n", m5);


    printf("m1: %08x %08x\n", *((int *)m1 - 1), *((int *)m1 - 2));
    printf("m2: %08x %08x\n", *((int *)m2 - 1), *((int *)m2 - 2));
    printf("m3: %08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));
    printf("m4: %08x %08x\n", *((int *)m4 - 1), *((int *)m4 - 2));
    printf("m5: %08x %08x\n", *((int *)m5 - 1), *((int *)m5 - 2));
 

    free(m3);   // 释放m3
    *((int *)m3 - 2) = 0xFF;    // 修改大小标志
    printf("\n释放m3后，m3：%08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));  // 并没有变化

    char *m6 = (char *)malloc(0x20);    // 申请和m3相同大小的内存
    printf("m6: %p \n", m6);
    printf("m6: %08x %08x\n", *((int *)m6 - 1), *((int *)m6 - 2));

}

输出：

 

m1: 0x7fffd5e62e70
m2: 0x7fffd5e630a0
m3: 0x7fffd5e630c0
m4: 0x7fffd5e630f0
m5: 0x7fffd5e63130
m1: 00000000 00000021
m2: 00000000 00000021
m3: 00000000 00000031
m4: 00000000 00000041
m5: 00000000 00000071

释放m3后，m3：00000000 000000ff
m6: 0x7fffd5e630c0
m6: 00000000 000000ff

 在m3被释放后，修改m3的大小标志，再申请大小相同的m6，系统还是把原来m3的内存分配给了m6。

说明申请内存时，前8个字节并不是用来确定内存块大小的，系统的其他地方还记录着每一块内存的使用情况。

 

例3.

int malloc_test(){
    char *m1 = (char *)malloc(0x10);
    printf("m1: %p \n", m1);

    char *m2 = (char *)malloc(0x10);
    printf("m2: %p \n", m2);

    char *m3 = (char *)malloc(0x20);
    printf("m3: %p \n", m3);

    char *m4 = (char *)malloc(0x30);
    printf("m4: %p \n", m4);

    char *m5 = (char *)malloc(0x60);
    printf("m5: %p \n", m5);


    printf("m1: %08x %08x\n", *((int *)m1 - 1), *((int *)m1 - 2));
    printf("m2: %08x %08x\n", *((int *)m2 - 1), *((int *)m2 - 2));
    printf("m3: %08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));
    printf("m4: %08x %08x\n", *((int *)m4 - 1), *((int *)m4 - 2));
    printf("m5: %08x %08x\n", *((int *)m5 - 1), *((int *)m5 - 2));
 

    free(m3);   // 释放m3
    *((int *)m3 - 2) = 0xff;    // 修改大小标志
    printf("\n释放m3后，m3：%08x %08x\n", *((int *)m3 - 1), *((int *)m3 - 2));  // 并没有变化

    char *m6 = (char *)malloc(0x20);    // 申请和m3相同大小的内存
    printf("m6: %p \n", m6);
    printf("m6: %08x %08x\n", *((int *)m6 - 1), *((int *)m6 - 2));

    // *((int *)m3 - 2) = 0x31;
    free(m6);
    m6 = (char *)malloc(0x20);    // 申请和m3相同大小的内存
    printf("m6: %p \n", m6);
    printf("m6: %08x %08x\n", *((int *)m6 - 1), *((int *)m6 - 2));

}

输出：

m1: 0x7ffff5673e70
m2: 0x7ffff56740a0
m3: 0x7ffff56740c0
m4: 0x7ffff56740f0
m5: 0x7ffff5674130
m1: 00000000 00000021
m2: 00000000 00000021
m3: 00000000 00000031
m4: 00000000 00000041
m5: 00000000 00000071

释放m3后，m3：00000000 000000ff
m6: 0x7ffff56740c0
m6: 00000000 000000ff
munmap_chunk(): invalid pointer
Aborted (core dumped)

m3的大小标志改成无规律的0xff，先释放m3, 再申请m6后，再释放m6。此时报无效指针的错误‘munmap_chunk(): invalid pointer’。

说明释放内存时，free只根据传入地址的前8个字节来判断内存的块大小，而0xff并不满足内存分配规则，所以报错。

将0xff改成0x21, 0x31...等满足规则的值，程序正常运行。

Mnnk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
wager_brk
10-28
2. **编程控制结构**：“brk”在编程中通常与内存管理相关，比如在早期的UNIX系统中，`sbrk()`函数用于改变程序的数据段大小。结合描述中的"break"，可能是指在赌注决策或处理流程中使用的中断机制，如跳出循环或...
linux学习---brk(), sbrk() 用法
朝气蓬勃
10-11 6997
一．brk sbrk介绍借用linux那个男人，看下BRK(2)                    Linux Programmer's Manual                    BRK(2) 此部分补充一个知识点：后面的括号1:Linux系统(shell)指2:系统函数3:标准C函数7:系统编程帮助    所以此部分是linux系统函数NAME         brk, sbrk
brk()、mmap()及malloc()基本原理
代码笔记本
02-27 4199
文章目录linux内存分配缺页中断linux内存分配的原理malloc()背后的实现原理malloc()和free()的功能malloc()和free()的分配算法参考资料 linux内存分配 缺页中断 什么是缺页中断，简单来说是因为操作系统采用了虚拟内存技术，程序代码/数据对应的内容并不一定是完全读入到内存中，在使用到时候发生缺页中断将对应的内容读入到内存中。 当一个进程发生缺页中断的时候，进程会陷入内核态，执行以下操作： 检查要访问的虚拟地址是否合法 查找/分配一个物理页 填充物理页内容（读取磁盘，或
炸弹指令何处来？
最新发布
advdbgger的博客
05-21 32
新来的小伙伴Denny在使用JS脚本测试NDB时遇到拦路虎，node进程打印出下面这个信息后就崩溃闪退了。geduer@ulan:/gewu/nanocode/nd3/ndi$ node ndunix.js register 'jtag' register 'swim' register 'dapdirect_jtag' register 'dapdirect_swd' register 'swd...
munmap_chunk(): invalid pointer:
weixin_35755188的博客
02-13 5742
这个错误消息通常表示程序试图释放一个无效的内存地址。“munmap_chunk”是指程序正在使用 munmap 函数释放内存，但发现了一个非法的指针，即不是一个有效的内存块地址。这可能是由于多次释放同一内存块导致的，或者是由于程序尝试释放一个未分配的内存块。在任何情况下，这都是一个严重的错误，需要立即修复。 ...
linux内存管理-系统调用brk()
guoguangwu的专栏
10-23 6269
尽管可见度不高，brk也许是最常使用的系统调用了，用户进程通过它向内核申请空间。人们常常并不意识到在调用brk，原因在于很少有人会直接使用系统调用brk向系统申请空间，而总是通过像malloc一类的C语言库函数（或语言成分，如C++中的new）间接地调用brk。如果把malloc想象成零售，brk则是批发。库函数malloc为用户进程（malloc本身就是该进程的一部分）维持一个小仓库，当进程需要使用更多的内存空间时就向小仓库要，小仓库中存量不足时就通过brk向内核批发。 前面讲过，每个进程拥有3GB字节
问题：munmap_chunk(): invalid pointer
Wangxu的博客
12-13 1万+
问题：munmap_chunk(): invalid pointer 在编写程序的时候遇到了munmap_chunk(): invalid pointer的问题，如下图所示，记录下如何解决 这段报错很混乱，找不出错误原因，只能大致了解到是指针出了问题，我们希望能够对代码出错位置进行定位，这里使用gdb调试来进行定位； gdb基本操作：https://blog.csdn.net/mercy_ps/article/details/81542986 另一个用于查看越界读写动态分配内存/读写已释放动态分配内存的工具
操作系统实验报告（内核编译 进程管理 brk工作机制）
02-06
实验报告中，我们详细分析了brk的工作流程，包括如何调整数据段的界限，以及如何通过sbrk()系统调用进行细粒度的内存分配。此外，还可能探讨了如何与其他内存分配策略（如mmap）进行对比，以及在不同情况下选择合适...
sbrk(),mmap(),malloc(),calloc()的异同
04-15
当进程需要更多的内存时，brk() 函数将虚拟地址空间映射到内存中，以供进程使用。 与 brk() 函数相似，sbrk() 函数也用于实现虚拟内存到内存的映射。sbrk() 函数的原型是 `void *sbrk(ptrdiff_t increment);`，它将...
Linux操作系统的内存使用方法详细解析
03-04
进程与内核之间的交互主要通过系统调用实现，如`brk`, `sbrk`, `mmap`, 和 `munmap`，这些调用用于管理进程的虚拟内存。用户进程只能看到和访问虚拟内存，对物理内存的使用是透明的。 为了提高效率，Linux使用了...
Malloc轻量级实现
01-21
这是一个使用sbrk/mmap实现的轻量级malloc函数簇实现，功能涵盖了内存对齐、内存分配释放、内存合并和分割等，对于malloc内部实现感兴趣的可以参考下
brk和sbrk
我的博客
11-28 806
program break 是虚拟内存中数据段的结束位置， malloc 通过调用 brk 或 sbrk 增加 program break 的值，从而创建可以通过 malloc 动态分配的内存空间。：进程可以通过增加堆的大小来分配内存，堆是一段长度可变的连续虚拟内存，始于进程的未初始化数据段末尾，随着内存的分配和释放而增减。在计算机程序中，“program break”通常指的是堆的当前内存边界。都是用来改变程序的“program break”的位置，也就是改变数据段的长度，实现虚拟内存到物理内存的映射。
系统调用与内存管理（sbrk、brk、mmap、munmap）
Apollon_krj的博客
01-16 2万+
一、系统调用（System Call）：在Linux中，4G内存可分为两部分——内核空间1G（3~4G）与用户空间3G（0~3G）,我们通常写的C代码都是在对用户空间即0~3G的内存进行操作。而且，用户空间的代码不能直接访问内核空间，因此内核空间提供了一系列的函数，实现用户空间进入内核空间的接口，这一系列的函数称为系统调用（System Call）。比如我们经常使用的open、close、read、
brk()--重置数据段存储空间函数
wocjj的专栏
11-27 687
资料出处：http://book.51cto.com/art/201203/326322.htm 第1章 动态内存管理函数：alloc.h 动态内存管理函数在程序执行过程中为程序中的数据分配内存，这些函数都通过指针来指明内存地址。 最常用的动态内存管理函数是stdlib中的malloc()、calloc()和free()，这组函数在同一数据段中分配内存，当
【Debug系列】munmap_chunk(): invalid pointer
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
08-28 8884
DATE: 2020.8.28 文章目录1、项目场景2、问题描述3、原因分析4、解决方案 1、项目场景 在编写一个简单的内存开辟和释放程序时，遇到这个内存问题。 2、问题描述 munmap_chunk(): invalid pointer 3、原因分析 出现这个问题的主要原因在于内存读取或写入越界导致释放已经释放了的内存。 4、解决方案 参考： https://stackoverflow.com/questions/32118545/munmap-chunk-invalid-pointer ------
Qt 报错：munmap_chunk(): invalid pointer解决方案
FreeLikeTheWind的博客
10-21 1420
Qt 报错：munmap_chunk(): invalid pointer解决方案
pytorch出现munmap_chunk(): invalid pointer
Z__z__Z_的博客
08-31 1362
pytorch实现的CV代码，运行主程序后报错：munmap_chunk(): invalid pointer。
深入理解Linux内存管理brk 和 sbrk 与以及使用C++ list实现内存分配器
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
10-18 720
在Linux操作系统中，每个进程都有其独立的虚拟内存空间。这个空间被分为几个区域，其中一个重要的区域是堆（Heap）。堆是动态内存分配的地方，例如，当我们在C++中使用`new`或在C中使用`malloc`时，就是从堆中分配内存。
brk(), sbrk() 用法详解
热门推荐
__七把刀__
07-22 3万+
brk() , sbrk() 的声明如下： #include int brk(void *addr); void *sbrk(intptr_t increment); 这两个函数都用来改变 "program break" (程序间断点)的位置，这个位置可参考下图： 如 man 里说的： 引用 brk()  and  sbrk() change the location of
Unix/Linux内存管理：brk/sbrk解析
"这篇资源是关于Unix下的C语言编程教程，特别关注了内存管理中的`brk`和`sbrk`函数。Unix/Linux操作系统是多用户、多任务的系统，有着丰富的衍生版本，如SystemV、Berkley和Hybrid等。教程涵盖了Unix的核心编程概念...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值