linux服務器開發—手寫內存泄漏檢測組件

一口Linux 2022-04-09 13:22

KDES 2026上海峰會：定義下一代工程仿真 4周搞定BLE/Wi?Fi/NFC，從選型到首例工程

擊上方“一口Linux”，選擇“置頂/星標公眾號”

干貨福利，第一時間送達！

內存泄漏原因

內存泄漏在C/C++這種不帶GC(Garbage Collection)的語言里，是一個經常發生的問題。因為沒有GC，所以分配的內存需要程序員自己調用釋放。內存泄漏的根本原因是程序對于在申請的內存沒有進行釋放。

{
void *p1 = malloc(10);
void *p2 = malloc(20);

free(p1);
}

上面的代碼段，申請了兩塊內存p1，p2，只釋放了p1，沒有釋放p2，產生了內存泄漏。

內存泄漏會產生哪些后果？

隨著程序運行時間越來越久，內存有分配沒有釋放，會使得進程堆中的內存會越來越少，直到耗盡。會造成后面的運行時代碼不能成功分配內存。

內存泄漏如何解決？

方案一引入gc，從語言層面解決內存泄漏；

方案二當發生內存泄漏的時候，能夠精準的定位代碼那個文件、那個函數、哪一行所引起的。

我們實現的是方案二，核心需求有兩個。

需求1：能夠檢測出內存泄漏

需求2：能夠指出是由代碼的哪個文件、哪個函數、哪一行引起的內存泄漏

內存泄漏檢測如何實現？

內存泄漏檢測實現的核心思想就是對系統的malloc/free進行hook，用我們自己的malloc/free代替系統調用，將free的地址和malloc的地址進行匹配，查看最后又哪些malloc沒有進行free，并將沒有free的malloc操作的代碼段地址進行記錄，通過代碼段定位所在的文件、函數、代碼行。

方案一

采用__libc_malloc, libc_free與__builtin_return_address。它們是gcc提供的函數。

__libc_malloc, libc_free用來代替malloc/free。可以用來實現hook。需要注意的是，我們實現的malloc/free函數，內部會有一些函數如printf，fopen，需要防止它們會嵌套調用malloc/free。

__builtin_return_address，能夠返回調用所在函數的代碼段的地址。能夠定位內存泄漏的具體位置。

malloc的時候，創建一個文件，文件名使用申請內存的地址，并記錄申請該內存的代碼段的地址；free的時候，刪除對應的文件。

#include 
#include 
#include 
 
int enable_malloc_hook = 1;
extern void *__libc_malloc(size_t size);
 
int enable_free_hook = 1;
extern void *__libc_free(void *p);
 
void *malloc(size_t size) {
 
    if (enable_malloc_hook) {
        enable_malloc_hook = 0;
 
        void *p = __libc_malloc(size);
 
        void *caller = __builtin_return_address(0);
 
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);
 
        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+%p]malloc --> addr:%p size:%lu\n", caller, p, size);
        fflush(fp);
 
        enable_malloc_hook = 1;
        return p;
    } else {
 
        return __libc_malloc(size);
 
    }
    return NULL;
}
 
void free(void *p) {
 
    if (enable_free_hook) {
        enable_free_hook = 0;
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);
 
        if (unlink(buff) < 0) {
            printf("double free: %p\n", p);
        }
 
        __libc_free(p);
 
 
        enable_free_hook = 1;
    } else {
        __libc_free(p);
    }
 
}
 
// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {
 
 
    void *p1 = malloc(10);
    void *p2 = malloc(20);
 
    free(p1);
 
    void *p3 = malloc(30);
    void *p4 = malloc(40);
 
    free(p2);
    free(p4);
 
    return 0;
}

方案二

使用宏定義, 開啟宏定義使用我們的版本，不開啟就使用系統的。可以方便debug。

內存泄漏檢測使用malloc_hook/free_hook, 定位內存泄漏位置，使用__FILE__, __LINE__.

#define malloc(size) malloc_hook(size, __FILE__, __LINE__)

#define free(p) free_hook(p, __FILE__, __LINE__)

可以使用fclose，沒有double free的問題了

#include 
#include 
#include 
 
void *malloc_hook(size_t size, const char *file, int line) {
 
    void *p = malloc(size);
 
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);
 
    FILE *fp = fopen(buff, "w");
    fprintf(fp, "[+%s:%d]malloc --> addr:%p size:%lu\n", file, line, p, size);
    fflush(fp);
 
    fclose(fp);
 
    return p;
 
}
 
void free_hook(void *p,  const char *file, int line) {
 
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);
 
    if (unlink(buff) < 0) {
        printf("double free: %p\n", p);
        return;
    }
 
    free(p);
 
}
 
#define malloc(size)   malloc_hook(size, __FILE__, __LINE__)
 
#define free(p)    free_hook(p, __FILE__, __LINE__)
 
 
// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {
 
 
    void *p1 = malloc(10);
    void *p2 = malloc(20);
 
    free(p1);
 
    void *p3 = malloc(30);   // memory leak
    void *p4 = malloc(40);
 
    free(p2);
    free(p4);
    free(p4); // double free
 
    return 0;
 
}

檢測出兩個問題，一次內存泄漏 p3，一次double free p4。結果OK。

方案三

使用malloc.h中提供的hook: __malloc_hook, __free_hook.

這兩個hook，默認是malloc，free。

參考mtrace的做法，通過改變這兩個值來進行檢測。

#include 
#include 
#include 
#include 
 
typedef void *(*malloc_hoot_t)(size_t size, const void *caller);
malloc_hoot_t malloc_f;
 
typedef void (*free_hook_t)(void *p, const void *caller);
free_hook_t free_f;
 
void mem_trace(void);
void mem_untrace(void);
 
void *malloc_hook_f(size_t size, const void *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]malloc --> addr:%p size:%lu\n", caller, ptr, size);
    fflush(fp);
 
    fclose(fp);
    
    mem_trace();
    return ptr;
 
}
 
void free_hook_f(void *p, const void *caller) {
    mem_untrace();
    // printf("-%p: addr[%p]\n", caller, p);
 
    char buff[128] = {0};
    sprintf(buff, "./mem/%p.mem", p);
 
    if (unlink(buff) < 0) {
        printf("double free: %p\n", p);
    }
    
    free(p);
    mem_trace();
 
}
 
void mem_trace(void) {
 
    malloc_f = __malloc_hook;
    free_f = __free_hook;
 
    __malloc_hook = malloc_hook_f;
    __free_hook = free_hook_f;
}
 
void mem_untrace(void) {
 
    __malloc_hook = malloc_f;
    __free_hook = free_f;
 
}
 
 
// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {
 
    mem_trace();
    void *p1 = malloc(10);
    void *p2 = malloc(20);
 
    free(p1);
 
    void *p3 = malloc(30);
    void *p4 = malloc(40);
 
    free(p2);
    free(p4);
    mem_untrace();
 
    return 0;
 
}

方案四

使用mtrace

#include 
#include 
#include 
#include 
#include 
 
// gcc -o memleak_0 memleak_0.c -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {
 
// export MALLOC_TRACE=./test.log
    mtrace();
    void *p1 = malloc(10);
    void *p2 = malloc(20);
 
    free(p1);
 
    void *p3 = malloc(30);
    void *p4 = malloc(40);
 
    free(p2);
    free(p4);
    muntrace();
 
#endif
    return 0;
 
}

方案五

使用dlsym對malloc，free進行hook。

#define _GNU_SOURCE
#include 
 
#include 
#include 
#include 
 
typedef void *(*malloc_t)(size_t size);
malloc_t malloc_f;
 
typedef void (*free_t)(void *p);
free_t free_f;
 
 
int enable_malloc_hook = 1;
 
int enable_free_hook = 1;
 
void *malloc(size_t size) {
 
    if (enable_malloc_hook) {
        enable_malloc_hook = 0;
 
        void *p = malloc_f(size);
 
        void *caller = __builtin_return_address(0);
 
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);
 
        FILE *fp = fopen(buff, "w");
        fprintf(fp, "[+%p]malloc --> addr:%p size:%lu\n", caller, p, size);
        fflush(fp);
 
        enable_malloc_hook = 1;
        return p;
    } else {
 
        return malloc_f(size);
 
    }
    return NULL;
}
 
void free(void *p) {
 
    if (enable_free_hook) {
        enable_free_hook = 0;
        char buff[128] = {0};
        sprintf(buff, "./mem/%p.mem", p);
 
        if (unlink(buff) < 0) {
            printf("double free: %p\n", p);
        }
 
        free_f(p);
 
 
        enable_free_hook = 1;
    } else {
        free_f(p);
    }
 
}
 
static int init_hook() {
 
    malloc_f = dlsym(RTLD_NEXT, "malloc");
 
    free_f = dlsym(RTLD_NEXT, "free");
 
}
 
// gcc -o memleak_0 memleak_0.c -ldl -g
// addr2line -f -e  memleak_0  -a 0x4006d8
int main() {
 
    init_hook();
 
    void *p1 = malloc(10);
    void *p2 = malloc(20);
 
    free(p1);
 
    void *p3 = malloc(30);
    void *p4 = malloc(40);
 
    free(p2);
    free(p4);
 
    return 0;
 
}

共享內存

mmap方法1

匿名mmap

#include 
#include 
#include 
 
 
 
void *shm_mmap_alloc(int size) {
 
    void *addr = mmap(NULL, size, PROT_READ|PROT_WRITE, 
        MAP_ANON | MAP_SHARED, -1, 0);
    if (addr == MAP_FAILED) {
        return NULL;
    }
 
    return addr;
 
}
 
int shm_mmap_free(void *addr, int size) {
 
    return munmap(addr, size);
 
}
 
 
int main() {
 
    char *addr = (char *)shm_mmap_alloc(1024);
 
    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;
 
        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '\0';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %s\n", addr);
            sleep(1);
        }
    }
 
    shm_mmap_free(addr, 1024);
 
}

mmap方法2

/dev/zero

#include 
#include 
#include 
 
#include 
#include 
#include 
 
 
void *shm_mmap_alloc(int size) {
    int fd = open("/dev/zero", O_RDWR);
 
    void *addr = mmap(NULL, size, PROT_READ|PROT_WRITE, 
        MAP_SHARED, fd, 0);
    close(fd);
 
    if (addr == MAP_FAILED) {
        return NULL;
    }
 
    return addr;
 
}
 
int shm_mmap_free(void *addr, int size) {
 
    return munmap(addr, size);
 
}
 
 
int main() {
 
    char *addr = (char *)shm_mmap_alloc(1024);
 
    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;
 
        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '\0';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %s\n", addr);
            sleep(1);
        }
    }
 
    shm_mmap_free(addr, 1024);
 
}

shmget方法

#include 
#include 
#include 
 
#include 
#include 
#include 
 
#include 
#include 
 
 
void *shm_alloc(int size) {
  
    int segment_id = shmget(IPC_PRIVATE, size,
                        IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);
    char *addr = (char *)shmat(segment_id, NULL, 0);
 
    return addr;
 
}
 
int shm_free(void *addr) {
 
    return shmdt(addr);
 
}
 
 
int main() {
 
    char *addr = (char *)shm_alloc(1024);
 
    pid_t pid = fork();
    if (pid == 0) {
        // child
        int i = 0;
 
        while(i < 26) {
            addr[i] = 'a' + i++;
            addr[i] = '\0';
            sleep(1);
        }
    } else if (pid > 0) {
        int i = 0;
        while (i++ < 26) {
            printf("parent: %s\n", addr);
            sleep(1);
        }
    }
 
    shm_free(addr);
 
}

end

一口Linux?

關注，回復【1024】海量Linux資料贈送

精彩文章合集

文章推薦

?【專輯】ARM

?【專輯】粉絲問答

?【專輯】所有原創

?【專輯】linux入門

?【專輯】計算機網絡

?【專輯】Linux驅動

?【干貨】嵌入式驅動工程師學習路線

?【干貨】Linux嵌入式所有知識點-思維導圖

點擊“閱讀原文”查看更多分享，歡迎點分享、收藏、點贊、在看

登錄閱讀全文



免責聲明：該內容由專欄作者授權發布或作者轉載，目的在于傳遞更多信息，并不代表本網贊同其觀點，本站亦不保證或承諾內容真實性等。若內容或圖片侵犯您的權益，請及時聯系本站刪除。侵權投訴聯系：? nick.zong@aspencore.com！

一口Linux 寫點代碼,寫點人生!

進入專欄

評論

一口Linux 寫點代碼,寫點人生!

文章：1650篇粉絲：129人

 私信