（四）cmockery中allocate_moudle分析

    所分析的allocate_moudle.c和allocate_moudle_test.c文件位于 工程中的 cmockery/src/example/ 目录下，是关于内存相关的一些测试，比如内存泄露，内存向上向下溢出错误等的检测。
样例程序如下：
allocate_module.c
  1. #ifdef HAVE_CONFIG_H
  2. #include "config.h"
  3. #endif
  4. #ifdef HAVE_MALLOC_H
  5. #include <malloc.h>
  6. #endif
  7. #include <sys/types.h>
  8. #define UNIT_TESTING 1
  9. #if UNIT_TESTING
  10. extern void* _test_malloc(const size_t size, const char* file, const int line);
  11. extern void* _test_calloc(const size_t number_of_elements, const size_t size,
  12.                           const char* file, const int line);
  13. extern void _test_free(void* const ptr, const char* file, const int line);
  15. #define malloc(size) _test_malloc(size, __FILE__, __LINE__)
  16. #define calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__)
  17. #define free(ptr) _test_free(ptr, __FILE__, __LINE__)
  18. #endif // UNIT_TESTING
  20. void leak_memory() {
  21.     int * const temporary = (int*)malloc(sizeof(int));
  22.     *temporary = 0;
  23. }
  25. void buffer_overflow() {
  26.     char * const memory = (char*)malloc(sizeof(int));
  27.     memory[sizeof(int)] = '!';
  28.     free(memory);
  29. }
  31. void buffer_underflow() {
  32.     char * const memory = (char*)malloc(sizeof(int));
  33.     memory[-1] = '!';
  34.     free(memory);
  35. }
    这个文件中由一个宏进行控制是否使用cmockery的内存检测功能，在上面程序的第8行是我后期添加的，在源程序中是不存在的。将UNIT_TESTING设置为1则为使用内存检测功能，对应的是cmockery中重写的一组内存相关的操作:_test_malloc, _test_calloc, _test_free。如果UNIT_TESTING设置为0，那么就使用libc中的malloc， calloc， free函数。程序的第9-18行就是这一功能选择的具体代码；
    leak_memory函数，使用malloc申请一个int类型的内存空间，并随后将这个内存指针进行赋值为0，人为的丢失掉这块内存，即内存泄露现象。
    buffer_overflow函数，先用malloc申请一个int类型的内存空间，然后再在这块内存的最后一个字节之后，写上了一个字符‘！’，也就是说在申请的内存之后的空间内进行赋值操作，即内存上溢。
    buffer_underflow函数以memory[-1] = '!';这个方式进行在申请的内存的之前进行赋值操作，人为的制造了一个内存下溢的情况。

allocate_module_test.c
  1. #include <stdarg.h>
  2. #include <stddef.h>
  3. #include <setjmp.h>
  4. #include "cmockery.h"
  6. extern void leak_memory();
  7. extern void buffer_overflow();
  8. extern void buffer_underflow();
  10. // Test case that fails as leak_memory() leaks a dynamically allocated block.
  11. void leak_memory_test(void **state) {
  12.     leak_memory();
  13. }
  15. // Test case that fails as buffer_overflow() corrupts an allocated block.
  16. void buffer_overflow_test(void **state) {
  17.     buffer_overflow();
  18. }
  20. // Test case that fails as buffer_underflow() corrupts an allocated block.
  21. void buffer_underflow_test(void **state) {
  22.     buffer_underflow();
  23. }
  25. int main(int argc, char* argv[]) {
  26.     const UnitTest tests[] = {
  27.         unit_test(leak_memory_test),
  28.         unit_test(buffer_overflow_test),
  29.         unit_test(buffer_underflow_test)
  30.     };
  31.     return run_tests(tests);
  32. }
    以上程序的1-23行进行封装了一下作为一个个的测试单元。然后再main函数里面填充到UnitTest变量中，最后调用run_tests函数进行运行测试。

运行结果为：
    

    很显然是将三种不同的内存错误都进行了有效的识别，想知道单元测试程序是怎么就能够知道我们的内存使用情况的，那就要细致的分析一下cmockery关于内存操作的这一组程序：
  1. #undef malloc
  2. void* _test_malloc(const size_t size, const char* file, const int line) {
  3.     char* ptr;
  4.     MallocBlockInfo *block_info;
  5.     ListNode * const block_list = get_allocated_blocks_list();
  6.     const size_t allocate_size = size + (MALLOC_GUARD_SIZE * 2) +
  7.         sizeof(*block_info) + MALLOC_ALIGNMENT;
  8.     char* const block = (char*)malloc(allocate_size);
  9.     assert_true(block);
  11.     // Calculate the returned address.
  12.     ptr = (char*)(((size_t)block + MALLOC_GUARD_SIZE + sizeof(*block_info) +
  13.                   MALLOC_ALIGNMENT) & ~(MALLOC_ALIGNMENT - 1));
  15.     // Initialize the guard blocks.
  16.     memset(ptr - MALLOC_GUARD_SIZE, MALLOC_GUARD_PATTERN, MALLOC_GUARD_SIZE);
  17.     memset(ptr + size, MALLOC_GUARD_PATTERN, MALLOC_GUARD_SIZE);
  18.     memset(ptr, MALLOC_ALLOC_PATTERN, size);
  20.     block_info = (MallocBlockInfo*)(ptr - (MALLOC_GUARD_SIZE +
  21.                                              sizeof(*block_info)));
  22.     set_source_location(&block_info->location, file, line);
  23.     block_info->allocated_size = allocate_size;
  24.     block_info->size = size;
  25.     block_info->block = block;
  26.     block_info->node.value = block_info;
  27.     list_add(block_list, &block_info->node);
  28.     return ptr;
  29. }
  30. #define malloc test_malloc
    通过在所需要的内存大小之外再从该内存的上下各冗余出来两块保障空间，并进行赋值为0xef，然后将地址信息和内存大小信息填充到申请出来的内存块中，然后再返回给程序所使用的真正的内存位置。
    内存所组织的方式所定义的结构体如下：
  1. // Location within some source code.
  2. typedef struct SourceLocation {
  3.     const char* file;
  4.     int line;
  5. } SourceLocation;
  7. // Doubly linked list node.
  8. typedef struct ListNode {
  9.     const void *value;
  10.     int refcount;
  11.     struct ListNode *next;
  12.     struct ListNode *prev;
  13. } ListNode;
  15. // Debug information for malloc().
  16. typedef struct MallocBlockInfo {
  17.     void* block;              // 由 malloc().分配的内存地址
  18.     size_t allocated_size;    // 分配的总大小
  19.     size_t size;              // 请求的内存大小
  20.     SourceLocation location;  // 分配函数调用的位置
  21.     ListNode node;            // 在所有的分配内存中的节点(以链表挂接的)
  22. } MallocBlockInfo;

MallocBlockInfo的内存结构如下图所示：



    申请出来的内存都以双向链表的形式挂接起来。



所申请内存的计算方式，以及申请到的内存样子。再以一定的格式进行划分debug内存和用户使用内存空间。然后得到如下图的形式，其中用户所申请的空间以 int 类型大小所示例，即为 4 个字节


  1. void* _test_calloc(const size_t number_of_elements, const size_t size,
  2.                    const char* file, const int line) {
  3.     void* const ptr = _test_malloc(number_of_elements * size, file, line);
  4.     if (ptr) {
  5.         memset(ptr, 0, number_of_elements * size);
  6.     }
  7.     return ptr;
  8. }

_test_calloc函数，简单的调用_test_malloc函数，并进行将返回的用户数据进行初始化为0，然后进行返回。

  1. // Use the real free in this function.
  2. #undef free
  3. void _test_free(void* const ptr, const char* file, const int line) {
  4.     unsigned int i;
  5.     char *block = (char*)ptr;
  6.     MallocBlockInfo *block_info;
  7.     _assert_true((int)ptr, "ptr", file, line);
  8.     block_info = (MallocBlockInfo*)(block - (MALLOC_GUARD_SIZE +
  9.                                                sizeof(*block_info)));
  10.     // Check the guard blocks.
  11.     {
  12.         char *guards[2] = {block - MALLOC_GUARD_SIZE,
  13.                            block + block_info->size};
  14.         for (i = 0; i < ARRAY_LENGTH(guards); i++) {
  15.             unsigned int j;
  16.             char * const guard = guards[i];
  17.             for (j = 0; j < MALLOC_GUARD_SIZE; j++) {
  18.                 const char diff = guard[j] - MALLOC_GUARD_PATTERN;
  19.                 if (diff) {
  20.                     print_error(
  21.                         "Guard block of 0x%08x size=%d allocated by "
  22.                         SOURCE_LOCATION_FORMAT " at 0x%08x is corrupt
",
  23.                         (size_t)ptr, block_info->size,
  24.                         block_info->location.file, block_info->location.line,
  25.                         (size_t)&guard[j]);
  26.                     _fail(file, line);
  27.                 }
  28.             }
  29.         }
  30.     }
  31.     list_remove(&block_info->node, NULL, NULL);
  33.     block = block_info->block;
  34.     memset(block, MALLOC_FREE_PATTERN, block_info->allocated_size);
  35.     free(block);
  36. }
  37. #define free test_free
    _test_free函数用于释放_test_calloc或者_test_malloc函数所申请到的内存，由block_info = (MallocBlockInfo*)(block - (MALLOC_GUARD_SIZE +sizeof(*block_info)));
计算出来整块内存的索引信息，从而可以拿到保障内存区域（方法：char *guards[2] = {block - MALLOC_GUARD_SIZE,block + block_info->size};），以及用户使用的内存区域。然后循环检测进行校验是否发生了改变，如果有变化，说明了上溢出或者下溢出，异常处理。如果没有异常，那么从链表中将这个内存节点取下来，并进行释放。至于内存泄露的情况是在哪里检查的，有一个函数叫做fail_if_blocks_allocated，在这个里面对于所有的内存节点进行扫描然后得到内存的状态，并进行报错的。









【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/cfzhang/p/d5a067810c959865a97bef5734f3d00f.html