Linux C内存泄露检测工具

最新推荐文章于 2024-09-27 15:20:44 发布

yuyin86

最新推荐文章于 2024-09-27 15:20:44 发布

阅读量1.2k

点赞数

分类专栏： linux学习调试gdb 文章标签： linux 工具 c output function file

linux学习同时被 2 个专栏收录

636 篇文章 4 订阅

订阅专栏

调试gdb

147 篇文章 1 订阅

订阅专栏

内存泄漏检查方法(for Linux)
如果你更想读原始文档, 请参考glibc info的"Allocation Debugging"一章 (执行info libc);
glibc提供了一个检查内存泄漏的方法, 前提是你的程序使用glibc的标准函数分配内存(如malloc, alloc...):
1. 在需要内存泄漏检查的代码的开始调用void mtrace(void) (在mcheck.h中有声明). mtrace为malloc等函数安装hook, 用于记录内存分配信息.在需要内存泄漏检查的代码的结束调用void muntrace(void).
注意: 一般情况下不要调用muntrace, 而让程序自然结束. 因为可能有些释放内存的的代码要到muntrace之后才运行.
2. 用debug模式编译被检查代码(-g或-ggdb)
3. 设置环境变量MALLOC_TRACE为一文件名, 这一文件将存有内存分配信息.
4. 运行被检查程序, 直至结束或muntrace被调用.
5. 用mtrace命令解析内存分配Log文件($MALLOC_TRACE)
(mtrace foo $MALLOC_TRACE, where foo is the executible name)
如果有内存泄漏, mtrace会输出分配泄漏内存的代码位置,以及分配数量.

其他东西
1. 可以将mtrace, muntrace放入信号处理函数(USR1, USR2), 以动态地进行内存泄漏检查控制.
2. mtrace是个perl代码, 如果你对符号地址与代码文本的转换感兴趣, 可以读一下.
3. again, 尽量不要用muntrace()

For C++ Leak:
检查内存泄漏的方法除glibc提供外；
还可以试试一些专用的程序；如：
ccmalloc
http://www.inf.ethz.ch/personal/biere/projects/ccmalloc/ccmalloc-english.html
mpatrol
http://www.cbmamiga.demon.co.uk/mpatrol/
这俩个工具的功能相当不错，能对程序进行相当全面的检查

01 #include <stdlib.h>

02 #include <mcheck.h>
03
04 void func(void)
05 {
06     int* ptr = malloc(10 * sizeof(int));
07     //free(ptr);
08 }
09
10 int main(void)
11 {
12     setenv("MALLOC_TRACE", "output_file_name", 1);
13     mtrace();
14     func();
15     return 0;
16 }

# gcc test.c -o test -g
# ./test
# more output_file_name
= Start
@ ./test:[0x80483e6] + 0x804a470 0x28
@ /lib/tls/i686/cmov/libc.so.6:(clearenv+0x7c)[0xb7e449ac] - 0x804a008
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x47)[0xb7eec6d7] - 0x804a0c0
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x4f)[0xb7eec6df] - 0x804a0e8

# mtrace output_file_name
- 0x0804a008 Free 3 was never alloc'd 0xb7e449ac
- 0x0804a0c0 Free 4 was never alloc'd 0xb7eec6d7
- 0x0804a0e8 Free 5 was never alloc'd 0xb7eec6df

Memory not freed:
-----------------
0 Address     Size     Caller
0x0804a470     0x28 at 0x80483e6

01 #include <stdlib.h>
02 #include <mcheck.h>
03
04 void func(void)
05 {
06     int* ptr = malloc(10 * sizeof(int));
07     free(ptr);
08 }
09
10 int main(void)
11 {
12     setenv("MALLOC_TRACE", "output_file_name", 1);
13     mtrace();
14     func();
15     return 0;
16 }

# more output_file_name
= Start
@ ./test:[0x8048426] + 0x804a470 0x28
@ ./test:[0x8048434] - 0x804a470
@ /lib/tls/i686/cmov/libc.so.6:(clearenv+0x7c)[0xb7e149ac] - 0x804a008
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x47)[0xb7ebc6d7] - 0x804a0c0
@ /lib/tls/i686/cmov/libc.so.6:(tdestroy+0x4f)[0xb7ebc6df] - 0x804a0e8

0x8048426 分配内存空间的指令地址
0x804a470 malloc分配的内存空间己地址
+         表示分配内存
-         表示释放内存

# mtrace output_file_name
- 0x0804a008 Free 4 was never alloc'd 0xb7e149ac
- 0x0804a0c0 Free 5 was never alloc'd 0xb7ebc6d7
- 0x0804a0e8 Free 6 was never alloc'd 0xb7ebc6df
No memory leaks.

--------------------------------------------
#include <stdlib.h>
#include <mcheck.h>

void func(void)
{
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
}

int main(void)
{
    setenv("MALLOC_TRACE", "output_file_name", 1);
    mtrace();
    func();
   while (1)
   {
       muntrace();
   }
    return 0;
}

$ ./a.out &
$ more output_file_name
= Start
@ ./a.out:[0x8048426] + 0x804a468 0x28

= End

--------------------------------------------
#include <stdlib.h>
#include <mcheck.h>

void func(void)
{
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
}

int main(void)
{
    setenv("MALLOC_TRACE", "output_file_name", 1);
    mtrace();
    func();
   while (1)
   {
       sleep (1);
       func ();
       muntrace();
   }
    return 0;
}

= Start
@ ./a.out:[0x8048456] + 0x804a468 0x28
@ ./a.out:[0x8048456] + 0x804a498 0x28
= End
虽然while中反复调用func()但是此处只检测到两次(while外一次，while内一次)

---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>

void func(void)
{
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
}

int main(void)
{
    setenv("MALLOC_TRACE", "output_file_name", 1);
    mtrace();
    func();
    while (1)
    {
        sleep (1);
        func ();
        //muntrace();
    }
    return 0;
}

这种使用方式，进程中守护任务，所以output_file_name不会马上有内存，需要等一会儿

函数各自生成自己的内存泄露检测报告，这样比较麻烦
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>

void func(void)
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
   muntrace();
}

void test()
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
   muntrace();
}

void task()
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    int* ptr = malloc(10 * sizeof(int));
    //free(ptr);
   while (1)
   {
       usleep (10);
       /* 如果不在这里调用muntrace，将不能生成检测报告 */
       muntrace();
   }
}

int main(void)
{

    //mtrace();
    func();
   test();
   task();

    return 0;
}

普通函数统一报告，有无限循环的函数单独生成报告
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>

void func(void)
{
    int* ptr = malloc(10 * sizeof(int));

}

void test()
{
    int* ptr = malloc(10 * sizeof(int));
}

void task()
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    int* ptr = malloc(10 * sizeof(int));
   while (1)
   {
       usleep (10);
       /* 如果不在这里调用muntrace，将不能生成检测报告 */
       muntrace();
   }
}

int main(void)
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    func();
   test();
   task();

    return 0;
}

创建线程前检测一次，并结束检测；线程自行检测；线程创建后不能再进行检测，
如果需要检测，则不能调用muntrace()，但是检测还是会失效
---------------------------------------------
#include <stdlib.h>
#include <mcheck.h>
#include <stdio.h>
#include <pthread.h>

void func(void)
{
    int* ptr = malloc(10 * sizeof(int));

}

void test()
{
    int* ptr = malloc(100 * sizeof(int));
}

void task()
{
   char buff[128];
   snprintf (buff, sizeof (buff), "%s", __FUNCTION__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    int* ptr = malloc(1000 * sizeof(int));
   while (1)
   {
       usleep (10);
       /* 如果不在这里调用muntrace，将不能生成检测报告 */
       muntrace();
   }
}

int main(void)
{
   pthread_t id;
   int i, ret;

   char buff[128];
   snprintf (buff, sizeof (buff), "%s%d", __FUNCTION__, __LINE__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
    func();
   test();
   muntrace();

   ret = pthread_create(&id, NULL, (void *)task, NULL);
   if (ret != 0)
   {
       printf("Create pthread error!\n");
       exit(1);
   }

#if 0 /* 创建线程(线程自行负责检测)后，就不能再检测了，否则会有段错误 */
   snprintf (buff, sizeof (buff), "%s%d", __FUNCTION__, __LINE__);
    setenv("MALLOC_TRACE", buff, 1);
   mtrace();
   test();
   //muntrace();
#endif

   sleep(1);
   //while (1) {}
    return 0;
}