Linux C memory Leak detection Tool Valgrind

Source: Internet
Author: User
Tags valgrind

Linux/C + +on common memory leak detection tools areValgrind, Rational purify. Valgrindfree. Valgrindcan be in +bit or -bitPowerpc/linuxwork on the kernel.
Valgrind The toolkit contains several tools, such asMemcheck,cachegrind,helgrind, Callgrind,Massif. Here are some of the tools that you'll work with:
Memcheck the tool mainly checks for the following program errors:
? use of uninitialized memory(use of uninitialised memory)
? using memory that has already been freed(reading/writing memory after it had been free'd)
? use more thanmallocAllocated Memory Space(reading/writing off the end of malloc'd blocks)
? illegal access to the stack(reading/writing inappropriate areas on the stack)
? is there a free space for the application ?(Memory leaks–where pointers to malloc'd blocks is lost forever)
?Malloc/free/new/deleteapplication and release memory matching(mismatched use of malloc/new/new [] vs Free/delete/delete [])
?srcand theDSTthe overlap(overlapping src and DST pointers in memcpy () and related functions)
Valgrind the use of statically allocated arrays is not checked.
Valgrind takes up more memory--up to twice times the normal usage of your program. If you useValgrindto detect a problem with a program that uses a lot of memory, it may take a long time to run the test
2.1. Download Installation
http://www.valgrind.org
installation
./configure;make;make Install
2.2. Compiling the program
The detected program is added –G-fno-inlineThe compile option retains debugging information.

2.3. Memory Leak Detection
$ valgrind--tool=memcheck--log-file=/home/trunk/valgrind_log_all--leak-check=full--error-limit=no-- Show-leak-kinds=all/opt/lim/bin/limserver

which --leak-check=full refers to a full check of memory leaks, --show-reachable=yes is where the memory leaks are displayed, --trace-children=yes is to follow the child process. When the program exits normally, valgrind will naturally output the information of memory leaks.

1. Memory leaks:

#include <stdio.h>void function () {int *p = (int*) malloc (10*sizeof (int)); P[10] = 0;}    int main () {function (); return 0;}

Related logs:

==20220== Memcheck, a memory error detector
==20220== Copyright (C) 2002-2010, and GNU GPL ' d, by Julian Seward et al.
==20220== Using Valgrind-3.6.1-debian and Libvex; Rerun with-h for copyright info
==20220== Command:./test
==20220== Parent pid:20160
==20220==
==20220== Invalid Write of size 4
==20220== at 0x80483ff:function (in/mnt/documents/training/valgrind/test)
==20220== by 0x8048411:main (in/mnt/documents/training/valgrind/test)
==20220== Address 0x41be050 is 0 bytes after a block of size alloc ' d
==20220== at 0x4028876:malloc (vg_replace_malloc.c:236)
==20220== by 0x80483f5:function (in/mnt/documents/training/valgrind/test)
==20220== by 0x8048411:main (in/mnt/documents/training/valgrind/test)
==20220==
==20220==
==20220== HEAP SUMMARY:
==20220== in with exit:40 bytes in 1 blocks
==20220== Total heap Usage:1 allocs, 0 frees, Bytes allocated
==20220==
==20220== LEAK SUMMARY:
==20220== definitely lost:40 bytes in 1 blocks
==20220== indirectly lost:0 bytes in 0 blocks
==20220== possibly lost:0 bytes in 0 blocks
==20220== still reachable:0 bytes in 0 blocks
==20220== suppressed:0 bytes in 0 blocks
==20220== rerun with--leak-check=full to see details of leaked memory
==20220==
==20220== for counts of detected and suppressed errors, rerun with:-V
==20220== ERROR summary:1 errors from 1 contexts (suppressed:11 from 6)

2. Using uninitialized memory

#include <stdio.h>int main () {int A;    if (a==1) {printf ("a==%d\n", a); } return 0;}

Log analysis:

==20345== Memcheck, a memory error detector
==20345== Copyright (C) 2002-2010, and GNU GPL ' d, by Julian Seward et al.
==20345== Using Valgrind-3.6.1-debian and Libvex; Rerun with-h for copyright info
==20345== Command:./test
==20345==
==20345== Conditional Jump or move depends on uninitialised value (s)
==20345== at 0x80483f2:main (in/mnt/documents/training/valgrind/test)
==20345==
==20345==
==20345== HEAP SUMMARY:
==20345== in with exit:0 bytes in 0 blocks
==20345== Total heap usage:0 allocs, 0 frees, 0 bytes allocated
==20345==
==20345== all heap blocks were freed--no leaks is possible
==20345==
==20345== for counts of detected and suppressed errors, rerun with:-V
==20345== use--track-origins=yes to see where uninitialised values come from
==20345== ERROR summary:1 errors from 1 contexts (suppressed:11 from 6)

You can use--track-origins=yes to get more information.

3. Memory read/write out of bounds

#include <stdio.h>int main () {int *a = (int*) malloc (5*sizeof (int));    A[5] = 1; return 0;}

==20368== Memcheck, a memory error detector
==20368== Copyright (C) 2002-2010, and GNU GPL ' d, by Julian Seward et al.
==20368== Using Valgrind-3.6.1-debian and Libvex; Rerun with-h for copyright info
==20368== Command:./test
==20368==
==20368== Invalid Write of size 4
==20368== at 0x8048404:main (in/mnt/documents/training/valgrind/test)
==20368== Address 0x41be03c is 0 bytes after a block of size alloc ' d
==20368== at 0x4028876:malloc (vg_replace_malloc.c:236)
==20368== by 0x80483f8:main (in/mnt/documents/training/valgrind/test)
==20368==
==20368==
==20368== HEAP SUMMARY:
==20368== in with exit:20 bytes in 1 blocks
==20368== Total heap Usage:1 allocs, 0 frees, Bytes allocated
==20368==
==20368== LEAK SUMMARY:
==20368== definitely lost:20 bytes in 1 blocks
==20368== indirectly lost:0 bytes in 0 blocks
==20368== possibly lost:0 bytes in 0 blocks
==20368== still reachable:0 bytes in 0 blocks
==20368== suppressed:0 bytes in 0 blocks
==20368== rerun with--leak-check=full to see details of leaked memory
==20368==
==20368== for counts of detected and suppressed errors, rerun with:-V
==20368== ERROR summary:1 errors from 1 contexts (suppressed:11 from 6)

4. Memory Request Release Management error

#include <stdio.h>int main () {int *a = new Int[5];    /*free (a); */delete A; return 0;}

==20387== Memcheck, a memory error detector
==20387== Copyright (C) 2002-2010, and GNU GPL ' d, by Julian Seward et al.
==20387== Using Valgrind-3.6.1-debian and Libvex; Rerun with-h for copyright info
==20387== Command:./test
==20387==
==20387== mismatched free ()/Delete/delete []
==20387== at 0x4027919:operator Delete (void*) (vg_replace_malloc.c:387)
==20387== by 0x8048498:main (in/mnt/documents/training/valgrind/test)
==20387== Address 0x42f2028 is 0 bytes inside a block of size alloc ' d
==20387== at 0x4027f65:operator new[] (unsigned int) (vg_replace_malloc.c:299)
==20387== by 0x8048488:main (in/mnt/documents/training/valgrind/test)
==20387==
==20387==
==20387== HEAP SUMMARY:
==20387== in with exit:0 bytes in 0 blocks
==20387== Total Heap Usage:1 Allocs, 1 frees, Bytes allocated
==20387==
==20387== all heap blocks were freed--no leaks is possible
==20387==
==20387== for counts of detected and suppressed errors, rerun with:-V
==20387== ERROR summary:1 errors from 1 contexts (suppressed:17 from 6)





Linux C memory Leak detection Tool Valgrind

Related Article

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.