From 0c14cd279ad4e1ec3588e1360a510f3bdf7925f5 Mon Sep 17 00:00:00 2001 From: FreeArtMan Date: Thu, 18 Aug 2022 10:34:32 +0100 Subject: valgrind --- md/notes/undefined_c/titles.md | 140 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) diff --git a/md/notes/undefined_c/titles.md b/md/notes/undefined_c/titles.md index 6053291..ec8f0b5 100644 --- a/md/notes/undefined_c/titles.md +++ b/md/notes/undefined_c/titles.md @@ -1069,6 +1069,146 @@ void _start() { http://main.lv/writeup/making_c_executables_smaller.md ### Memory leaks + +Memory leaks is cruitial part of C language. Default case when they are detected are +when allocated memory wasn free'd after use. If amount of this type of memory increasing then +its can eventually fill whole memory and system will be unresponsive. Here is simple example +how memory leak created and how to detect it. + +```c +#include + +int main() { + + char *ptr = malloc(12); + + return 0; +} +``` + +The best way to detect it to use valgrind. + +``` +$ valgrind ./malloc + +==778== HEAP SUMMARY: +==778== in use at exit: 12 bytes in 1 blocks +==778== total heap usage: 2 allocs, 1 frees, 1,036 bytes allocated +``` + +There is seen 2 allocs and 1 free. But we see that 12bytes after exit. So our created leak is detected. +More complex example. So now we created leaking function and we called it 5 times. But in larger code +base it would be nice to see location of leaks. + +```c +#include + +int* mem_alloc(int sz) { + int *ret=NULL; + + if (sz < 0) { + return NULL; + } + + ret = malloc(sz*sizeof(int)); + + if (sz>10) { + return NULL; + } + + return ret; + +} + +int main() { + + mem_alloc(0); + + free(mem_alloc(1)); + + mem_alloc(100); + + free(mem_alloc(2)); + + mem_alloc(10); + + return 0; +} +``` + +There is 3 blocks that leaks, and we see where its comming from there is possible to guess but it would better +to have position of where leak located. + +``` +valgrind --leak-check=full --track-origins=yes --log-file=log.txt ./memleak2 + +==4974== HEAP SUMMARY: +==4974== in use at exit: 440 bytes in 3 blocks +==4974== total heap usage: 5 allocs, 2 frees, 452 bytes allocated +==4974== +==4974== 0 bytes in 1 blocks are definitely lost in loss record 1 of 3 +==4974== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==4974== by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2) +==4974== by 0x10919E: main (in /home/fam/prog/c/undefined_c/memleak2) +==4974== +==4974== 40 bytes in 1 blocks are definitely lost in loss record 2 of 3 +==4974== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==4974== by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2) +==4974== by 0x1091D6: main (in /home/fam/prog/c/undefined_c/memleak2) +==4974== +==4974== 400 bytes in 1 blocks are definitely lost in loss record 3 of 3 +==4974== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==4974== by 0x109179: mem_alloc (in /home/fam/prog/c/undefined_c/memleak2) +==4974== by 0x1091BA: main (in /home/fam/prog/c/undefined_c/memleak2) +==4974== +==4974== LEAK SUMMARY: +==4974== definitely lost: 440 bytes in 3 blocks +==4974== indirectly lost: 0 bytes in 0 blocks +==4974== possibly lost: 0 bytes in 0 blocks +==4974== still reachable: 0 bytes in 0 blocks +==4974== suppressed: 0 bytes in 0 blocks +``` + +Add compilation option __g3__ + +``` +gcc -g3 memleak2.c -o memleak2 +``` + +Now it shows source lines and trace from where the leaking code where called. Thats looks better now. + +``` +valgrind --leak-check=full --track-origins=yes --log-file=log.txt ./memleak2 + +==5073== HEAP SUMMARY: +==5073== in use at exit: 440 bytes in 3 blocks +==5073== total heap usage: 5 allocs, 2 frees, 452 bytes allocated +==5073== +==5073== 0 bytes in 1 blocks are definitely lost in loss record 1 of 3 +==5073== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==5073== by 0x109179: mem_alloc (memleak2.c:10) +==5073== by 0x10919E: main (memleak2.c:22) +==5073== +==5073== 40 bytes in 1 blocks are definitely lost in loss record 2 of 3 +==5073== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==5073== by 0x109179: mem_alloc (memleak2.c:10) +==5073== by 0x1091D6: main (memleak2.c:30) +==5073== +==5073== 400 bytes in 1 blocks are definitely lost in loss record 3 of 3 +==5073== at 0x4841888: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) +==5073== by 0x109179: mem_alloc (memleak2.c:10) +==5073== by 0x1091BA: main (memleak2.c:26) +==5073== +==5073== LEAK SUMMARY: +==5073== definitely lost: 440 bytes in 3 blocks +==5073== indirectly lost: 0 bytes in 0 blocks +==5073== possibly lost: 0 bytes in 0 blocks +==5073== still reachable: 0 bytes in 0 blocks +==5073== suppressed: 0 bytes in 0 blocks +==5073== +``` + + ### Code coverage ### Profiling ### Canary -- cgit v1.2.3