内存泄漏专题（7）hook之宏定义

前面介绍的mtrace也好，bcc也罢，其实都是hook技术的一种实现，但是mtrace本身使用场景上有局限，而bcc环境依赖则十分复杂。因此，这些调试手段只适用于开发环境用来调试，对于生产环境，均不是一个非常好的方法。

但其实所谓的hook技术，本身并不复杂，说白了就是重载malloc/free函数，让代码在调用malloc函数时，先调用我们自己定义的malloc，由自定义的malloc完成一些前置统计工作后，再去调用系统的malloc，从而完成一些内存的统计分析。明白了这一点，其实我们可以轻而易举地自己实现一套hook机制，嵌入到代码中，这样带来的好处显而易见：

• 不依赖其他检测工具，可以非常方便地在开发环境甚至在线上进行调试
• 可以在代码里通过开关的方式控制是否检测内存泄漏，如线上默认关闭，如果怀疑出现内存泄漏，则将开关打开，可以非常方便地定位问题
• 系统无关，可以针对不同操作系统有不同的实现，这对于跨平台的应用非常有帮助。

对于C语言，我们可以用dlsym去修改动态链接的函数（备注：dlsym函数是GNU扩展），但dlsym的最大劣势仍然是只能在Linux下使用，那么，有没有一套跨平台的方案，可以在所有平台上运行呢？其实也是有的。

那就是通过宏定义的方式，将malloc/free这些函数替换成我们自己实现的钩子函数。比如我们有如下定义：

//mcheck.h
#ifndef _MCHECK_H_
#define _MCHECK_H_

#include<stddef.h>

void mcheck_initialize();
void mcheck_terminate();

void *malloc_hook(size_t size, const char *file, int line);
void *calloc_hook(size_t nmemb, size_t size, const char *file, int line);
void *realloc_hook(void *ptr, size_t size, const char *file, int line);
void free_hook(void *p, const char *file, int line);

#define malloc(size)            malloc_hook(size, __FILE__, __LINE__)
#define calloc(nmemb, size)     calloc_hook(nmemb, size, __FILE__, __LINE__)
#define realloc(ptr, size)       realloc_hook(ptr, size, __FILE__, __LINE__)
#define free(p)                 free_hook(p, __FILE__, __LINE__)

#endif

由于宏定义是直接替换，因此，有了上面的代码，在执行malloc的时候，实际上执行的是malloc_hook函数。而我们只需要在实现malloc_hook/free_hook的时候加上一些统计信息就行了。

在此之前，我们封装一个链表，用来存储每次申请内存的地址以及申请内存的大小，在每次申请内存的时候，向链表添加一条数据，每次释放的时候，将对应的记录删除掉，那么，当程序结束，如果链表还有数据，那就是没有释放的泄露部分的内存。

当然你也可以用其他的数据接口来存储，这里为了简单演示，就直接使用链表了。

// meminfo.h
#ifndef _MEMINFO_H_
#define _MEMINFO_H_

#include<stddef.h>
#include<stdio.h>
#include<stdlib.h>

typedef enum mcheck_errcode_t
{
    MCHECK_SUCCESS,
    MCHECK_FAILED,
}mcheck_errcode_t;

typedef struct mcheck_caller_t
{
    const char *file;
    int line;
    const char *func;
} mcheck_caller_t;

typedef struct mcheck_meminfo {
    void    *address;
    size_t  size;
    mcheck_caller_t caller;
}mcheck_meminfo;

typedef struct mcheck_mem_list {
    mcheck_meminfo mem_info;
    struct mcheck_mem_list *next;
}mcheck_mem_list;

int mcheck_mem_list_create(mcheck_mem_list **list);
int mcheck_mem_list_add(mcheck_mem_list *mlist, mcheck_meminfo mem_info);
mcheck_mem_list *mcheck_mem_list_get(mcheck_mem_list *mlist, void *address);
int mcheck_mem_list_delete(mcheck_mem_list *mlist, void *address);
int mcheck_list_size(mcheck_mem_list *mlist);
void mcheck_list_report_leak(mcheck_mem_list *mlist);
void mcheck_list_destory(mcheck_mem_list *mlist);
void init_report_file();

#endif

定义如下：

//meminfo.c
#include "meminfo.h"

int mcheck_mem_list_create(mcheck_mem_list **mlist){
    if (*mlist != NULL) {
        mcheck_list_destory(*mlist);
    }

    *mlist = (mcheck_mem_list *)calloc(1, sizeof(mcheck_mem_list));
    if (*mlist == NULL) {
        return MCHECK_FAILED;
    }
    (*mlist)->next = NULL;
    return MCHECK_SUCCESS;
}

int mcheck_mem_list_add(mcheck_mem_list *mlist, mcheck_meminfo mem_info)
{
    mcheck_mem_list *node = NULL;
    mcheck_mem_list_create(&node);
    node->mem_info = mem_info;
    if (mlist == NULL)
    {
        mlist = node;
        return MCHECK_SUCCESS;
    }
    while (mlist->next != NULL)
    {
        mlist = mlist->next;
    }
    mlist->next = node;
    return MCHECK_SUCCESS;
}

mcheck_mem_list *mcheck_mem_list_get(mcheck_mem_list *mlist, void *address){
    if (mlist == NULL) {
        return NULL;
    }
    mcheck_mem_list *node = mlist;
    while (mlist != NULL) {
        if (address == mlist->mem_info.address) {
            return node;
        }
        mlist = mlist->next;
    }
    return NULL;
}

int mcheck_mem_list_delete(mcheck_mem_list *mlist, void *address){
    if (mlist == NULL) {
        return MCHECK_FAILED;
    }

    mcheck_mem_list *current = mlist;
    mcheck_mem_list *prev = mlist;

    while (current != NULL) {
        if (current->mem_info.address == address) {
            if (mlist == current) {
                if (current->next = NULL) {
                    mlist = NULL;
                } else {
                    mlist = mlist->next;
                }
            } else {
                prev->next = current->next;
            }
            free(current);
            return MCHECK_SUCCESS;
        }
        prev = current;
        current = current->next;
    }
    return MCHECK_FAILED;
}

int mcheck_list_size(mcheck_mem_list *mlist){
    if (mlist == NULL)   {return 0;}
    int size = 0;
    while(mlist->next != NULL)
    {
        size++;
        mlist = mlist->next;
    }
    return size;
}

void mcheck_list_destory(mcheck_mem_list *mlist){
    if (mlist == NULL) {
        return;
    }

    mcheck_mem_list *current = mlist;
    mcheck_mem_list *prev = mlist;
    while (prev != NULL) {
        current = current->next;
        free(prev);
        prev = current;
    }
    mlist = NULL;
}

static char *get_report_filename(){
    char *fname = getenv("MCHECK_TRACE");
    if (fname == NULL) {
        fname = "mcheck.rpt";
    }
    return fname;
}

void init_report_file(){
    char *fname = get_report_filename();
    FILE *fp = NULL;
    fp = fopen(fname, "w+");
    fclose(fp);
}

static void write_report_file(char *message){
    char *fname = get_report_filename();
    FILE *fp = NULL;
    fp = fopen(fname, "a+");
    fprintf(fp, "%s\n", message);
    fflush(stdout);
    fclose(fp);
}

void mcheck_list_report_leak(mcheck_mem_list *mlist){
    if (mcheck_list_size(mlist) == 0)
    {
        write_report_file("All memory was free, congratulations, well done!");
        return;
    }
    write_report_file("Memory Not Free:");
    write_report_file("-----------------------------");
    write_report_file("\tAddress\t\tSize\t\tCaller");
    mlist = mlist->next;
    while (mlist != NULL)
    {
        mcheck_meminfo mem_info = mlist->mem_info;
        char message[1024] = {0};
        sprintf(message, "\t%p\t%lu\tat\t%s:%d[%s]", 
            mem_info.address, 
            mem_info.size, 
            mem_info.caller.file, 
            mem_info.caller.line, 
            mem_info.caller.func);
        write_report_file(message);
        mlist = mlist->next;
    }
}

以上代码逻辑比较简单 ，就不一一解释了。接下来实现一下钩子函数：

#include<stdio.h>
#include<malloc.h>
#include "meminfo.h"

static mcheck_mem_list *mlist = NULL;

void mcheck_initialize()
{
    init_report_file();
    mcheck_mem_list_create(&mlist);
}

void mcheck_terminate(){
    mcheck_list_report_leak(mlist);
    mcheck_list_destory(mlist);
}

void *malloc_hook(size_t size, const char *file, int line)
{
    void *p = malloc(size);
    char buff[128] = {0};
    mcheck_meminfo meminfo = {0};
    mcheck_caller_t caller = {0};
    caller.file = file;
    caller.line = line;
    caller.func = "malloc";
    meminfo.address = p;
    meminfo.size = size;
    meminfo.caller = caller;
    mcheck_mem_list_add(mlist, meminfo);
    return p;
}

void *calloc_hook(size_t nmemb, size_t size, const char *file, int line)
{
    void *p = calloc(nmemb, size);
    char buff[128] = {0};
    mcheck_meminfo meminfo = {0};
    mcheck_caller_t caller = {0};
    caller.file = file;
    caller.line = line;
    caller.func = "calloc";
    meminfo.address = p;
    meminfo.size = nmemb*size;
    meminfo.caller = caller;
    mcheck_mem_list_add(mlist, meminfo);
    return p;
}

void *realloc_hook(void *ptr, size_t size, const char *file, int line)
{
    void *p = realloc(ptr, size);
    char buff[128] = {0};
    mcheck_meminfo meminfo = {0};
    mcheck_caller_t caller = {0};
    caller.file = file;
    caller.line = line;
    caller.func = "realloc";
    meminfo.address = p;
    meminfo.size = size;
    meminfo.caller = caller;
    mcheck_mem_list_add(mlist, meminfo);
    mcheck_mem_list_delete(mlist, ptr);
    return p;
}

void free_hook(void *p, const char *file, int line){
    mcheck_mem_list_delete(mlist, p);
    free(p);
}

如上所示，我们会在每次申请内存之前，收集其调用栈信息，并且封装了mcheck_initialize和mcheck_terminate两个接口函数，我们只需要在程序里调用这两个函数，就能检测出内存泄露的问题。

类似与下面这种：

#include <mcheck.h>

int main(void){
    mcheck_initialize();
    //your code
    mcheck_terminate();
    return 0;
}

下面我们用一个具体的示例演示一下：

#include "mcheck.h"

int main(void){
    mcheck_initialize();
    void *p1 = malloc(10);
    void *p2 = malloc(20);
    free(p1);
    //free(p2);
    void *p3 = malloc(30);
    free(p3);
    void *p4 = calloc(1, 64);
    void *p5 = malloc(32);
    void *p6 = realloc(p5, 128);
    mcheck_terminate();
    return 0;

我们注意在第1行包含了头文件，并在第4行和14行分别调用了mcheck的接口，这样的话，就可以检测出这个过程中出现的内存泄露问题，以上代码运行会产生一个名为mcheck.rpt的报告，内容如下：

Memory Not Free:
-----------------------------
	Address		Size		Caller
	0x1fde0b0	20	at	mcheck_sample.c:6[malloc]
	0x1fde300	64	at	mcheck_sample.c:11[calloc]
	0x1fde390	128	at	mcheck_sample.c:13[realloc]

它告诉我们第6，11，13行分别出现了内存泄露，大小是多少，调用的那么函数申请的内存，还是比较详细的。

但是这种方式也有缺陷。首先就是调用栈只有一层，不能打印出更深层的调用栈，不利于复杂程序的问题排查。其次是如果要使mcheck生效，必须每个.c里都要include该头文件，对于第三方库是没有办法检测到的，因此使用面也是比较有限。

---

本专栏知识点是通过<零声教育>的系统学习，进行梳理总结写下文章，对C/C++课程感兴趣的读者，可以点击链接，查看详细的服务：C/C++Linux服务器开发/高级架构师