21ic电子技术开发论坛 › 单片机与嵌入式系统 › 极海MCU › 嵌入式c语言开发：关于“踩内存”，你知道多少？ ...
返回列表 发新帖我要提问本帖赏金: 80.00元(功能说明)

[APM32F4] 嵌入式c语言开发：关于“踩内存”，你知道多少？

[复制链接]
3616|2
 楼主| DKENNY 发表于 2024-12-12 20:22 | 显示全部楼层 |阅读模式
内存, c语言开发, 嵌入式c语言
本帖最后由 DKENNY 于 2024-12-12 20:21 编辑

#申请原创# #技术资源# @21小跑堂

前言
      在编程中，尤其是使用C语言时，内存错误常常令人头痛。一旦找出这些错误，问题通常容易解决。今天我们聚焦于“踩内存”的现象做个简单的分析。
      “踩内存”意味着由于程序设计或实现的问题，意外修改了相邻的内存区域。原本应该处理特定内存块，但误操作使得相邻内存数据被篡改。此问题可能导致程序功能失常，甚至使程序崩溃或系统挂起。
      内存可以大致分为两个部分：
      l 静态存储区
      l 动态存储区
      “踩内存”通常发生在同一存储区内的数据之间。

一、静态存储区互踩
      静态存储区互踩通常是指在静态存储区域中，多个变量之间由于不当的内存管理或对同一内存区域的错误引用而导致的数据覆盖和错误。
      在C语言中，静态存储区互踩的情况主要可以归结为以下几种常见的情况。
        l 同名静态变量互踩
        l 数组越界
        l 静态结构体中变量互踩
        l 静态变量在循环中越界
        l 静态变量的指针互踩

1. 同名静态变量互踩
复制
  1. #include <stdio.h>
    


  2. 

  3. void func1() 
    

  4. {
    

  5.     static int value = 0; // 静态变量 value
    

  6.     value++;
    

  7.     printf("func1: value = %d\n", value);
    

  8. }
    


  9. 

  10. void func2() 
    

  11. {
    

  12.     static int value = 10; // 静态变量 value，和 func1 中的 value 名称相同
    

  13.     value++;
    

  14.     printf("func2: value = %d\n", value);
    

  15. }
    


  16. 

  17. int main() 
    

  18. {
    

  19.     func1(); // 输出: 1
    

  20.     func2(); // 输出: 11
    

  21.     func1(); // 输出: 2
    

  22.     func2(); // 输出: 12
    

  23.     return 0;
    

  24. }
     分析：在这个例子中，func1 和 func2 中都有同名的静态变量 value。虽然它们在不同的作用域中，但由于同名而导致互相影响。每次调用时，func1 和 func2 分别引用同名的静态变量，可能导致逻辑混乱。
      解决方案：使用更具描述性的变量名，避免同名。

2. 数组越界
复制
  1. #include <stdio.h>
    


  2. 

  3. void func() 
    

  4. {
    

  5.     static int arr[3]; // 静态数组 arr
    

  6.     static int b = 10; // 静态变量 b
    


  7. 

  8.     // 越界赋值
    

  9.     for (int i = 0; i <= 3; i++) 
    

  10.     { // 注意这里的循环条件是 <= 3，导致越界
    

  11.         arr[i] = i * 2; // 尝试赋值
    

  12.     }
    


  13. 

  14.     printf("arr[0] = %d, arr[1] = %d, arr[2] = %d, b = %d\n", arr[0], arr[1], arr[2], b);
    

  15. }
    


  16. 

  17. int main() 
    

  18. {
    

  19.     func(); // 调用 func
    

  20.     return 0;
    

  21. }
     分析：在这个示例中，数组 arr 被越界访问，arr[3] 可能覆盖静态变量 b 的值。这会导致未定义行为及错误的输出。
      解决方案：确保数组访问时索引在合法范围内。

3. 静态结构体中变量互踩
复制
  1. #include <stdio.h>
    


  2. 

  3. struct Data 
    

  4. {
    

  5.     static int count; // 静态结构体成员
    

  6. };
    


  7. 

  8. int Data::count = 0; // 初始化
    


  9. 

  10. void func1() 
    

  11. {
    

  12.     Data::count++;
    

  13.     printf("func1: count = %d\n", Data::count);
    

  14. }
    


  15. 

  16. void func2() 
    

  17. {
    

  18.     Data::count += 10; // 同一静态成员
    

  19.     printf("func2: count = %d\n", Data::count);
    

  20. }
    


  21. 

  22. int main() 
    

  23. {
    

  24.     func1(); // 输出: 1
    

  25.     func2(); // 输出: 11
    

  26.     func1(); // 输出: 2
    

  27.     func2(); // 输出: 12
    

  28.     return 0;
    

  29. }
     分析：在这个例子中，静态结构体成员 count 被 func1 和 func2 同时修改，导致它们之间的值互相影响。
      解决方案：避免使用同一结构体的静态成员，使用实例化对象。

4. 静态变量在循环中越界
复制
  1. #include <stdio.h>
    


  2. 

  3. void func() 
    

  4. {
    

  5.     static int arr[3]; // 静态数组 arr
    

  6.     for (int i = 0; i < 5; i++) 
    

  7.     { // 越界访问
    

  8.         arr[i] = i; // 越界写入
    

  9.     }
    

  10. }
    


  11. 

  12. int main() 
    

  13. {
    

  14.     func(); // 调用 func
    

  15.     return 0;
    

  16. }
     分析：这里传入的数组大小是3，但在循环中却写入了5个元素。arr[3] 和 arr[4] 可能会覆盖其他静态或全局变量，导致数据损坏。
      解决方案：确保循环条件不超过数组大小。

5. 静态变量的指针互踩
复制
  1. #include <stdio.h>
    


  2. 

  3. void func() 
    

  4. {
    

  5.     static int *ptr1 = NULL; // 指向静态变量的指针
    

  6.     static int *ptr2 = NULL; // 另一个指针
    


  7. 

  8.     static int a = 5; // 静态变量
    

  9.     static int b = 10; // 另一个静态变量
    


  10. 

  11.     ptr1 = &a; // 指向 a
    

  12.     ptr2 = &b; // 指向 b
    


  13. 

  14.     *ptr1 = 20; // 修改 a
    

  15.     *ptr2 = 30; // 修改 b
    


  16. 

  17.     printf("a = %d, b = %d\n", a, b);
    

  18. }
    


  19. 

  20. int main() 
    

  21. {
    

  22.     func(); // 调用 func
    

  23.     return 0;
    

  24. }
     分析：在这个例子中，静态变量 a 和 b 被指针 ptr1 和 ptr2 修改。如果不小心，指针可能指向错误的内存区域，从而导致互踩的问题。
      解决方案：在使用指针时，确保它们指向正确的内存地址，并避免使用多个指向同一静态变量的指针。

总结
      静态存储区互踩的情况主要由于变量同名、数组越界、指针错误等引起。在编写C代码时，应该注意变量的作用域和生命周期，确保不发生意外的内存覆盖和数据损坏，避免使用同名变量，并严格控制数组的访问范围。

二、动态存储区踩内存
      动态存储区踩内存通常指在使用动态内存时发生的错误，如内存越界、内存泄漏、悬挂指针等。下面列出几种常见的情况，并提供C语言代码示例和详细分析。

1. 内存越界访问
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    


  3. 

  4. void access_out_of_bounds() 
    

  5. {
    

  6.     int *arr = (int *)malloc(3 * sizeof(int)); // 动态分配3个整数的内存
    

  7.     // 越界写入
    

  8.     for (int i = 0; i <= 3; i++) 
    

  9.     { // 注意这里的循环条件是 <= 3，导致越界
    

  10.         arr[i] = i; // 尝试访问 arr[3]
    

  11.     }
    

  12.     free(arr);
    

  13. }
    


  14. 

  15. int main() 
    

  16. {
    

  17.     access_out_of_bounds(); // 调用函数
    

  18.     return 0;
    

  19. }
    分析：
       l 在这个例子中，malloc 分配了3个整数的内存，但在循环中使用了 i<=3，导致尝试访问 arr[3]，这是未分配的内存区域，可能会导致未定义行为。
     后果：
       l 数据损坏：可能会覆盖其他有效内存区域的数据，导致数据完整性问题。
       l 程序崩溃：如果越界访问了操作系统保留的内存或未分配的内存，可能引发段错误（segmentation fault）。

2. 内存泄漏
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    


  3. 

  4. void memory_leak() 
    

  5. {
    

  6.     int *ptr = (int *)malloc(5 * sizeof(int)); // 动态分配内存
    

  7.     // 忘记释放内存
    

  8.     // free(ptr); // 应该释放内存，但这里被注释掉
    

  9. }
    


  10. 

  11. int main() 
    

  12. {
    

  13.     memory_leak(); // 调用函数
    

  14.     return 0;
    

  15. }
    分析：
       l 在这个示例中，malloc 分配了5个整数的内存，但没有调用 free 来释放它。这将导致内存泄漏。
     后果：
       l 内存耗尽：在长时间运行的程序中，如果频繁发生内存泄漏，可能导致系统内存耗尽，最终导致程序崩溃或系统变得不稳定。
       l 性能降低：内存泄漏会导致可用内存减少，从而影响程序的性能。

3. 悬挂指针
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    


  3. 

  4. void dangling_pointer() 
    

  5. {
    

  6.     int *ptr = (int *)malloc(sizeof(int)); // 动态分配内存
    

  7.     *ptr = 42; // 设置值
    

  8.     free(ptr); // 释放内存
    

  9.     // 访问已释放的内存
    

  10.     printf("Value: %d\n", *ptr); // 悬挂指针
    

  11. }
    


  12. 

  13. int main() 
    

  14. {
    

  15.     dangling_pointer(); // 调用函数
    

  16.     return 0;
    

  17. }
    分析：
       l 在这个例子中，ptr 指向动态分配的内存，在调用 free后，该内存被释放，但 ptr 仍然指向原来的地址。
     后果：
       l 未定义行为：访问已释放的内存将导致未定义行为，程序可能崩溃，或者返回意外的值。
       l 数据损坏：如果其他部分的代码分配了相同的内存，可能会导致 ptr 中的数据被覆盖。

4. 双重释放
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    


  3. 

  4. void double_free() 
    

  5. {
    

  6.     int *ptr = (int *)malloc(sizeof(int)); // 动态分配内存
    

  7.     free(ptr); // 释放内存
    

  8.     free(ptr); // 再次释放相同的指针，导致双重释放
    

  9. }
    


  10. 

  11. int main() 
    

  12. {
    

  13.     double_free(); // 调用函数
    

  14.     return 0;
    

  15. }
    分析：
       l 在这个示例中，free(ptr) 被调用两次。第一次释放了指针所指向的内存，但第二次释放将导致未定义行为。
     后果：
       l 程序崩溃：双重释放通常会导致程序崩溃（如段错误），因为它试图释放不再有效的内存区域。

5. 未初始化的指针
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    


  3. 

  4. void uninitialized_pointer() 
    

  5. {
    

  6.     int *ptr; // 声明，但未初始化
    

  7.     // 直接使用未初始化的指针
    

  8.     *ptr = 10; // 访问未定义的内存
    

  9. }
    


  10. 

  11. int main() 
    

  12. {
    

  13.     uninitialized_pointer(); // 调用函数
    

  14.     return 0;
    

  15. }
    分析：
       l 在这个例子中，ptr 被声明但未初始化。使用未初始化的指针访问内存会导致未定义行为。
     后果：
       l 未定义行为：访问未初始化的指针会导致程序崩溃，返回随机值，或读取到不该访问的内存区域。
       l 数据损坏：如果该指针指向随机内存，可能会覆盖有效的数据，导致严重的数据完整性问题。

示例代码分析
      以下是一个类似的动态踩内存示例，我们将创建一个动态数组并故意越界写入，从而引发内存篡改。然后，我们将分析代码，指出篡改的数据，并提供一些检测和防止动态存储区被踩内存的方法。
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    


  4. 

  5. #define BUFFER_SIZE 10
    

  6. #define REDZONE_SIZE 4
    


  7. 

  8. int main(void) 
    

  9. {
    

  10.     // 申请 BUFFER_SIZE 字节的堆内存
    

  11.     char *buffer = (char *)malloc(BUFFER_SIZE + REDZONE_SIZE); // 加上红区
    

  12.     if (buffer == NULL) 
    

  13.     {
    

  14.         printf("malloc error\n");
    

  15.         exit(EXIT_FAILURE);
    

  16.     }
    


  17. 

  18.     // 设置红区的值
    

  19.     memset(buffer + BUFFER_SIZE, 0xAA, REDZONE_SIZE); // 红区填充为 0xAA
    


  20. 

  21.     // 向 buffer 写入数据
    

  22.     strcpy(buffer, "Hello, World!"); // 这是一个越界写入
    


  23. 

  24.     // 打印内容
    

  25.     printf("buffer = %s\n", buffer);
    

  26.     
    

  27.     // 打印红区内容
    

  28.     for (int i = 0; i < REDZONE_SIZE; i++) 
    

  29.     {
    

  30.         printf("buffer[%d] = 0x%X\n", BUFFER_SIZE + i, (unsigned char)buffer[BUFFER_SIZE + i]);
    

  31.     }
    


  32. 

  33.     // 释放对应内存
    

  34.     free(buffer);
    

  35.     return 0;
    

  36. }
    分析
     l 变量定义与内存分配：
         ¡ 我们分配了 BUFFER_SIZE 字节的内存来存储字符串，并额外分配了 REDZONE_SIZE 字节作为红区，用于检测内存越界。
     l 越界写入：
         ¡ 使用 strcpy 将超出 buffer 大小的字符串拷贝到动态分配的内存中。这将导致对红区的覆盖，破坏其内容。
     l 输出结果：
         ¡ 程序输出了 buffer 的内容和红区的值。由于越界写入，红区的内容可能被修改，导致其不再是 0xAA。

检测动态存储区被踩内存的方法
      为了解决和检测动态存储区的内存踩踏问题，可以采取以下步骤：
      a. 使用红区：
        l 在动态分配的内存块之后添加一个红区。红区的大小应足够大，可以通过简单的 memset 或其他方法初始化为特定的值（如 0xAA）。
        l 在释放内存前，检查红区的值，以确保其未被修改。
      b. 内存覆盖检测：
        l 在使用内存块之前，检查红区的内容。如果红区的内容被破坏，则表明存在越界写入或其他类型的内存篡改。
      c. 例子中的实现：
        l 在示例代码中，我们对红区进行了填充，并在打印时输出了红区的内容。如果红区的内容变为其它值（如 0x00 或其它），则表示内存被篡改。

设置红区的作用
      设置红区（Red Zone）是一种有效的内存保护技术，通常用于检测动态内存分配中的越界写入和篡改。设置两块红区（前红区和后红区）可以更加全面地保护内存区域。以下是具体分析：
      l 检测越界写入：
        ¡ 红区的主要作用是检测越界写入。如果程序试图写入超过分配的内存块，那么写入的内容可能会覆盖红区的内容。通过监测红区的状态，可以及时发现越界错误。
      l 检测未定义行为：
        ¡ 除了越界写入，红区还可以帮助检测其他未定义行为，例如双重释放或悬挂指针等。通过检查红区的状态，可以判断是否有内存被错误地访问。
      l 提高安全性：
        ¡ 在安全性要求较高的程序中，红区可以帮助防止缓冲区溢出（buffer overflow）攻击，增加程序的安全性。
      l 调试和测试：
        ¡ 在开发和测试阶段，通过在动态分配内存时使用红区，可以更容易地发现和修复内存管理错误。

设置前红区和后红区的好处
     l 双向保护：
       ¡ 设置前红区（在分配的内存之前）和后红区（在分配的内存之后）可以提供更全面的保护。这样无论是对内存块的前面还是后面进行越界写入，都能被有效检测到。
     l 检测不同类型的错误：
       ¡ 前红区可以用于检测前向越界写入，而后红区可以用于检测后向越界写入。这样可以捕获更广泛的错误类型。
     l 栈和堆的整合：
       ¡ 在一些复杂的数据结构中（例如链表、树等），可能会有多个指针相互指向，设置双红区可以减少因指针错误引起的意外内存访问。

红区配置步骤
      a. 定义红区的大小：
        l 通常来说，红区的大小可以设定为几个字节（如4字节或8字节），以便在动态分配内存时能够明显检测内存越界的情况。
      b. 修改动态内存分配函数：
        l 重写 malloc 和 free 函数，以便在分配和释放内存时同时处理红区。
      c. 初始化红区：
        l 在分配内存后，可以使用 memset 函数将红区的内容初始化为特定的值（如0xAA ）。
      d. 检测红区：
        l 在释放内存或使用内存前，检查红区的内容，以确保其未被修改。
0e4a752ecdfe9f85ac65eb87c5fe050a
      以下是一个示例，演示如何在动态分配的内存前后设置红区。
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    


  4. 

  5. #define BUFFER_SIZE 10
    

  6. #define REDZONE_SIZE 4
    


  7. 

  8. void check_redzones(char *buffer) 
    

  9. {
    

  10.     // 检查前红区
    

  11.     for (int i = 0; i < REDZONE_SIZE; i++) 
    

  12.     {
    

  13.         if (buffer[i] != 0xAA) 
    

  14.         {
    

  15.             printf("Memory corruption detected in front redzone!\n");
    

  16.             return;
    

  17.         }
    

  18.     }
    

  19.     // 检查后红区
    

  20.     for (int i = 0; i < REDZONE_SIZE; i++) 
    

  21.     {
    

  22.         if (buffer[BUFFER_SIZE + REDZONE_SIZE + i] != 0xAA) 
    

  23.         {
    

  24.             printf("Memory corruption detected in back redzone!\n");
    

  25.             return;
    

  26.         }
    

  27.     }
    

  28.     printf("Both redzones are intact.\n");
    

  29. }
    


  30. 

  31. int main(void) 
    

  32. {
    

  33.     // 申请 BUFFER_SIZE 字节的堆内存，并加上前后红区
    

  34.     char *buffer = (char *)malloc(BUFFER_SIZE + 2 * REDZONE_SIZE);
    

  35.     if (buffer == NULL) 
    

  36.     {
    

  37.         printf("malloc error\n");
    

  38.         exit(EXIT_FAILURE);
    

  39.     }
    


  40. 

  41.     // 设置前红区和后红区的值
    

  42.     memset(buffer, 0xAA, REDZONE_SIZE); // 前红区
    

  43.     memset(buffer + BUFFER_SIZE + REDZONE_SIZE, 0xAA, REDZONE_SIZE); // 后红区
    


  44. 

  45.     // 向 buffer 写入数据
    

  46.     strcpy(buffer + REDZONE_SIZE, "Hello"); // 向有效内存写入
    

  47.     // strcpy(buffer + REDZONE_SIZE, "Hello, World!"); // 这会越界写入
    


  48. 

  49.     // 检测红区
    

  50.     check_redzones(buffer);
    


  51. 

  52.     // 打印内容
    

  53.     printf("buffer = %s\n", buffer + REDZONE_SIZE);
    

  54.     
    

  55.     // 打印前后红区内容
    

  56.     for (int i = 0; i < REDZONE_SIZE; i++) 
    

  57.     {
    

  58.         printf("front redzone[%d] = 0x%X\n", i, (unsigned char)buffer[i]);
    

  59.         printf("back redzone[%d] = 0x%X\n", i, (unsigned char)buffer[BUFFER_SIZE + REDZONE_SIZE + i]);
    

  60.     }
    


  61. 

  62.     // 释放对应内存
    

  63.     free(buffer);
    

  64.     return 0;
    

  65. }

APM32开发时，怎么配置红区？
      以下是一个简单的示例，演示如何在APM32中设置红区。
      l 前红区：4字节。写入固定数据0xAAAAAAAA。
      l 后红区：4字节。写入固定数据0xAAAAAAAA。
d0994a6a1bd7b5e020b877d557279e4e
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    


  4. 

  5. #define REDZONE_SIZE 4  // 红区大小
    

  6. #define BUFFER_SIZE 10  // 动态分配的内存大小
    


  7. 

  8. // 自定义内存分配函数
    

  9. void* my_malloc(size_t size) 
    

  10. {
    

  11.     // 分配额外的内存用于红区
    

  12.     char *ptr = (char *)malloc(size + 2 * REDZONE_SIZE);
    

  13.     if (ptr == NULL) 
    

  14.     {
    

  15.         return NULL; // 处理内存分配错误
    

  16.     }
    

  17.     
    

  18.     // 初始化前红区
    

  19.     memset(ptr, 0xAA, REDZONE_SIZE);
    

  20.     // 初始化后红区
    

  21.     memset(ptr + size + REDZONE_SIZE, 0xAA, REDZONE_SIZE);
    

  22.     
    

  23.     // 返回有效内存的起始地址
    

  24.     return ptr + REDZONE_SIZE;
    

  25. }
    


  26. 

  27. // 自定义内存释放函数
    

  28. void my_free(void* ptr) 
    

  29. {
    

  30.     if (ptr == NULL) return;
    

  31.     
    

  32.     // 找到原始指针
    

  33.     char *original_ptr = (char *)ptr - REDZONE_SIZE;
    

  34.     
    

  35.     // 检查红区
    

  36.     for (int i = 0; i < REDZONE_SIZE; i++) 
    

  37.     {
    

  38.         if (original_ptr[i] != 0xAA) 
    

  39.         {
    

  40.             printf("Memory corruption detected in front redzone!\n");
    

  41.             break;
    

  42.         }
    

  43.     }
    

  44.     
    

  45.     // 释放内存
    

  46.     free(original_ptr);
    

  47. }
    


  48. 

  49. int main(void) 
    

  50. {
    

  51.     // 使用自定义的内存分配函数
    

  52.     char *buffer = (char *)my_malloc(BUFFER_SIZE);
    

  53.     if (buffer == NULL) 
    

  54.     {
    

  55.         printf("Memory allocation failed\n");
    

  56.         return -1;
    

  57.     }
    

  58.     
    

  59.     // 使用分配的内存
    

  60.     strcpy(buffer, "Hello");
    

  61.     printf("Buffer: %s\n", buffer);
    

  62.     
    

  63.     // 释放内存
    

  64.     my_free(buffer);
    

  65.     
    

  66.     return 0;
    

  67. }
     代码分析
      a. 自定义内存分配函数 ：
        l 使用分配比请求的大小大的内存，以便为前后红区留出空间。
        l 使用初始化前红区和后红区为特定值（如）。
        l 返回指向有效内存的指针（即跳过前红区）。
      b. 自定义内存释放函数 ：
        l 计算原始指针（在红区之前的指针）。
        l 检查前红区的内容，确认是否完整。如果被篡改，输出错误信息。
        l 最后，释放原始指针的内存。
      c. 使用示例：
        l 在函数中，调用分配动态内存，并使用释放。

总结
      l 设置前红区和后红区可以提供双向保护，对于检测动态内存的越界和篡改非常有效。
      l 红区的作用十分重要，不仅可以检测越界、未定义行为，还能提高程序的安全性和调试能力。


回复

收藏 举报

打赏榜单

21小跑堂 打赏了 80.00 元 2024-12-18
理由：恭喜通过原创审核！期待您更多的原创作品~~

评论

21小跑堂
类举嵌入式编程中的内存错误类型，分析错误产生的原因和解决方法。通过实例代码举例说明如何规避内存错误，文章结构紧凑，条理清晰，可阅读性较佳。  发表于 2024-12-18 17:41

相关帖子
风之呢喃 发表于 2024-12-19 09:52 | 显示全部楼层
总结的很全面，感谢分享
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

DKENNY Image

60

主题

108

帖子

17

粉丝
快速回复 在线客服 返回列表 返回顶部