1: #!/usr/bin/env perl
2: #***************************************************************************
3: # _ _ ____ _
4: # Project ___| | | | _ \| |
5: # / __| | | | |_) | |
6: # | (__| |_| | _ <| |___
7: # \___|\___/|_| \_\_____|
8: #
9: # Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
10: #
11: # This software is licensed as described in the file COPYING, which
12: # you should have received as part of this distribution. The terms
13: # are also available at https://curl.haxx.se/docs/copyright.html.
14: #
15: # You may opt to use, copy, modify, merge, publish, distribute and/or sell
16: # copies of the Software, and permit persons to whom the Software is
17: # furnished to do so, under the terms of the COPYING file.
18: #
19: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20: # KIND, either express or implied.
21: #
22: ###########################################################################
23: #
24: # Example input:
25: #
26: # MEM mprintf.c:1094 malloc(32) = e5718
27: # MEM mprintf.c:1103 realloc(e5718, 64) = e6118
28: # MEM sendf.c:232 free(f6520)
29:
30: my $mallocs=0;
31: my $callocs=0;
32: my $reallocs=0;
33: my $strdups=0;
34: my $wcsdups=0;
35: my $showlimit;
36: my $sends=0;
37: my $recvs=0;
38: my $sockets=0;
39:
40: while(1) {
41: if($ARGV[0] eq "-v") {
42: $verbose=1;
43: shift @ARGV;
44: }
45: elsif($ARGV[0] eq "-t") {
46: $trace=1;
47: shift @ARGV;
48: }
49: elsif($ARGV[0] eq "-l") {
50: # only show what alloc that caused a memlimit failure
51: $showlimit=1;
52: shift @ARGV;
53: }
54: else {
55: last;
56: }
57: }
58:
59: my $maxmem;
60:
61: sub newtotal {
62: my ($newtot)=@_;
63: # count a max here
64:
65: if($newtot > $maxmem) {
66: $maxmem= $newtot;
67: }
68: }
69:
70: my $file = $ARGV[0];
71:
72: if(! -f $file) {
73: print "Usage: memanalyze.pl [options] <dump file>\n",
74: "Options:\n",
75: " -l memlimit failure displayed\n",
76: " -v Verbose\n",
77: " -t Trace\n";
78: exit;
79: }
80:
81: open(FILE, "<$file");
82:
83: if($showlimit) {
84: while(<FILE>) {
85: if(/^LIMIT.*memlimit$/) {
86: print $_;
87: last;
88: }
89: }
90: close(FILE);
91: exit;
92: }
93:
94:
95: my $lnum=0;
96: while(<FILE>) {
97: chomp $_;
98: $line = $_;
99: $lnum++;
100: if($line =~ /^LIMIT ([^ ]*):(\d*) (.*)/) {
101: # new memory limit test prefix
102: my $i = $3;
103: my ($source, $linenum) = ($1, $2);
104: if($trace && ($i =~ /([^ ]*) reached memlimit/)) {
105: print "LIMIT: $1 returned error at $source:$linenum\n";
106: }
107: }
108: elsif($line =~ /^MEM ([^ ]*):(\d*) (.*)/) {
109: # generic match for the filename+linenumber
110: $source = $1;
111: $linenum = $2;
112: $function = $3;
113:
114: if($function =~ /free\((\(nil\)|0x([0-9a-f]*))/) {
115: $addr = $2;
116: if($1 eq "(nil)") {
117: ; # do nothing when free(NULL)
118: }
119: elsif(!exists $sizeataddr{$addr}) {
120: print "FREE ERROR: No memory allocated: $line\n";
121: }
122: elsif(-1 == $sizeataddr{$addr}) {
123: print "FREE ERROR: Memory freed twice: $line\n";
124: print "FREE ERROR: Previously freed at: ".$getmem{$addr}."\n";
125: }
126: else {
127: $totalmem -= $sizeataddr{$addr};
128: if($trace) {
129: print "FREE: malloc at ".$getmem{$addr}." is freed again at $source:$linenum\n";
130: printf("FREE: %d bytes freed, left allocated: $totalmem bytes\n", $sizeataddr{$addr});
131: }
132:
133: newtotal($totalmem);
134: $frees++;
135:
136: $sizeataddr{$addr}=-1; # set -1 to mark as freed
137: $getmem{$addr}="$source:$linenum";
138:
139: }
140: }
141: elsif($function =~ /malloc\((\d*)\) = 0x([0-9a-f]*)/) {
142: $size = $1;
143: $addr = $2;
144:
145: if($sizeataddr{$addr}>0) {
146: # this means weeeeeirdo
147: print "Mixed debug compile ($source:$linenum at line $lnum), rebuild curl now\n";
148: print "We think $sizeataddr{$addr} bytes are already allocated at that memory address: $addr!\n";
149: }
150:
151: $sizeataddr{$addr}=$size;
152: $totalmem += $size;
153:
154: if($trace) {
155: print "MALLOC: malloc($size) at $source:$linenum",
156: " makes totally $totalmem bytes\n";
157: }
158:
159: newtotal($totalmem);
160: $mallocs++;
161:
162: $getmem{$addr}="$source:$linenum";
163: }
164: elsif($function =~ /calloc\((\d*),(\d*)\) = 0x([0-9a-f]*)/) {
165: $size = $1*$2;
166: $addr = $3;
167:
168: $arg1 = $1;
169: $arg2 = $2;
170:
171: if($sizeataddr{$addr}>0) {
172: # this means weeeeeirdo
173: print "Mixed debug compile, rebuild curl now\n";
174: }
175:
176: $sizeataddr{$addr}=$size;
177: $totalmem += $size;
178:
179: if($trace) {
180: print "CALLOC: calloc($arg1,$arg2) at $source:$linenum",
181: " makes totally $totalmem bytes\n";
182: }
183:
184: newtotal($totalmem);
185: $callocs++;
186:
187: $getmem{$addr}="$source:$linenum";
188: }
189: elsif($function =~ /realloc\((\(nil\)|0x([0-9a-f]*)), (\d*)\) = 0x([0-9a-f]*)/) {
190: my ($oldaddr, $newsize, $newaddr) = ($2, $3, $4);
191:
192: $totalmem -= $sizeataddr{$oldaddr};
193: if($trace) {
194: printf("REALLOC: %d less bytes and ", $sizeataddr{$oldaddr});
195: }
196: $sizeataddr{$oldaddr}=0;
197:
198: $totalmem += $newsize;
199: $sizeataddr{$newaddr}=$newsize;
200:
201: if($trace) {
202: printf("%d more bytes ($source:$linenum)\n", $newsize);
203: }
204:
205: newtotal($totalmem);
206: $reallocs++;
207:
208: $getmem{$oldaddr}="";
209: $getmem{$newaddr}="$source:$linenum";
210: }
211: elsif($function =~ /strdup\(0x([0-9a-f]*)\) \((\d*)\) = 0x([0-9a-f]*)/) {
212: # strdup(a5b50) (8) = df7c0
213:
214: $dup = $1;
215: $size = $2;
216: $addr = $3;
217: $getmem{$addr}="$source:$linenum";
218: $sizeataddr{$addr}=$size;
219:
220: $totalmem += $size;
221:
222: if($trace) {
223: printf("STRDUP: $size bytes at %s, makes totally: %d bytes\n",
224: $getmem{$addr}, $totalmem);
225: }
226:
227: newtotal($totalmem);
228: $strdups++;
229: }
230: elsif($function =~ /wcsdup\(0x([0-9a-f]*)\) \((\d*)\) = 0x([0-9a-f]*)/) {
231: # wcsdup(a5b50) (8) = df7c0
232:
233: $dup = $1;
234: $size = $2;
235: $addr = $3;
236: $getmem{$addr}="$source:$linenum";
237: $sizeataddr{$addr}=$size;
238:
239: $totalmem += $size;
240:
241: if($trace) {
242: printf("WCSDUP: $size bytes at %s, makes totally: %d bytes\n",
243: $getmem{$addr}, $totalmem);
244: }
245:
246: newtotal($totalmem);
247: $wcsdups++;
248: }
249: else {
250: print "Not recognized input line: $function\n";
251: }
252: }
253: # FD url.c:1282 socket() = 5
254: elsif($_ =~ /^FD ([^ ]*):(\d*) (.*)/) {
255: # generic match for the filename+linenumber
256: $source = $1;
257: $linenum = $2;
258: $function = $3;
259:
260: if($function =~ /socket\(\) = (\d*)/) {
261: $filedes{$1}=1;
262: $getfile{$1}="$source:$linenum";
263: $openfile++;
264: $sockets++; # number of socket() calls
265: }
266: elsif($function =~ /socketpair\(\) = (\d*) (\d*)/) {
267: $filedes{$1}=1;
268: $getfile{$1}="$source:$linenum";
269: $openfile++;
270: $filedes{$2}=1;
271: $getfile{$2}="$source:$linenum";
272: $openfile++;
273: }
274: elsif($function =~ /accept\(\) = (\d*)/) {
275: $filedes{$1}=1;
276: $getfile{$1}="$source:$linenum";
277: $openfile++;
278: }
279: elsif($function =~ /sclose\((\d*)\)/) {
280: if($filedes{$1} != 1) {
281: print "Close without open: $line\n";
282: }
283: else {
284: $filedes{$1}=0; # closed now
285: $openfile--;
286: }
287: }
288: }
289: # FILE url.c:1282 fopen("blabla") = 0x5ddd
290: elsif($_ =~ /^FILE ([^ ]*):(\d*) (.*)/) {
291: # generic match for the filename+linenumber
292: $source = $1;
293: $linenum = $2;
294: $function = $3;
295:
296: if($function =~ /f[d]*open\(\"(.*)\",\"([^\"]*)\"\) = (\(nil\)|0x([0-9a-f]*))/) {
297: if($3 eq "(nil)") {
298: ;
299: }
300: else {
301: $fopen{$4}=1;
302: $fopenfile{$4}="$source:$linenum";
303: $fopens++;
304: }
305: }
306: # fclose(0x1026c8)
307: elsif($function =~ /fclose\(0x([0-9a-f]*)\)/) {
308: if(!$fopen{$1}) {
309: print "fclose() without fopen(): $line\n";
310: }
311: else {
312: $fopen{$1}=0;
313: $fopens--;
314: }
315: }
316: }
317: # GETNAME url.c:1901 getnameinfo()
318: elsif($_ =~ /^GETNAME ([^ ]*):(\d*) (.*)/) {
319: # not much to do
320: }
321: # SEND url.c:1901 send(83) = 83
322: elsif($_ =~ /^SEND ([^ ]*):(\d*) (.*)/) {
323: $sends++;
324: }
325: # RECV url.c:1901 recv(102400) = 256
326: elsif($_ =~ /^RECV ([^ ]*):(\d*) (.*)/) {
327: $recvs++;
328: }
329:
330: # ADDR url.c:1282 getaddrinfo() = 0x5ddd
331: elsif($_ =~ /^ADDR ([^ ]*):(\d*) (.*)/) {
332: # generic match for the filename+linenumber
333: $source = $1;
334: $linenum = $2;
335: $function = $3;
336:
337: if($function =~ /getaddrinfo\(\) = (\(nil\)|0x([0-9a-f]*))/) {
338: my $add = $2;
339: if($add eq "(nil)") {
340: ;
341: }
342: else {
343: $addrinfo{$add}=1;
344: $addrinfofile{$add}="$source:$linenum";
345: $addrinfos++;
346: }
347: if($trace) {
348: printf("GETADDRINFO ($source:$linenum)\n");
349: }
350: }
351: # fclose(0x1026c8)
352: elsif($function =~ /freeaddrinfo\(0x([0-9a-f]*)\)/) {
353: if(!$addrinfo{$1}) {
354: print "freeaddrinfo() without getaddrinfo(): $line\n";
355: }
356: else {
357: $addrinfo{$1}=0;
358: $addrinfos--;
359: }
360: if($trace) {
361: printf("FREEADDRINFO ($source:$linenum)\n");
362: }
363: }
364:
365: }
366: else {
367: print "Not recognized prefix line: $line\n";
368: }
369: }
370: close(FILE);
371:
372: if($totalmem) {
373: print "Leak detected: memory still allocated: $totalmem bytes\n";
374:
375: for(keys %sizeataddr) {
376: $addr = $_;
377: $size = $sizeataddr{$addr};
378: if($size > 0) {
379: print "At $addr, there's $size bytes.\n";
380: print " allocated by ".$getmem{$addr}."\n";
381: }
382: }
383: }
384:
385: if($openfile) {
386: for(keys %filedes) {
387: if($filedes{$_} == 1) {
388: print "Open file descriptor created at ".$getfile{$_}."\n";
389: }
390: }
391: }
392:
393: if($fopens) {
394: print "Open FILE handles left at:\n";
395: for(keys %fopen) {
396: if($fopen{$_} == 1) {
397: print "fopen() called at ".$fopenfile{$_}."\n";
398: }
399: }
400: }
401:
402: if($addrinfos) {
403: print "IPv6-style name resolve data left at:\n";
404: for(keys %addrinfofile) {
405: if($addrinfo{$_} == 1) {
406: print "getaddrinfo() called at ".$addrinfofile{$_}."\n";
407: }
408: }
409: }
410:
411: if($verbose) {
412: print "Mallocs: $mallocs\n",
413: "Reallocs: $reallocs\n",
414: "Callocs: $callocs\n",
415: "Strdups: $strdups\n",
416: "Wcsdups: $wcsdups\n",
417: "Frees: $frees\n",
418: "Sends: $sends\n",
419: "Recvs: $recvs\n",
420: "Sockets: $sockets\n",
421: "Allocations: ".($mallocs + $callocs + $reallocs + $strdups + $wcsdups)."\n",
422: "Operations: ".($mallocs + $callocs + $reallocs + $strdups + $wcsdups + $sends + $recvs + $sockets)."\n";
423:
424: print "Maximum allocated: $maxmem\n";
425: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to memanalyze.pl CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests