美文网首页
Valgrind memcheck 用法

Valgrind memcheck 用法

作者: RonZheng2010 | 来源:发表于2019-02-21 09:08 被阅读0次

    Valgrind是一组调试(debugging)和剖析(profiling)工具的集合。memcheck是其中应用最广泛的一个,它检查内存有关的问题,包括诸如内存访问越界、内存泄露等。

    1. 使用步骤

    1.1 编译程序

    • -g:使用这个选项产生符号信息。这样Valgrind产生的报告中会显示的代码位置是源代码的位置,否则Valgrind只能猜函数名。
    • -fno-inline:不使用这个选项,Valgrind报告的调用栈可能让人迷惑。如果是编译debug版本,这个选项是默认的
    • -O1。使用这个选项在速度与准确性之间达到平衡。如果速度可容忍,最好使用-O0。
    • -Wall。使用这个选项时,gcc能解决一些memcheck不能检测到的问题。

    1.2 用Valgrind运行程序

    valgrind --log-file=valgrind.log --tool=memcheck --leak-check=full \
    --show-leak-kinds=all ./your_app arg1 arg2
    
    • --log-file 报告文件名。如果没有指定,输出到stderr。
    • --tool=memcheck 指定Valgrind使用的工具。Valgrind是一个工具集,包括Memcheck、Cachegrind、Callgrind等多个工具。memcheck是缺省项。
    • --leak-check 指定如何报告内存泄漏(memcheck能检查多种内存使用错误,内存泄漏是其中常见的一种),可选值有:
      • no 不报告
      • summary 显示简要信息,有多少个内存泄漏。summary是缺省值。
      • yes 和 full 显示每个泄漏的内存在哪里分配。
    • show-leak-kinds 指定显示内存泄漏的类型的组合。类型包括definite, indirect, possible,reachable。也可以指定all或none。缺省值是definite,possible。

    2. 错误类型

    2.1 illegal read 非法读 / illegal write 非法写

    如下代码分配了长度为1024的缓存buf,然后在buf+1020的位置写入一个8字节的uint64_t,并打印它。这个uint64_t已经超出buf的界限。

     10     char* buf = (char*) malloc (1024);
     11     uint64_t* bigNum = (uint64_t*)(buf + 1020);
     12     *bigNum = 0x12345678AABBCCDD;
     13     printf ("bigNum is %llu\n", *bigNum);
     14     free(buf);
    

    报告指出了非法写的位置main.cpp:12和非法读的位置main.cpp:13。

    ==17387== Invalid write of size 8
    ==17387==    at 0x400849: main (main.cpp:12)
    ==17387==  Address 0x51f343c is 1,020 bytes inside a block of size 1,024 alloc'd
    ==17387==    at 0x4C2B6CD: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==17387==    by 0x400828: main (main.cpp:10)
    ==17387== 
    ==17387== Invalid read of size 8
    ==17387==    at 0x400850: main (main.cpp:13)
    ==17387==  Address 0x51f343c is 1,020 bytes inside a block of size 1,024 alloc'd
    ==17387==    at 0x4C2B6CD: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==17387==    by 0x400828: main (main.cpp:10)
    

    2.2 Use of uninitialised values 使用未初始化的值

    如下代码打印了一个未初始化的值unused。

    10     int unused; 
    11     printf ("unused=%d", unused);
    

    报告指出了使用unused的位置main.cpp:11。

    ==17418== Use of uninitialised value of size 8
    ==17418==    at 0x4E7A39B: _itoa_word (_itoa.c:195)
    ==17418==    by 0x4E7C3E7: vfprintf (vfprintf.c:1596)
    ==17418==    by 0x4E85198: printf (printf.c:35)
    ==17418==    by 0x4007A2: main (main.cpp:11)
    

    2.3 Use of uninitialised or unaddressable values in system calls 系统调用时使用未初始化的值或不能访问的地址

    如下代码中arr没有初始化,就调用write()输出了。

    10     char* arr = (char*)malloc(10);
    11     write (1, arr, 10);
    

    报告给出了系统调用write的位置main.cpp:11。

    ==17450== Syscall param write(buf) points to uninitialised byte(s)
    ==17450==    at 0x4F1AF10: __write_nocancel (syscall-template.S:82)
    ==17450==    by 0x400802: main (main.cpp:11)
    ==17450==  Address 0x51f3040 is 0 bytes inside a block of size 10 alloc'd
    ==17450==    at 0x4C2B6CD: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==17450==    by 0x4007E8: main (main.cpp:10)
    

    2.4 illegal fress 非法释放

    如下代码中,释放的地址arr+2不是分配时得到的地址arr。

    10     char* arr = (char*)malloc(10);
    11     free (arr+2);
    

    报告中指出了释放时的位置main.cpp:11,也指出了分配时的位置main.cpp:10。

    ==3429== Invalid free() / delete / delete[] / realloc()
    ==3429==    at 0x4C2A82E: free (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3429==    by 0x4007FC: main (main.cpp:11)
    ==3429==  Address 0x51f3042 is 2 bytes inside a block of size 10 alloc'd
    ==3429==    at 0x4C2B6CD: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3429==    by 0x4007E8: main (main.cpp:10)
    

    2.5 When a heap block is freed with an inappropriate deallocation function 不匹配的释放

    如下代码中分配得到一个int数组d[],释放的时候却使用delete,而不是delete[]。

    10     int* d = new int[5];
    11     delete d;
    

    报告中指出了数组释放的位置main.cpp:11,也指出了分配的位置main.cpp:10。

    ==3498== Mismatched free() / delete / delete []
    ==3498==    at 0x4C2A4BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3498==    by 0x400828: main (main.cpp:11)
    ==3498==  Address 0x5a2ac80 is 0 bytes inside a block of size 20 alloc'd
    ==3498==    at 0x4C2AC27: operator new[](unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3498==    by 0x400818: main (main.cpp:10)
    

    2.6 Overlapping source and destination blocks 移动/复制缓存数据时,源与目标重叠

    如下代码中memcpy复制的源和目标重叠。

    10     char buf[256] = "";
    11     memcpy (buf+10, buf, 100);
    

    报告指出了复制的位置main.cpp:11.

    ==3530== Source and destination overlap in memcpy(0x7feffffea, 0x7feffffe0, 100)
    ==3530==    at 0x4C2CFA0: memcpy@@GLIBC_2.14 (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3530==    by 0x40087E: main (main.cpp:11)
    

    2.7 Fishy argument values 函数调用的参数可能不合法

    下面的代码中,使用了负值-10调用malloc。

    10     int sz = -10;
    11     int* arr2 = (int*)malloc (sz);
    12     free(arr2);
    

    报告只是警告malloc()的参数不合法,但没有指出位置。(就算不用Valgrind运行程序,这个错误应该也能马上发现吧?)

    ==3583== Warning: silly arg (-10) to malloc()
    

    2.8 Memory leak detection 内存泄露

    以下代码分配了100字节没有释放。

    10     int* arr = (int*)malloc (100);
    

    报告依次列出了每一个泄露的内存分配的位置(这里是main.cpp:10),最后还给出了所有关于泄露的统计总结(LEAK_SUMMARY部分)。

    ==3869== HEAP SUMMARY:
    ==3869==     in use at exit: 100 bytes in 1 blocks
    ==3869==   total heap usage: 1 allocs, 0 frees, 100 bytes allocated
    ==3869== 
    ==3869== 100 bytes in 1 blocks are definitely lost in loss record 1 of 1
    ==3869==    at 0x4C2B6CD: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3869==    by 0x400798: main (main.cpp:10)
    ==3869== 
    ==3869== LEAK SUMMARY:
    ==3869==    definitely lost: 100 bytes in 1 blocks
    ==3869==    indirectly lost: 0 bytes in 0 blocks
    ==3869==    possibly lost: 0 bytes in 0 blocks
    ==3869==    still reachable: 0 bytes in 0 blocks
    ==3869==    suppressed: 0 bytes in 0 blocks
    

    3. 关于内存泄露

    • memcheck跟踪所有malloc()/new()分配的堆块,所以它能在程序退出时知道哪些块还没有释放。
    • 这里把程序能访问到的指针集合叫做root-set。memcheck根据从root-set能不能到达某个块,判断这个块是不是泄露了(reachable还是lost)。
      • 到达块有两种方式:一是start-pointer,它指向块的开始地址;二是interior-pointer,它指向块的中间某个位置。
      • 有start-pointer引用的缓存被认为是reachable。
      • 有interior-pointer引用的缓存则不一定了。
        • 它可能是分配之后的指针故意向后移动的结果。这时程序使用缓存开始的几个字节保存特别信息,而真正的数据在后面某个位置。比如指向C++的std::string内部数组的指针、指向new[]分配的C++对象数组的指针、多重继承的情况等。这时缓存是reachable的。
        • 但它也可能只是偶然指向缓存。这时缓存就是lost的。
        • 所以interior-pointer引用的缓存是possible lost。

    根据从root-set到缓存是否需要跳转,memcheck 将分配的缓存的状态分为几种:

    • directly reachable: root-set中的指针指向缓存,不需跳转
    • indirectly reachable: root-set中的指针不直接指向缓存,需要跳转
    • directly lost:没有任何指针指向缓存
    • indirectly lost:有指针指向缓存,但从root-set中也无法到达这个指针

    下图列出了缓存的各种情况。其中RRR是root-set中的节点,AAA和BBB是缓存。

         Pointer chain            AAA Leak Case   BBB Leak Case
         -------------            -------------   -------------
    (1)  RRR ------------> BBB                    DR
    (2)  RRR ---> AAA ---> BBB    DR              IR
    (3)  RRR               BBB                    DL
    (4)  RRR      AAA ---> BBB    DL              IL
    (5)  RRR ------?-----> BBB                    (y)DR, (n)DL
    (6)  RRR ---> AAA -?-> BBB    DR              (y)IR, (n)DL
    (7)  RRR -?-> AAA ---> BBB    (y)DR, (n)DL    (y)IR, (n)IL
    (8)  RRR -?-> AAA -?-> BBB    (y)DR, (n)DL    (y,y)IR, (n,y)IL, (_,n)DL
    (9)  RRR      AAA -?-> BBB    DL              (y)IL, (n)DL
    
    Pointer chain legend:
    - RRR: a root set node or DR block
    - AAA, BBB: heap blocks
    - --->: a start-pointer
    - -?->: an interior-pointer
    
    Leak Case legend:
    - DR: Directly reachable
    - IR: Indirectly reachable
    - DL: Directly lost
    - IL: Indirectly lost
    - (y)XY: it's XY if the interior-pointer is a real pointer
    - (n)XY: it's XY if the interior-pointer is not a real pointer
    - (_)XY: it's XY in either case
    

    下面是memcheck中LEAK SUMMARY部分中的项目:

    • Still reachable: 上图中(1)和(2)的情况,从root-set中通过start-pointer直接到达或跳转到达缓存。这一项是确定不是lost的,用户无需关系。
    • Definitely lost:(3)的情况。没有任何指针指向缓存。这一项确定是lost的,用户需解决。
    • Indirectly lost:(4)和(9)中BBB的情况。有start-pointer或interior-pointer指向缓存,但从root-set不能到达这些指针。这一项可以推迟解决,因为Indirectly lost一定与definitely lost对应,definitely lost解决了,indirectly lost也就变成reachable或者possible lost了。
    • Possibly lost: 有interior-pointer指向缓存,从root-set能到达这些指针。因为memcheck不能判断interior-pointer是否lost,所以需要用户排除。
      所以实际上只要关心definitely lost和possible lost就可以了。这也是memcheck的缺省值:
    --show-leak-kinds=definite,possible
    
    • suppressed: 用户在suppressed file中指定不要报告的项目,不管这个缓存是前面的哪种情况。

    4. memcheck的实现细节

    4.1 V (Valid-value) bit

    可以简单地认为memcheck实现了一个与真实CPU对等的CPU,这个CPU对于真实CPU上处理和存储的每一个bit,都有一个与这个bit关联的额外的bit。后一个bit叫做V bit,表示前一个bit中是否包含合法值。

    进程的整个地址空间对应一个bitmap,如果CPU加载一个word大小的数据,它同时从bitmap中加载对应的32个V bit。如果U将这个word数据的全部或部分写到一个不同的地址,则同时将那个地址对应的32个V bit写回bitmap。

    即使是CPU内部的bit也有一个相应的V bit。所有的CPU寄存器,不管是什么类型,都有各自的V bit。memcheck在bitmap大量使用压缩技术,以便紧凑地表达其中的V bit。

    4.2 A (Valid-address) bit

    内存中的每个byte都有一个valid-address(A) bit与它对应。与V bit不同,CPU中的byte没有A bit。A bit表示程序是否能合法读写相应的位置,A bit 不关心数据,V bit才关心。

    程序读写内存时,memcheck检查与该位置相应的A bit,如果 A bit无效,则报告错误。

    A bit设置的时机如下:

    • 程序启动时,所有全局数据的范围A bit设置有效
    • 调用malloc/new时,分配大小的区域,A bit设置有效,释放后立即设置无效
    • 栈指针SP移动时,A bit相应设置。因为栈向下增长,所以SP向下移动,A bit设置有效,SP向上移动,A bit设置无效。
    • 某些系统调用时,A bit相应设置。比如mmap()将文件映射到内存空间,所以A bit设置有效。

    相关链接

    GDB 常用法
    GDB 调试Coredump问题
    嵌入式开发中GDB调试Coredump问题
    嵌入式开发中GDB串口远程调试
    用backtrace()调试coredump问题
    Valgrind memcheck 用法
    Address Sanitizer 用法

    参考资料

    Memcheck: a memory error detector
    http://valgrind.org/docs/manual/mc-manual.html#mc-manual.badfrees

    valgrind 工具介绍和简单的使用
    https://www.cnblogs.com/AndyStudy/p/6409287.html

    关于gcc 2.96
    https://www.jianshu.com/p/a317e8208f8e

    相关文章

      网友评论

          本文标题:Valgrind memcheck 用法

          本文链接:https://www.haomeiwen.com/subject/dqecyqtx.html