Debian Codegraph @

deps/curl/tests/memanalyze.pl

raw
1 #!/usr/bin/env perl
2 #***************************************************************************
3 # _ _ ____ _
4 # Project ___| | | | _ \| |
5 # / __| | | | |_) | |
6 # | (__| |_| | _ <| |___
7 # \___|\___/|_| \_\_____|
8 #
9 # Copyright (C) 1998 - 2017, Daniel Stenberg, <[email protected]>, 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 }