内存泄漏检测相关内容

1 拦截 malloc free函数

通过拦截 malloc，free函数，然后以宏定义的方式，改造malloc, free: malloc的时候根据指针地址写一个文件，
free的时候根据指针地址删除这个文件。最后根据留下的文件就可以知道哪个new没有释放内存了。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void *_malloc(size_t size, const char *filename, int line) {

	void *ptr = malloc(size); 
	
	char buff[128] = {0};
	sprintf(buff, "./mem/%p.mem", ptr);
	
	FILE *fp = fopen(buff, "w");
	fprintf(fp, "[+]addr: %p, filename: %s, line: %d\n", ptr, filename, line);

	fflush(fp);
	fclose(fp);
	
	
	return ptr;
}

void _free(void *ptr, const char *filename, int line) {

	char buff[128] = {0};
	sprintf(buff, "./mem/%p.mem", ptr);

	if (unlink(buff) < 0) { // filename no exist;
		printf("double free: %p\n", ptr);
		return ;
	}
	
	return free(ptr);
}


#define malloc(size)  _malloc(size, __FILE__, __LINE__)
#define free(ptr)	_free(ptr, __FILE__, __LINE__)

方法1的弊端是，最好是用在一个.c文件中，如果文件较多的话就不太适用。

2 hook malloc/free

同方法1，不过这里使用的是dlsym 来hook malloc/free来代替方法1，通过caller = __builtin_return_address(0)获取
调用者，就算是在不同的文件里也适用

typedef void *(*malloc_t)(size_t size);
typedef void *(*free_t)(size_t size);

malloc_t malloc_f = NULL;
free_t free_f = NULL;

int enable_malloc_hook = 1;
int enable_free_hook = 1;
void *malloc(size_t size){
    void p;
    if(enable_malloc_hook){ // 避免 递归调用 加标志enable_malloc_hook
        enable_malloc_hook = 0;
        p = malloc_f(size);
        printf("malloc\n");  

        void  caller = __builtin_return_address(0);
        printf("caller = %p\n", caller);

        char buff[128] = {0};
        sprintf(buff, "./%p.mem", p); // filename
        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+]%p:%d addr: %p, size: %ld \n", caller,  __LINE__, p, size);  //这里的 LINE 不符合要求
        ///
        /// 用这个命令找到有malloc没有free的地方： addr2line -f -e 应用程序 -a caller(指针地址) ==> 函数+line
        ///
        fflush(fp);
        enable_malloc_hook = 1;
    } else {
        p = malloc_f(size);
    }
    return p;
}
void free(void *ptr){
    if(enable_free_hook){
        enable_free_hook = 0;

        char buff[128] = {0};
        sprintf(buff, "./%p.mem", ptr); // filename
        if(unlink(buff) < 0){  // file not exist;    double free
            printf("double free: %p\n", ptr);
            //return ptr;
        }

        enable_free_hook = 1;
    } else {
        free_f(reinterpret_cast<size_t>(ptr));
    }
    printf("free\n");
    //return ptr;
}
void Init_hook(void){
    if(malloc_f == NULL){
        malloc_f = (malloc_t)dlsym(RTLD_NEXT, "malloc"); //这里得到函数调用的入口
    }
    if(free_f == NULL){
        free_f = (free_t)dlsym(RTLD_NEXT, "free");
    }
}

int main(){
    Init_hook(); 
    void *p1 = malloc(5);
    void *p2 = malloc(15);
    void *p3 = malloc(25);
    free(p1);
    free(p2);
    return 0;
}

3 封装底层的malloc free

用更加底层的函数申请内存，释放内存
libc中含有 malloc free ，所以它们不是系统调用
所以可以参考如下：

extern void * __libc_malloc(size_t size)
extern void * __libc_free(void * p)

void * malloc(size_t size) {
	__libc_malloc(x);  //  这里相当于用了一个跟家底层的接口
}

其它部分类似方法2

4 使用 bpftrace工具

bpftrace要求 linux5.4及以上支持
bpftrace // 可以不用管对方的代码 ，在内核允许的情况下
uprobe 可以挂函数名（内存）、网络、进程调度、内核执行流程等都可以的
在目标程序memleak同级目录下touch一个mem.bt的文件，输入下面的内容，

uprobe:/lib/x86_64-linux-gnu/libc.so.6:malloc
/comm == "memleak" /
{
    printf("malloc\n");
}
uprobe:/lib/x86_64-linux-gnu/libc.so.6:free
/comm == "memleak" /
{
    printf("free\n");
}

然后：
1 一个终端运行 bpftrace mem.bt
2 接着另一个终端 ./memleak (memleak 是类似标题1中的程序名)
memleak.c // gcc memleak.c -o memleak
int main(){

		    void *p1 = malloc(5);
		    void *p2 = malloc(15);
		    void *p3 = malloc(25);
		    free(p1);
		    free(p2);
		    return 0;
		}

如下图：可以查内存泄漏了malloc与 free 的数量不一样，说明有内存没有释放

5 还是bpf工具，监测进程

稍稍改变一下测试程序

int main() {

	while(1){
		void *p1 = malloc(5);
		void *p2 = malloc(5);
		void *p3 = malloc(5);
		
		
		free(p1);
		free(p2);
		sleep(1);
	}
}

运行上面的测试程序，查看进程id

对应进程id是111806，touch一个mempid.bt修改内容如下

uprobe:/lib/x86_64-linux-gnu/libc.so.6:malloc
/pid == 111806/
{
    printf("malloc\n");
}

uprobe:/lib/x86_64-linux-gnu/libc.so.6:free
/pid == 111806/
{
    printf("free\n");
}

运行测试程序：bpftrace mempid.bt，可得如下输出结果

通过过bpftrace方法查到内存泄露的情况，适用于测试看不到源码的程序。
文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习:链接