C语言（14） 谈谈嵌入式 C 语言踩内存问题！

于 2023-06-17 14:55:21 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： # C 语言编程 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhi_Alanwu/article/details/131260391
版权

1 概述

C 语言内存问题，难在于定位，定位到了就好解决了。
这篇笔记我们来聊聊踩内存。踩内存，通过字面理解即可。本来是操作这一块内存，因为设计失误操作到了相邻内存，篡改了相邻内存的数据。

踩内存，轻则导致功能异常，重则导致程序崩溃死机。
内存，粗略地分：

静态存储区
动态存储区

存储于相同存储区的变量才有互踩内存的可能。

2 静态存储区踩内存

分享一个之前在实际项目中遇到的问题。

在Linux中，一个进程默认可以打开的文件数为1024个，fd的范围为0~1023。
项目中使用了串口，串口fd为static全局变量，某次这个fd突然变为一个超范围得值，显然被踩了。
出问题的代码如：

float arr[5];
int count = 8;
for (size_t i = 0; i < count; i++)
{
    arr[i] = xxx;
}

在这里插入图片描述
操作同属于静态存储区的arr数组出现了数组越界操作，踩了后面几个连续变量，fd也踩了。
实际中，纯靠log打印调试很难定位fd的相邻变量，需要花比较多的时间。
在Linux中，这个问题我们可以通过生成生成map文件来查看，在CMakeLists.txt中生成map文件的代码如：

set(CMAKE_EXE_LINKER_FLAGS "-Wl,-Map=output.map")  # 生成map文件
set(CMAKE_C_FLAGS "-fdata-sections")               # 把static变量地址输出到map文件
set(CMAKE_CXX_FLAGS "-fdata-sections")

3 动态存储区踩内存

动态堆内存踩内存典型例子：malloc与strcpy搭配使用不当导致缓冲区溢出。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int main (void)
{
    char *str = "hello";
    int str_len = strlen(str);

    ///< 此时str_len = 5
    printf("str_len = %d\n", str_len);

    ///< 申请5字节的堆内存
    char *ptr = (char*)malloc(str_len);
    if (NULL == ptr)
    {
        printf("malloc error\n");
        exit(EXIT_FAILURE);
    }

    ///< 定义一个指针p_a指向ptr向后偏移5字节的地址, 并在这个地址里写入整数20
    char *p_a = ptr + 5;
    *p_a = 20;
    printf("*p_a = %d\n", *p_a);

    ///< 拷贝字符串str到ptr指向的地址
    strcpy(ptr, str);

    ///< 打印结果：a指向的地方被踩了
    printf("ptr = %s\n", ptr);
    printf("*p_a = %d\n", *p_a);

    ///< 释放对应内存
    if (ptr)
    {
        free(ptr);
        ptr = NULL;
    }

    return 0;
}

运行结果：
在这里插入图片描述
显然，经过strcpy操作之后，数据a的值被篡改了。
原因：忽略了strcpy操作会把字符串结束符一同拷贝到目的缓冲区。
在这里插入图片描述
如果相邻的空间里没有存放其它业务数据，那么踩了也不会出现问题，如果正好存放了重要数据，这时候可能会出现大bug，而且可能是偶现的，不好复现定位。

针对这种情况，我们可以借助一些工具来定位问题，比如：

dmalloc
valgrind
valgrind的简单使用可阅读往期笔记：链接

当然，我们也可以在我们的代码里进行一些尝试。针对这类问题，分享一个检测思路：

我们在申请内存时，在申请内存的前后增加两块标识区（红区），里面写入固定数据。申请、释放内存的时候去检测这两块标识区有没有被破坏（检测操作堆内存时是否踩到高压红区）。

为了能定位到后面的标识区，在增加一块len区用来存储实际申请的空间的长度。
此处，我们定义：

前红区（before_ red_area）：4字节。写入固定数据0x11223344。
后红区（after_ red_area）：4字节。写入固定数据0x55667788。
长度区（len_area）：4字节。存储数据存储区的长度。

在这里插入图片描述

自定义申请内存函数

除了数据存储区之外，多申请12个字节。自定义申请内存的函数自然是要兼容malloc的使用方法。malloc原型：

void *malloc(size_t __size);

自定义申请内存的函数：

void *Malloc(size_t __size);

返回值自然要返回数据存储区的地址。具体实现：

#define BEFORE_RED_AREA_LEN  (4)            ///< 前红区长度
#define AFTER_RED_AREA_LEN   (4)            ///< 后红区长度
#define LEN_AREA_LEN         (4)            ///< 长度区长度

#define BEFORE_RED_AREA_DATA (0x11223344u)  ///< 前红区数据
#define AFTER_RED_AREA_DATA  (0x55667788u)  ///< 后红区数据

void *Malloc(size_t __size)
{
    ///< 申请内存：4 + 4 + __size + 4
    void *ptr = malloc(BEFORE_RED_AREA_LEN + AFTER_RED_AREA_LEN + __size + LEN_AREA_LEN);
    if (NULL == ptr)
    {
        printf("[%s]malloc error\n", __FUNCTION__);
        return NULL;
    }

    ///< 往前红区地址写入固定值
    *((unsigned int*)(ptr)) = BEFORE_RED_AREA_DATA;     

    ///< 往长度区地址写入长度     
    *((unsigned int*)(ptr + BEFORE_RED_AREA_LEN)) = __size;  

    ///< 往后红区地址写入固定值
    *((unsigned int*)(ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)) = AFTER_RED_AREA_DATA;  

    ///< 返回数据区地址
    void *data_area_ptr = (ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN);
    return data_area_ptr;
}
自定义检测内存函数
申请完内存并往内存里写入数据后，检测本该写入到数据存储区的数据有没有写到红区。这种内存检测方法我们是用在开发调试阶段的，所以检测内存，我们可以使用断言，一旦触发断言，直接终止程序报错。

检测前后红区里的数据有没有被踩：

void CheckMem(void *ptr, size_t __size)
{
    void *data_area_ptr = ptr;

    ///< 检测是否踩了前红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN)));
    assert(*((unsigned int*)(data_area_ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN)) == BEFORE_RED_AREA_DATA);

    ///< 检测是否踩了长度区
    printf("[%s]len_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr - LEN_AREA_LEN)));
    assert(*((unsigned int*)(data_area_ptr - LEN_AREA_LEN)) == __size); 

    ///< 检测是否踩了后红区
    printf("[%s]after_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr + __size)));
    assert(*((unsigned int*)(data_area_ptr + __size)) == AFTER_RED_AREA_DATA); 
}

自定义释放内存函数
要释放所有前面申请内存。释放前同样要进行检测：

void Free(void *ptr)
{
    void *all_area_ptr = ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN;

    ///< 检测是否踩了前红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(all_area_ptr)));
    assert(*((unsigned int*)(all_area_ptr)) == BEFORE_RED_AREA_DATA);

    ///< 读取长度区内容
    size_t __size = *((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN));

    ///< 检测是否踩了后红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)));
    assert(*((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)) == AFTER_RED_AREA_DATA);

    ///< 释放所有区域内存
    free(all_area_ptr);
}

我们使用这种方法检测上面的 malloc与strcpy搭配使用不当导致缓冲区溢出 的例子：
在这里插入图片描述
可以看到，这个例子踩了后红区，把后红区数据修改为了 0x55667700 ，触发断言程序终止。

测试代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>

#define BEFORE_RED_AREA_LEN  (4)            ///< 前红区长度
#define AFTER_RED_AREA_LEN   (4)            ///< 后红区长度
#define LEN_AREA_LEN         (4)            ///< 长度区长度

#define BEFORE_RED_AREA_DATA (0x11223344u)  ///< 前红区数据
#define AFTER_RED_AREA_DATA  (0x55667788u)  ///< 后红区数据

void *Malloc(size_t __size)
{
    ///< 申请内存：4 + 4 + __size + 4
    void *ptr = malloc(BEFORE_RED_AREA_LEN + AFTER_RED_AREA_LEN + __size + LEN_AREA_LEN);
    if (NULL == ptr)
    {
        printf("[%s]malloc error\n", __FUNCTION__);
        return NULL;
    }

    ///< 往前红区地址写入固定值
    *((unsigned int*)(ptr)) = BEFORE_RED_AREA_DATA;     

    ///< 往长度区地址写入长度     
    *((unsigned int*)(ptr + BEFORE_RED_AREA_LEN)) = __size;  

    ///< 往后红区地址写入固定值
    *((unsigned int*)(ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)) = AFTER_RED_AREA_DATA;  

    ///< 返回数据区地址
    void *data_area_ptr = (ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN);
    return data_area_ptr;
}

void CheckMem(void *ptr, size_t __size)
{
    void *data_area_ptr = ptr;

    ///< 检测是否踩了前红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN)));
    assert(*((unsigned int*)(data_area_ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN)) == BEFORE_RED_AREA_DATA);

    ///< 检测是否踩了长度区
    printf("[%s]len_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr - LEN_AREA_LEN)));
    assert(*((unsigned int*)(data_area_ptr - LEN_AREA_LEN)) == __size); 

    ///< 检测是否踩了后红区
    printf("[%s]after_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(data_area_ptr + __size)));
    assert(*((unsigned int*)(data_area_ptr + __size)) == AFTER_RED_AREA_DATA); 
}

void Free(void *ptr)
{
    void *all_area_ptr = ptr - LEN_AREA_LEN - BEFORE_RED_AREA_LEN;

    ///< 检测是否踩了前红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(all_area_ptr)));
    assert(*((unsigned int*)(all_area_ptr)) == BEFORE_RED_AREA_DATA);

    ///< 读取长度区内容
    size_t __size = *((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN));

    ///< 检测是否踩了后红区
    printf("[%s]before_red_area_data = 0x%x\n", __FUNCTION__, *((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)));
    assert(*((unsigned int*)(all_area_ptr + BEFORE_RED_AREA_LEN + LEN_AREA_LEN + __size)) == AFTER_RED_AREA_DATA);

    ///< 释放所有区域内存
    free(all_area_ptr);
}

int main (void)
{
    char *str = "hello";
    int str_len = strlen(str);

    ///< 此时str_len = 5
    printf("str_len = %d\n", str_len);

    ///< 申请5字节的堆内存
    char *ptr = (char*)Malloc(str_len);    ///< 自定义的Malloc
    if (NULL == ptr)
    {
        printf("malloc error\n");
        exit(EXIT_FAILURE);
    }

    ///< 定义一个指针p_a指向ptr向后偏移5字节的地址, 并在这个地址里写入整数20
    char *p_a = ptr + 5;
    *p_a = 20;
    printf("*p_a = %d\n", *p_a);

    ///< 拷贝字符串str到ptr指向的地址
    strcpy(ptr, str);

    ///< 操作完堆内存之后，要检测写入操作有没有踩到红区
    CheckMem(ptr, str_len);

    ///< 打印结果：a指向的地方被踩了
    printf("ptr = %s\n", ptr);
    printf("*p_a = %d\n", *p_a);

    ///< 释放对应内存
    if (ptr)
    {
        Free(ptr);
        ptr = NULL;
    }

    return 0;
}

没有踩内存的情况：
在这里插入图片描述
本例只是简单分享了检测堆内存踩数据的一种检测思路，例子代码不具备通用性。比如，万一踩的内存不只是相邻的几个字节，而是踩了相邻的一大片，这时候就跨过了红区，而不是踩在红区上。

红区大小由我们自己设定，我们可以设得大些。如果设得很大了都能跨过，这种情况bug应该就比较好复现也比较好定位。看代码应该就比较容易定位了，比较难定位的往往是那种踩了一小块的。

相关资料：

https://www.packetmania.net/2021/03/28/Memory-overrun-detection/

https://download.csdn.net/download/rrzzzz/8642321

转载处：点击

深圳-剑影
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过系统调用，内核断点方法定位用户进程被内核踩内存的问题
sunshineywz的博客
04-20 515
1、系统调用拦截 系统调用拦截的目的其实就是把系统真正要执行的系统调用替换为我们自己写的内核函数，这里有一篇博客，对此作了介绍，https://blog.csdn.net/zhangyifei216/article/details/49872861 系统调用拦截的两个问题，一个是找到sys_call_table地址，一个是修改内存页的属性，让其变为可写。 1）找sys_call_table地址 我...
c语言学习笔记 嵌入式 c 开发
最新发布
12-28
c语言学习笔记 嵌入式 c 开发
一种利用内存保护技术实现程序踩内存的检测方法
05-09
提供了一种利用内存保护技术实现程序踩内存的检测方法, 利用内存保护技术, 在应用程序申请内存后根据情况将其所申请的内存页面属性设置为只读....
内存泄漏 & 内存溢出 & 踩内存 & malloc底层实现原理
LJFjy_fighting的博客
08-21 8933
本文主要对内存泄漏、内存溢出、内存踩踏【踩内存】以及malloc的底层实现原理进行了总结。话不多说，直接往下看： 参考文章： 内存泄漏与内存溢出： https://blog.csdn.net/ruiruihahaha/article/details/70270574 踩内存： https://blog.csdn.net/u014485485/article/details/104714934 malloc的底层实现原理： https://blog.csdn.net/ypshowm/article
python判断括号有效_Python有效括号字符串判断和深度计算
weixin_39581995的博客
12-15 343
'''如果字符串满足一下条件之一，则可以称之为 有效括号字符串(valid parentheses string，可以简写为 VPS)：字符串是一个空字符串 ""，或者是一个不为 "(" 或 ")" 的单字符。字符串可以写为 AB(A 与 B字符串连接)，其中 A 和 B 都是 有效括号字符串 。字符串可以写为 (A)，其中 A 是一个 有效括号字符串 。类似地，可以定义任何有效括号字符串S ...
踩内存：总的来说，是访问了不应该访问的内存地址。尤其在C指针中。可以访问不合法的内存。
Neil驱动的博客
03-29 567
现象：挂死，程序跑的异常，数据被串改大致原因：数组越界，字符串操作越界，栈指针操作越界，操作了释放掉了的指针，多线程时序对资源保护控制不当，内存管理异常，使用了其他地方的内存定位方法：1. 类...
踩内存问题定位手段汇总
qq_35399548的博客
10-16 3235
踩内存问题定位
用mprotect来定位Linux踩内存的问题
放狼的爷们
03-01 6133
    最恶心的Bug莫过于踩内存，定位了内核问题的朋友都知道。这类问题一直没有很套路的方法解决，都需要走读大量的代码，做大量调试来解决。解这类问题最关键的两点就是，1，找到被踩的内存地址，2，抓住被踩的时序。    想要找到被踩的内存地址，这里很多时候可以通过堆栈反汇编，和调试，查找出来，虽然很多时候被踩的地方不固定，这就糟糕了。就要想方法发现共同规律，比如是否在同一个全局变量里面，或者都是同一...
内存飞踩问题的几点思考
sydyh43的博客
09-15 1867
1、程序编译，链接后生成二进制可执行程序。二进制可执行文件以elf格式实现排列。可以通过readelf -S xxxx查看具体section的划分，粗略划分如下图所示。 在这些section中，代码段是只读的，自然也就不存在代码（指令）被改写的情况。数据段，堆，栈区具有读写的属性，但是数据段和堆一般存放的是数据，不涉及到指令的问题。剩下的栈区，存放的既有数据，又有代码（指令），可能存在代码（指令）被改写，即内存被飞踩现象。 2、栈空间数据被修改情况 2.1、先做个实验（ARM 32环境）
关于踩内存
热门推荐
ChuanjieZhu
03-07 1万+
1.什么是踩内存 访问了不合法的地址 。通俗一点就是访问了不属于自己的地址。如果这块地址分配给了另一个变量使用，就会破坏别人的数据。从而导致程序运行异常，挂死，输出图像破图等。 2.踩内存的可能的情形 1）内存访问越界 a)数组访问越界； b)字符串操作越界； 2）非法指针 a）使用了空指针； b)使用了释放掉的指针； c)指针类型转换错误； 3）栈溢出； 4）多线程读...
记处理一次内存被踩
Laurence1234的博客
08-09 376
C语言内存被踩
C语言程序设计嵌入式C语言期末大作业智能家居温度控制器源码.zip
06-09
C语言程序设计嵌入式C语言期末大作业智能家居温度控制器源码。具有以下功能： 测量并显示当前室内环境的温度和湿度。 显示日期、时间。 红外遥控功能，可以遥控本控制器开关机、调整空调温度、风速和工作模式。 ...
Embed_C.rar_C语言程序设计_嵌入式C语言_嵌入式C语言编程_嵌入式c
09-19
关于嵌入式C语言程序设计的书, 对于嵌入输开发有着重要的作用。
C语言在DSP嵌入式系统中的应用与开发-论文
05-19
C语言在DSP嵌入式系统中的应用与开发
C语言嵌入式状态机架构（含C源码）
05-29
状态机简介 函数指针实现FSM 代码实现步骤 附代码 测试程序 总结
c语言学习笔记（11） #pragma pack()
剑影的博客
11-13 1548
转载地址 #pragma pack(n) 解释一： 每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16来改变这一系数，其中的n就是你要指定的“对齐系数”。 规则： 1、数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。 2、结构(或联合)的整体对
c语言学习笔记（2） ble 分包解包系列
剑影的博客
03-19 1197
1.c文件 #include"ble_packt.h" static void ble_send_ack(uint8_t askcmd,uint8_t result) { uint8_t buf[10]; uint8_t indata[2]; uint8_t len=0; indata[0]=askcmd; indata[1]=result; len=ble_packet_data...
c语言学习笔记（9）AT指令时经常用到 -c语言库函数
剑影的博客
05-22 1110
1：查找对应的字符串 char *p_data =null; //找到"+TEST_RXLORA" 这个首地址 p_data = strstr((const char *)re_data, "+TEST_RXLORA"); //查找十进制数值(int *)&lora_rssi[rssi_cnt]) if(sscanf(p_data, "+TEST_RXLORA:%d:", (int *)&lora_rssi[rssi_cnt])) ...
c语言面向对象嵌入式开发
09-05
C语言是一种面向过程的编程语言，它不直接支持面向对象编程（OOP）。然而，在嵌入式开发中，可以使用一些技巧来实现面向对象的编程风格。 一种常见的方法是通过结构体（struct）和函数指针来模拟类和方法。结构体可以用来封装数据，并通过函数指针来操作数据。 例如，可以定义一个结构体来表示一个对象，结构体的成员变量用来存储对象的状态，成员函数指针用来表示对象的方法。通过传递结构体指针和调用相应的函数指针，就可以实现对对象的操作。 另外，可以使用函数指针作为回调函数，将函数作为参数传递给其他函数，从而实现类似于多态的效果。 总的来说，虽然C语言本身不直接支持面向对象编程，但在嵌入式开发中可以利用结构体和函数指针等技巧来模拟面向对象的编程风格。这种方式可以实现封装、继承和多态等面向对象的特性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值