【C/C++】什么是内存泄漏？如何检测内存泄漏？

  • 开发
  • 26

一、内存泄漏概述

1.1 什么是内存泄漏

内存泄漏是在没有自动 gc 的编程语言里面，经常发生的一个问题。

自动垃圾回收（Automatic Garbage Collection，简称 GC）是一种内存管理技术，在程序运行时自动检测和回收不再使用的内存对象，以避免内存泄漏和释放已分配内存的负担。

因为没有 gc，所以分配的内存需要程序员自己调用释放。其核心原因是调用分配与释放没有符合开闭原则，没有配对，形成了有分配，没有释放的指针，从而产生了内存泄漏。

void func(size_t s1)
{
	void p1=malloc(s1);
	void p2=malloc(s1);
	free(p1);
}

以上代码段，分配了两个s1大小的内存块，由 p1 与 p2 指向。而代码块执行完以后，释放了 p1，而 p2 没有释放。形成了有分配没有释放的指针，产生了内存泄漏。

1.2 内存泄漏导致的后果

随着工程代码量越来越多，有分配没有释放，自然会使得进程堆的内存会越来越少，直到耗尽。从而导致后面的运行时代码不能成功分配内存，使程序奔溃。

1.3 内存泄漏解决思路

最好的办法肯定是引入自动垃圾回收gc。但是这不适合C/C++语言。

解决内存泄漏，我们需要解决两点：

1）能够检测出来是否发送内存泄漏

2）如果发生内存泄漏，能够检测出来具体是哪一行代码所引起的。

内存泄漏是由于内存分配与内存释放，不匹配所引起的。因此对内存分配函数malloc/calloc/realloc，以及内存释放函数free进行“劫持”hook，就能能够统计出内存分配的位置，内存释放的位置，从而判断是否匹配。

二、宏定义方法

2.1 宏定义

使用宏定义，替换系统的内存分配接口。并利用__FILE__、__LINE__分别获取当前编译文件的文件名、行号，进行追踪位置信息。

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

需要注意的是，宏定义一定要放在内存分配之前，这样预编译阶段才会替换为我们自己实现的_malloc和_free。

2.2 检测位置

为了方便观察，我们可以在内存分配_malloc的时候，创建一个文件。文件名为指向新分配内存的指针值，文件内容为指针值、调用_malloc时的文件名、行号。

在该内存释放_free的时候，删除该指针对应的文件。

最后，程序运行结束，如果没有文件说明没有内存泄漏，否则说明存在内存泄漏。

2.3 结果分析

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

void *_malloc(size_t size, const char *filename, int line){
    void *ptr = malloc(size);
    
    char buffer[128] = {0};
    sprintf(buffer, "./memory/%p.memory", ptr);

    FILE *fp = fopen(buffer, "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 buffer[128] = {0};
    sprintf(buffer, "./memory/%p.memory", ptr);

    if (unlink(buffer) < 0){
        printf("double free: %p\n", ptr);
        return;
    }

    return free(ptr);
}

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

int main() {

    void *p1 = malloc(5);
    void *p2 = malloc(18);
    void *p3 = malloc(15);

    free(p1);
    free(p3);

}

最后在memory文件夹里，可以看到存在一个文件，说明有一个地方出现内存泄漏

[+]addr: 0x559e55b6e8b0, filename: fun1.c, line: 39

从结果上看，内存泄漏发生第39行。

相关视频推荐

c/c++后端服务器开发必学基础组件设计与实现，实操+手写代码，2024跳槽涨薪必备教程！内容包含（线程池、内存池、多线程锁、死锁检测、内存泄漏、分布式锁..）icon-default.png?t=N7T8https://www.bilibili.com/video/BV11Z421v7Vx/

免费学习地址：Linux C/C++开发（后端/音视频/游戏/嵌入式/高性能网络/存储/基础架构/安全）

需要C/C++ Linux服务器架构师学习资料加qun579733396获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享

三、hook方法

利用 hook 机制改写系统的内存分配函数。

3.1 hook

hook方法的实现分三个步骤

1）定义函数指针。

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

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

2）函数实现，函数名与目标函数名一致。

void *malloc(size_t size)
{
	//改写的功能
}

void free(void *ptr)
{
	//改写的功能
}

3）初始化hook，调用dlsym()。

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

    if (!free_f){
        free_f = dlsym(RTLD_NEXT, "free");
    }
}

3.2 检测位置

宏定义的方法在检测调用所在行号的时候使用了系统定义的__LINE__，因为是宏定义的malloc，预编译时候直接嵌入。因此__LINE__返回的就是调用malloc的位置。

但是hook方法不一样，系统定义的__LINE__在函数内部调用，无法确定在主函数中的调用位置。比如

fprintf(fp, "[+]addr: %p, filename: %s, line: %d\n", ptr, filename, line);

返回的就是fprintf所在的行号。

因此使用gcc 提供的__builtin_return_address，该函数返回当前函数或其调用者之一的返回地址。 参数level 表示向上扫描调用堆栈的帧数。比如对于 main --> f1() --> f2() --> f3() ，f3()函数里面调用 __builtin_return_address (0)，返回f3的地址；调用 __builtin_return_address (1)，返回f2的地址；

3.3 递归调用

hook的时候，要考虑其他函数也用到所hook住的函数，比如在printf()函数里面也调用了malloc，那么就需要防止内部递归进入死循环。

通过gdb调试，在第23行打断点，发现每次运行都回到了23行。

这是因为sprintf隐含调用了malloc，这样就陷入一个循环：

23行的sprintf —> 自定义的malloc —> 23行的sprintf —> 自定义的malloc --> 23行的sprintf —> 自定义的malloc --> ……

解决办法是，限制调用次数。当进入 malloc 函数内部后，根据自己的需要，设置 hook 的开关。在关闭的区域内调用 malloc 后进入到 else 部分执行原来的 hook 函数，避免了无限递归的发生。

int enable_malloc_hook = 1;
void *malloc(size_t size) { 
    // 执行改写的 malloc 函数
    if (enable_malloc_hook) {
        enable_malloc_hook = 0;
        // 关闭 hook, printf 内部的 malloc 执行 else 的部分
       // 其他代码
        enable_malloc_hook = 1;
    }
    // 执行原来的 malloc 函数
    else {
        p = malloc_f(size);
    }
}

3.4 结果分析

// gcc -o fun2 fun2.c -ldl -g

#define _GNU_SOURCE
#include <dlfcn.h>

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


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

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


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; 
        enable_free_hook = 0;

        ptr = malloc_f(size);

        void *caller = __builtin_return_address(0);

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

        FILE *fp = fopen(buffer, "w");
        fprintf(fp, "[+] caller: %p, addr: %p, size: %ld\n", caller, ptr, size);

        fflush(fp);
        fclose(fp);

        enable_malloc_hook = 1;
        enable_free_hook = 1;
    }
    else {
        ptr = malloc_f(size);
    }
    return ptr;
}

void free(void *ptr){

    if (enable_free_hook ){
        enable_free_hook = 0;
        enable_malloc_hook = 0;

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

        if (unlink(buffer) < 0){
            printf("double free: %p\n", ptr);
            return;
        }

        free_f(ptr);

        enable_malloc_hook = 1;
        enable_free_hook = 1;
    }
    else {

        free_f(ptr);
    }
}

void init_hook(){
    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);
    void *p2 = malloc(18);
    void *p3 = malloc(15);

    free(p1);
    free(p3);

}

从结果看存在一个内存泄漏，但是 caller：0x16bb 是地址，不是具体行号。使用addr2line可以将地址转换为文件名和行号。

3.5 addr2line

利用addr2line工具，将地址转换为文件名和行号，得到源文件的行数（根据机器码地址定位到源码所在行数)

addr2line -f -e fun2 -a 0x16bb

参数： -f：显示函数名信息。 -e filename：指定需要转换地址的可执行文件名。 -a address：显示指定地址（十六进制）。

但是，高版本 gcc 下使用 addr2line 命令会出现乱码问题。

??
??:0

addr2line 作用于 ELF 可执行文件，而高版本的 gcc 调用 __builtin_return_address返回的地址 caller 位于内存映像上，所以会产生乱码。

解决办法是利用动态链接库的dladdr函数 ，作用于共享目标，可以获取某个地址的符号信息。使用该函数可以解析符号地址

// gcc -o fun2 fun2.c -ldl -g

#define _GNU_SOURCE
#include <dlfcn.h>

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

// 解析地址
void* converToELF(void *addr) {
    Dl_info info;
    struct link_map *link;
    dladdr1(addr, &info, (void **)&link, RTLD_DL_LINKMAP);
    // printf("%p\n", (void *)(size_t)addr - link->l_addr);
    
    return (void *)((size_t)addr - link->l_addr);
}


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

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


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 = malloc_f(size);

        void *caller = __builtin_return_address(0);

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

        FILE *fp = fopen(buffer, "w");
        // converToELF(caller)
        fprintf(fp, "[+] caller: %p, addr: %p, size: %ld\n", converToELF(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;

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

        if (unlink(buffer) < 0){
            printf("double free: %p\n", ptr);
            return;
        }

        free_f(ptr);

        enable_free_hook = 1;
    }
    else {

        free_f(ptr);
    }
}

void init_hook(){
    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);
    void *p2 = malloc(18);
    void *p3 = malloc(15);

    free(p1);
    free(p3);

}

四、__libc_malloc 和 __libc_free

思路和hook的一样，因为malloc和free底层调用的也是__libc_malloc和__libc_free。

// gcc -o fun3 fun3.c
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <link.h>


void* converToELF(void *addr) {
    Dl_info info;
    struct link_map *link;
    dladdr1(addr, &info, (void **)&link, RTLD_DL_LINKMAP);
    // printf("%p\n", (void *)(size_t)addr - link->l_addr);
    
    return (void *)((size_t)addr - link->l_addr);
}



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; 
        enable_free_hook = 0;

        ptr = __libc_malloc(size);

        void *caller = __builtin_return_address(0);

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

        FILE *fp = fopen(buffer, "w");
        fprintf(fp, "[+] caller: %p, addr: %p, size: %ld\n", converToELF(caller), ptr, size);

        fflush(fp);
        fclose(fp);

        enable_malloc_hook = 1;
        enable_free_hook = 1;
    }
    else {
        ptr = __libc_malloc(size);
    }
    return ptr;
}

void free(void *ptr){

    if (enable_free_hook ){
        enable_free_hook = 0;
        enable_malloc_hook = 0;

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

        if (unlink(buffer) < 0){
            printf("double free: %p\n", ptr);
            return;
        }

        __libc_free(ptr);

        enable_malloc_hook = 1;
        enable_free_hook = 1;
    }
    else {

        __libc_free(ptr);
    }
}


int main(){

    void *p1 = malloc(5);
    void *p2 = malloc(18);
    void *p3 = malloc(15);

    free(p1);
    free(p3);

}

阅读全部

相关推荐

  2. 内存泄漏是什么？如何避免内存泄漏？

    2024-04-21 12:52:03       42 阅读

  3. 什么是内存泄漏？如何判断内存泄漏？

    2024-04-21 12:52:03       32 阅读

  4. 什么是内存泄漏？如何避免内存泄漏？

    2024-04-21 12:52:03       28 阅读

  5. 什么是内存泄漏？如何避免？

    2024-04-21 12:52:03       32 阅读

  10. 内存泄露？什么是ThreadLocal

    2024-04-21 12:52:03       48 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-04-21 12:52:03       94 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-04-21 12:52:03       100 阅读

  9. 在Django里面运行非项目文件

    2024-04-21 12:52:03       82 阅读

  19. Python语言-面向对象

    2024-04-21 12:52:03       91 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-04-21 12:52:03       85 阅读

热门阅读

  1. 浅谈-“指针”

    2024-04-21 12:52:03       32 阅读

  2. 2233: 【数学】因子游戏

    2024-04-21 12:52:03       36 阅读

  5. 【Redis(6)】Redis集群模式配置示例

    2024-04-21 12:52:03       39 阅读

  8. 设计模式｜迭代器模式（Iterator）

    2024-04-21 12:52:03       37 阅读

  16. 微信小程序手机授权报错：pad block corrupted

    2024-04-21 12:52:03       114 阅读

  21. flutter知识点--PlatformView

    2024-04-21 12:52:03       39 阅读

  22. 2024年Getx教程_Flutter+Getx系列实战教程介绍

    2024-04-21 12:52:03       39 阅读

  27. Oracle中排查谁把表数据删除更新——delete、drop、truncate

    2024-04-21 12:52:03       38 阅读

  28. SQL load direct path load index 无效的原因

    2024-04-21 12:52:03       44 阅读

  30. 【Vue】Vue中使一个div铺满全屏

    2024-04-21 12:52:03       40 阅读