内存泄漏检测工具-学习(一)

一、内存泄漏

1、是C/C++中常见的问题，其他语言基本不存在内存泄漏问题

因为要使用系统调用API，malloc/free管理虚拟内存中的堆区；那么内存泄漏主要指的就是堆区上的内存。

2、堆有多大？

无限制，一直向上增长。

3、内存泄漏的原因？

调用malloc/new分配内存后，忘记调用free/delete释放。

4、如何判断有没有内存泄漏？

系统命令-htop，看内存是否一直在增长，但不严谨，不能百分比确定是否是内存泄漏；
所以还是得需要一个内存泄漏检测工具。

二、具体实现

1、构造内存泄漏场景

malloc分配内存后，但不释放。

void *Malloc(size_t size, const char *file, int line, const char *func)
{
    void *ptr = NULL;
    printf("malloc size %d from %s:%d in %s\n", size, file, line, func);
    return ptr;
}

void Free(void *ptr, const char *file, int line, const char *func)
{
    printf("free ptr %p from %s:%d in %s\n", ptr, file, line, func);
}

这样属于伪分配内存，再进一步优化

#define malloc(size) Malloc(size, __FILE__, __LINE__, __func__)
#define free(ptr) Free(ptr, __FILE__, __LINE__, __func__)

void *Malloc(size_t size, const char *file, int line, const char *func)
{
    void *ptr = malloc(size);
    printf("malloc size %d from %s:%d in %s\n", size, file, line, func);
    return ptr;
}

void Free(void *ptr, const char *file, int line, const char *func)
{
    printf("free ptr %p from %s:%d in %s\n", ptr, file, line, func);
    free(ptr);
}

好家伙，直接coredump了 ，细查原因，原来是触发死循环的递归了，当调用malloc时，又会调用到自定义的Malloc,反复调用，一直把栈溢出了。

int flag_malloc = 0;
int flag_free = 0;
void *Malloc(size_t size, const char *file, int line, const char *func)
{
    void *ptr = NULL;
    if (flag_malloc == 0){
        flag_malloc = 1;
        ptr = malloc(size);
    }

    printf("malloc size %d from %s:%d in %s\n", size, file, line, func);
    return ptr;
}

void Free(void *ptr, const char *file, int line, const char *func)
{
    if(flag_free == 0){
        flag_free = 1;
        free(ptr);
    }
    printf("free ptr %p from %s:%d in %s\n", ptr, file, line, func);
    
}

当前输出信息少，可以通过肉眼观察出来哪个地方出现内存泄漏，但几十上百万条记录，肉眼就很难判断了。

2、想个方案只记录存在内存泄漏的信息

• 使用链表记录开辟内存的节点，每释放一次，就删除一个节点，最后看链表是否为空，来判断是否存在内存泄漏；缺点就是需要不停地遍历，链表的遍历效率太低。
• 使用红黑树，插入删除操作快，遍历速度也快，但就是需要控制下打印输出
• 通过写文件来判断，每开辟一块内存，就建一个文件，每释放一块内存，就删除一个文件，最后查看是否存在文件来判断是否内存泄漏。

void *Malloc(size_t size, const char *file, int line, const char *func)
{
    void *ptr = malloc(size);
    char buff[1024] = {0};
    printf("%p\n", ptr);

    snprintf(buff, 1024, "./%p.mem", ptr);

    FILE *fp = fopen(buff, "w");
    if (!fp)
    {
        free(ptr);
        return NULL;
    }
    fprintf(fp, "[+][%s:%s:%d] %p: %ld malloc\n", file, func, line, ptr, size);

    fflush(fp);
    fclose(fp);

    return ptr;
}

void Free(void *ptr, const char *file, int line, const char *func)
{
    char buff[1024] = {0};

    free(ptr);
    snprintf(buff, 1024, "./%p.mem", ptr);

    if (unlink(buff) < 0)
    { // if file not exist, unlink will return -1
        printf("double free: %p\n", ptr);
        return;
    }
}

这样就简洁多了，但是有个问题就是，目前对于源文件较少的话可以使用，源文件一多，尤其是引入动态链接库，那就不好用了。

3、对于多文件，如何定位内存泄漏

***利用hook的特性：***不修改原有代码的情况下，扩展或修改程序的行为。

• 这次就不需要重新宏定义malloc和free了

/**
 * @brief 自定义的malloc函数，用于在分配内存时记录分配信息
 *
 * 在调用实际的malloc函数分配内存之前，如果flag_malloc标志位为1，则记录分配的内存地址、调用者地址以及分配的大小到文件中。
 *
 * @param size 要分配的内存大小（以字节为单位）
 * @return 分配的内存地址指针，如果分配失败则返回NULL
 */
void *malloc(size_t size)
{
    //使用dlsym函数从动态链接库中获取真实的malloc函数地址
    if (!real_malloc)
    {
        real_malloc = (malloc_t)dlsym(RTLD_NEXT, "malloc");
    }

    void *ptr = NULL;

    if (flag_malloc)
    {
        flag_malloc = 0;

        ptr = real_malloc(size);

        void *caller = __builtin_return_address(0);     //使用__builtin_return_address(0)获取调用者地址是GCC特有的内建函数
        char buff[1024] = {0};

        snprintf(buff, 1024, "./%p.mem", ptr);

        FILE *fp = fopen(buff, "w");
        if (!fp)
        {
            free(ptr);
            return NULL;
        }
        fprintf(fp, "[+][%p] %p: %ld malloc\n", TranslateToSymbol(caller), ptr, size);

        fflush(fp);

        flag_malloc = 1;
    }
    else
    {
        ptr = real_malloc(size);
    }

    return ptr;
}

/**
 * @brief 自定义的内存释放函数
 *
 * 该函数通过动态链接库函数 dlsym 获取标准库中的 free 函数指针，并使用该指针释放传入的内存指针。
 * 在释放内存之前，会尝试删除与内存指针对应的临时文件（如果文件存在），以避免重复释放内存。
 *
 * @param ptr 需要释放的内存指针
 */
void free(void *ptr)
{
    if (!real_free)
    {
        real_free = (free_t)dlsym(RTLD_NEXT, "free");
    }

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

    if (unlink(buff) < 0)
    { // if file not exist, unlink will return -1
        printf("double free: %p\n", ptr);
        return;
    }

    real_free(ptr);
}

/**
 * @brief 将内存地址转换为符号地址
 *
 * 将传入的内存地址转换为相对于共享库起始地址的偏移量。
 *
 * @param addr 传入的内存地址
 * @return 转换后的符号地址，如果转换失败则返回NULL
 */
void *TranslateToSymbol(void *addr)
{
    Dl_info info;
    struct link_map *l = NULL;
    if (dladdr1(addr, &info, (void **)&l, RTLD_DL_LINKMAP))
    {
        return (void *)(addr - l->l_addr);
    }
    return NULL;
}

三、总结

1、内存泄漏是C/C++开发中常见的问题，主要是malloc/new分配的内存没有被释放，导致内存占用不断增加。

2、内存泄漏的检测方法有：

- 使用工具如Valgrind、AddressSanitizer等静态或动态分析。
- 专门的内存泄漏检测工具
- 自定义检测代码，自定义宏或者hook malloc/free函数记录内存分配和释放信息。

3、C++中可以使用智能指针（如std::shared_ptr、std::unique_ptr）自动管理内存，减少手动释放的需要。

四、拓展问题：

1、服务器线上出现内存泄漏，如何解决？

• 线上需要有内存泄漏检测模块。
• 通过热更新，打开内存泄漏模块。
• 待解决之后，在晚上人少时，将服务器down掉，重新编译代码，然后重启服务器。

代码：
Code