Cleofwine | 开发者

后端技术_手写内存泄漏检测组件（施工）

最近更新：2024-11-09 | 字数总计：988 | 阅读估时：5分钟 | 阅读量：次

判断内存泄漏
1. 截获malloc
Try_Catch实现
1. 基础实现
2. 完整实现

判断内存泄漏

调用malloc但是没有调用free，就会产生内存泄漏

如果判断出现了内存泄漏？
在那里泄漏了？

截获malloc

宏定义
hook
__libc_malloc

预编译替代malloc

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

#if 1

void* _malloc(size_t size, const char* filename, int len)
{
    // 宏定义放在后面，不影响这里
    void *ptr = malloc(size);
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", ptr);
    FILE *fp = fopen(buff, "w");
    fprintf(fp, "malloc, filename = %s, line = %d\n", filename, len);
    printf("malloc, filename = %s, line = %d\n", filename, len);
    fflush(fp);
    fclose(fp);
    return ptr;
}

void _free(void*ptr, const char* filename, int len)
{
    // 当发生内存泄漏的时候，mem文件夹下会有文件记录了文件和行
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", ptr);
    if(unlink(buff) < 0){ // 不存在
        printf("double free!\n");
        return;
    }
    printf("free, filename = %s, line = %d\n", filename, len);
    free(ptr);
}

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

#endif

int main()
{
    void *p1 = malloc(5); // 这里会自动传入调用malloc的行号和文件名
    void *p2 = malloc(10);
    void *p3 = malloc(15);
    
    free(p1);
    free(p2);
}

适用单文件
如何查线上内存泄漏：（开关+热更新）#if 0 这一段可以放在任意代码的最前面，不用改任何业务逻辑，适用于线上之间用该开关+热更新的方式查内存泄漏
热更新方法：本身程序具备了从配置文件中读取配置的功能，配置文件改值，程序能重新读取，那么就可以实现热更新

Hook掉malloc

// gcc -o memleak2 memleak2.c -ldl
#define _GNU_SOURCE
#include <dlfcn.h>

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

int enable_malloc_hook = 1;
int enable_free_hook = 1;

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

typedef void (*free_t)(void *ptr);
free_t free_f;

void *malloc(size_t size)
{
    // 不能直接这样，因为printf里调用了malloc，这样会递归栈溢出
    // printf("malloc\n");
    void *ptr = NULL;
    if(enable_malloc_hook){
        enable_malloc_hook = 0;
        printf("malloc\n");
        ptr = malloc_f(size);

        // 编译器自带的，0代表上一级的调用位置，1代表上上级...
        void *caller = __builtin_return_address(0);

        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", ptr);
        FILE *fp = fopen(buff, "w");
        // addr2line -f -e ./memleak -a 0x55556bec16b0
        fprintf(fp, "malloc, caller = %p, addr = %p, size = %ld\n", caller, ptr, size);

        fflush(fp);
        // fclose(fp);
        enable_malloc_hook = 1;
    }else{
        ptr = malloc_f(size);
    }
    return ptr;
}
void free(void* ptr)
{
    if(enable_free_hook){
        enable_free_hook = 0;
        printf("free\n");
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", ptr);
        if(unlink(buff) < 0){ // 不存在
            printf("double free!\n");
            return;
        }
        free_f(ptr);
        enable_free_hook = 1;
    }
    else{
        free_f(ptr);
    }
}

void init_hook(void)
{
    if(!malloc_f){
        malloc_f = dlsym(RTLD_NEXT, "malloc");
    }
    if(!free_f){
        free_f = dlsym(RTLD_NEXT, "free");
    }
}

int main()
{
    init_hook();
    void *p1 = malloc(5); // 这里会自动传入调用malloc的行号和文件名
    void *p2 = malloc(10);
    void *p3 = malloc(15);
    
    free(p1);
    free(p2);
}

适用多文件

调用libc函数

malloc函数不是系统调用（不需要系统中断）它是一个libc接口

#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

// libc
// malloc(); --> __libc_malloc();
extern void *__libc_malloc(size_t size);
extern void __libc_free(void *ptr);

int enable_malloc_hook = 1;
int enable_free_hook = 1;

void *malloc(size_t size) {
	void *ptr = NULL;
	if (enable_malloc_hook) {
		enable_malloc_hook = 0;
		ptr = __libc_malloc(size);
		void *caller = __builtin_return_address(0);
		char filename[128] = {0};
		sprintf(filename, "./mem/%p.mem", ptr);
		FILE *fp = fopen(filename, "w");
		fprintf(fp, "[+] caller: %p, addr: %p, size: %ld\n", caller, ptr, size);
		fflush(fp);
		enable_malloc_hook = 1;
	} else {
		ptr = __libc_malloc(size);
	}
	return ptr;
}

void free(void *ptr) {
	if (enable_free_hook) {
		enable_free_hook = 0;
        char buff[128] = {0};
		sprintf(buff, "./mem/%p.mem", ptr);
		if (unlink(buff) < 0) { // filename no exist;
			printf("double free: %p\n", ptr);
			return ;
		}
		__libc_free(ptr);
		enable_free_hook = 1;
	} else {
		__libc_free(ptr);
	}
}

int main() {

	init_hook();

	void *p1 = malloc(5);  //_malloc
	void *p2 = malloc(10);
	void *p3 = malloc(15);

	free(p1);
	free(p3);

}

找出另外两种截获malloc方式

Try_Catch实现

基础实现
- setjmp第一次返回0，剩余返回longjmp的值
- longjmp(env, idx)，无返回函数，栈直接覆盖
嵌套，单链表解决嵌套
线程安全问题，pthread_key_t(单链表的头存入)

基础实现

#include <stdio.h>
#include <setjmp.h>
#define TRY		int count = setjmp(env); if (count == 0)
#define CATCH(x) 		 else if (count == (x))
#define THROW(idx)		longjmp(env, (idx))
#define FINALLY	

jmp_buf env;
void func(int idx)
{
    printf("func --> idx: %d\n", idx);
    THROW(idx);
}
int main()
{
    TRY{
        printf("count --> %d\n", count);
        func(++count);
    }
    CATCH(1){
        printf("count --> %d\n", count);
        func(++count);
    }
    CATCH(2){
        printf("count --> %d\n", count);
        func(++count);
    }
    CATCH(3){
        printf("count --> %d\n", count);
        func(++count);
    }FINALLY{
        printf("other count --> %d\n", count);
    }
}

完整实现

2024-03-05 该篇文章被 Cleofwine 归为分类: 服务端