内存泄漏检测组件的分析与实现（linux c）-mtrace工具使用

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <malloc.h>
#include <mcheck.h>
void *malloc(size_t size){
  printf("malloc");
  return NULL;
}
void free(void *p){
  // printf("free");
}
int main(){
  void *p1 = malloc(10);
  void *p2 = malloc(20);
  free(p1);
  return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdint.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <syslog.h>
#include <unistd.h>
extern void *__libc_malloc(size_t size); //malloc.h里面定义的
int enable_malloc_hook = 1;              //终止递归的变量（具体参考malloc函数说明）
extern void __libc_free(void *p);
int enable_free_hook = 1;
void *malloc(size_t size)
{
    if (enable_malloc_hook)
    { //调用系统
        enable_malloc_hook = 0;
        void *p = __libc_malloc(size); //分配内存，系统的malloc实际上也是调用的这个api进行内存分配。
        //返回malloc调用完成时的地址，可以结合addr2line命令定位到哪一行内存泄露。
        void *caller = __builtin_return_address(0);
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p); //使用malloc返回的地址作为文件名(p.mem)
        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+%p] --> addr:%p, size:%ld\n", caller, p, size);
        fflush(fp);
        //fclose(fp);//注意不能close文件
        //printf函数内部会调用malloc，如果不用enable_malloc_hook变量会导致递归malloc的使用
        printf("malloc :%p\n", p);
        //保证下次调用malloc进入到if，注意，多线程不是线程安全的
        enable_malloc_hook = 1;
        return p;
    }
    else
    { //如果是其他API(比如printf)调用了malloc，会直接调用__lib_malloc(size_t size)进行分配，从而使得递归得以退出
        return __libc_malloc(size);
    }
}
void free(void *p)
{
    if (enable_free_hook)
    { //调用free
        enable_free_hook = 0;
        __libc_free(p);
        char buff[128] = {0};
                sprintf(buff, "./mem/%p.mem", p);
        if (unlink(buff) < 0) //删除文件，如果返回小于0，说明释放了2次
        {
            printf("double free:%p\n", p);
        }
        printf("free:%p\n", p);
        enable_free_hook = 1; //保证下次free,还走if
    }
    else
    { //其他系统API调用会直接调用__libc_free.
        __libc_free(p);
    }
}
int main()
{
    void *p1 = malloc(10);
    void *p2 = malloc(20);
    free(p1);
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdint.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <syslog.h>
#include <unistd.h>
void *malloc_hook(size_t size, const char *file, const char *func, int line)
{
    void *p = malloc(size);
    char str[256] = {0};
    sprintf(str, "./mem/%p.mem", p);
    FILE *fp = fopen(str, "w");
    fprintf(fp, "[info:]file:%s,func:%s,line:%d, addr:%p,size:%ld\n", file, func, line, p, size);
    fflush(fp);
    fclose(fp);
    return p;
}
void free_hook(void *p, const char *file, const char *func, int line)
{
    free(p);
    char str[256] = {0};
    sprintf(str, "./mem/%p.mem", p);
    if (unlink(str) < 0)
    {
        printf("double free.\n");
    }
}
//宏定义要定义在函数的下面,因为malloc_hook里面使用了malloc
//如果宏定义在函数的前面，会导致递归
#define malloc(size) malloc_hook(size, __FILE__, __FUNCTION__, __LINE__)
#define free(p) free_hook(p, __FILE__, __FUNCTION__, __LINE__);
#endif
int main()
{
    void *p1 = malloc(10);
    void *p2 = malloc(20);
    free(p1);
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdint.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <syslog.h>
#include <unistd.h>
typedef void *(*malloc_hook_t)(size_t size, const void *caller); //系统的__malloc_hook实际的函数类型
malloc_hook_t malloc_f;                                          //用于保存系统默认的__malloc_hook函数地址
typedef void (*free_hook_t)(void *p, const void *caller);        //系统的__free_hook的实际函数类型
free_hook_t free_f;                                              //用于保存系统默认的__free_hook函数指针地址
int replaced = 0;                                                //如果为1，malloc/free指向我们自定义的函数
void mem_trace(void);                                            //让其malloc指向我们自己定义的函数
void mem_untrace(void);                                          //让其free指向我们自己定义的函数
//自定义的malloc函数，与系统的__malloc_hook保持一致
//caller参数代表调用该函数的地址(__builtin_return_address(0)返回的地址就是这个地址)
void *malloc_hook_f(size_t size, const void *caller)
{
    //防止递归-如果不加这句，会让下面的malloc继续执行malloc_hook_f，从而造成递归
    //我们只要得到caller指针这个值就可以了。
    mem_untrace();
    void *ptr = malloc(size);
    //printf("+%p: addr[%p]\n", caller, ptr);
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", ptr);
    FILE *fp = fopen(buff, "w");
    fprintf(fp, "[+%p] --> addr:%p, size:%ld\n", caller, ptr, size);
    fflush(fp);
    fclose(fp);  //free
    mem_trace(); //保证下次malloc还是用我们自定义的
    return ptr;
}
void free_hook_f(void *p, const void *caller)
{
    mem_untrace(); //防止free函数递归
    //printf("-%p: addr[%p]\n", caller, p);
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);
    if (unlink(buff) < 0)
    { // no exist
        printf("double free: %p\n", p);
        return;
    }
    free(p);
    mem_trace();
}
void mem_trace(void)
{ //mtrace
    replaced = 1;
    malloc_f = __malloc_hook;      //__malloc_hook是系统本身提供的函数指针(会在malloc调用时初始化)
    free_f = __free_hook;          //__free_hook是系统本身提供的(free调用时会初始化)
    __malloc_hook = malloc_hook_f; //指向我们自定义函数，malloc会调用我们定义的函数
    __free_hook = free_hook_f;     //指向我们自定义函数，free会调用我们自定义的函数
}
//
void mem_untrace(void)
{
    __malloc_hook = malloc_f;
    __free_hook = free_f;
    replaced = 0;
}
int main()
{
    mem_trace();
    void *p1 = malloc(10);
    void *p2 = malloc(20);
    free(p1);
    mem_untrace();
    return 0;
}

#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <malloc.h>
#include <mcheck.h>
int main()
{
  mtrace();
  void *p1 = malloc(10);
  void *p2 = malloc(20); //
  free(p1);
  muntrace();
    return 0;
}