Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/scripts/markup_oops.pl

  1 #!/usr/bin/perl
  2 
  3 use File::Basename;
  4 use Math::BigInt;
  5 use Getopt::Long;
  6 
  7 # Copyright 2008, Intel Corporation
  8 #
  9 # This file is part of the Linux kernel
 10 #
 11 # This program file is free software; you can redistribute it and/or modify it
 12 # under the terms of the GNU General Public License as published by the
 13 # Free Software Foundation; version 2 of the License.
 14 #
 15 # Authors:
 16 #       Arjan van de Ven <arjan@linux.intel.com>
 17 
 18 
 19 my $cross_compile = "";
 20 my $vmlinux_name = "";
 21 my $modulefile = "";
 22 
 23 # Get options
 24 Getopt::Long::GetOptions(
 25         'cross-compile|c=s'     => \$cross_compile,
 26         'module|m=s'            => \$modulefile,
 27         'help|h'                => \&usage,
 28 ) || usage ();
 29 my $vmlinux_name = $ARGV[0];
 30 if (!defined($vmlinux_name)) {
 31         my $kerver = `uname -r`;
 32         chomp($kerver);
 33         $vmlinux_name = "/lib/modules/$kerver/build/vmlinux";
 34         print "No vmlinux specified, assuming $vmlinux_name\n";
 35 }
 36 my $filename = $vmlinux_name;
 37 
 38 # Parse the oops to find the EIP value
 39 
 40 my $target = "0";
 41 my $function;
 42 my $module = "";
 43 my $func_offset = 0;
 44 my $vmaoffset = 0;
 45 
 46 my %regs;
 47 
 48 
 49 sub parse_x86_regs
 50 {
 51         my ($line) = @_;
 52         if ($line =~ /EAX: ([0-9a-f]+) EBX: ([0-9a-f]+) ECX: ([0-9a-f]+) EDX: ([0-9a-f]+)/) {
 53                 $regs{"%eax"} = $1;
 54                 $regs{"%ebx"} = $2;
 55                 $regs{"%ecx"} = $3;
 56                 $regs{"%edx"} = $4;
 57         }
 58         if ($line =~ /ESI: ([0-9a-f]+) EDI: ([0-9a-f]+) EBP: ([0-9a-f]+) ESP: ([0-9a-f]+)/) {
 59                 $regs{"%esi"} = $1;
 60                 $regs{"%edi"} = $2;
 61                 $regs{"%esp"} = $4;
 62         }
 63         if ($line =~ /RAX: ([0-9a-f]+) RBX: ([0-9a-f]+) RCX: ([0-9a-f]+)/) {
 64                 $regs{"%eax"} = $1;
 65                 $regs{"%ebx"} = $2;
 66                 $regs{"%ecx"} = $3;
 67         }
 68         if ($line =~ /RDX: ([0-9a-f]+) RSI: ([0-9a-f]+) RDI: ([0-9a-f]+)/) {
 69                 $regs{"%edx"} = $1;
 70                 $regs{"%esi"} = $2;
 71                 $regs{"%edi"} = $3;
 72         }
 73         if ($line =~ /RBP: ([0-9a-f]+) R08: ([0-9a-f]+) R09: ([0-9a-f]+)/) {
 74                 $regs{"%r08"} = $2;
 75                 $regs{"%r09"} = $3;
 76         }
 77         if ($line =~ /R10: ([0-9a-f]+) R11: ([0-9a-f]+) R12: ([0-9a-f]+)/) {
 78                 $regs{"%r10"} = $1;
 79                 $regs{"%r11"} = $2;
 80                 $regs{"%r12"} = $3;
 81         }
 82         if ($line =~ /R13: ([0-9a-f]+) R14: ([0-9a-f]+) R15: ([0-9a-f]+)/) {
 83                 $regs{"%r13"} = $1;
 84                 $regs{"%r14"} = $2;
 85                 $regs{"%r15"} = $3;
 86         }
 87 }
 88 
 89 sub reg_name
 90 {
 91         my ($reg) = @_;
 92         $reg =~ s/r(.)x/e\1x/;
 93         $reg =~ s/r(.)i/e\1i/;
 94         $reg =~ s/r(.)p/e\1p/;
 95         return $reg;
 96 }
 97 
 98 sub process_x86_regs
 99 {
100         my ($line, $cntr) = @_;
101         my $str = "";
102         if (length($line) < 40) {
103                 return ""; # not an asm istruction
104         }
105 
106         # find the arguments to the instruction
107         if ($line =~ /([0-9a-zA-Z\,\%\(\)\-\+]+)$/) {
108                 $lastword = $1;
109         } else {
110                 return "";
111         }
112 
113         # we need to find the registers that get clobbered,
114         # since their value is no longer relevant for previous
115         # instructions in the stream.
116 
117         $clobber = $lastword;
118         # first, remove all memory operands, they're read only
119         $clobber =~ s/\([a-z0-9\%\,]+\)//g;
120         # then, remove everything before the comma, thats the read part
121         $clobber =~ s/.*\,//g;
122 
123         # if this is the instruction that faulted, we haven't actually done
124         # the write yet... nothing is clobbered.
125         if ($cntr == 0) {
126                 $clobber = "";
127         }
128 
129         foreach $reg (keys(%regs)) {
130                 my $clobberprime = reg_name($clobber);
131                 my $lastwordprime = reg_name($lastword);
132                 my $val = $regs{$reg};
133                 if ($val =~ /^[0]+$/) {
134                         $val = "0";
135                 } else {
136                         $val =~ s/^0*//;
137                 }
138 
139                 # first check if we're clobbering this register; if we do
140                 # we print it with a =>, and then delete its value
141                 if ($clobber =~ /$reg/ || $clobberprime =~ /$reg/) {
142                         if (length($val) > 0) {
143                                 $str = $str . " $reg => $val ";
144                         }
145                         $regs{$reg} = "";
146                         $val = "";
147                 }
148                 # now check if we're reading this register
149                 if ($lastword =~ /$reg/ || $lastwordprime =~ /$reg/) {
150                         if (length($val) > 0) {
151                                 $str = $str . " $reg = $val ";
152                         }
153                 }
154         }
155         return $str;
156 }
157 
158 # parse the oops
159 while (<STDIN>) {
160         my $line = $_;
161         if ($line =~ /EIP: 0060:\[\<([a-z0-9]+)\>\]/) {
162                 $target = $1;
163         }
164         if ($line =~ /RIP: 0010:\[\<([a-z0-9]+)\>\]/) {
165                 $target = $1;
166         }
167         if ($line =~ /EIP is at ([a-zA-Z0-9\_]+)\+0x([0-9a-f]+)\/0x[a-f0-9]/) {
168                 $function = $1;
169                 $func_offset = $2;
170         }
171         if ($line =~ /RIP: 0010:\[\<[0-9a-f]+\>\]  \[\<[0-9a-f]+\>\] ([a-zA-Z0-9\_]+)\+0x([0-9a-f]+)\/0x[a-f0-9]/) {
172                 $function = $1;
173                 $func_offset = $2;
174         }
175 
176         # check if it's a module
177         if ($line =~ /EIP is at ([a-zA-Z0-9\_]+)\+(0x[0-9a-f]+)\/0x[a-f0-9]+\W\[([a-zA-Z0-9\_\-]+)\]/) {
178                 $module = $3;
179         }
180         if ($line =~ /RIP: 0010:\[\<[0-9a-f]+\>\]  \[\<[0-9a-f]+\>\] ([a-zA-Z0-9\_]+)\+(0x[0-9a-f]+)\/0x[a-f0-9]+\W\[([a-zA-Z0-9\_\-]+)\]/) {
181                 $module = $3;
182         }
183         parse_x86_regs($line);
184 }
185 
186 my $decodestart = Math::BigInt->from_hex("0x$target") - Math::BigInt->from_hex("0x$func_offset");
187 my $decodestop = Math::BigInt->from_hex("0x$target") + 8192;
188 if ($target eq "0") {
189         print "No oops found!\n";
190         usage();
191 }
192 
193 # if it's a module, we need to find the .ko file and calculate a load offset
194 if ($module ne "") {
195         if ($modulefile eq "") {
196                 $modulefile = `modinfo -F filename $module`;
197                 chomp($modulefile);
198         }
199         $filename = $modulefile;
200         if ($filename eq "") {
201                 print "Module .ko file for $module not found. Aborting\n";
202                 exit;
203         }
204         # ok so we found the module, now we need to calculate the vma offset
205         open(FILE, $cross_compile."objdump -dS $filename |") || die "Cannot start objdump";
206         while (<FILE>) {
207                 if ($_ =~ /^([0-9a-f]+) \<$function\>\:/) {
208                         my $fu = $1;
209                         $vmaoffset = Math::BigInt->from_hex("0x$target") - Math::BigInt->from_hex("0x$fu") - Math::BigInt->from_hex("0x$func_offset");
210                 }
211         }
212         close(FILE);
213 }
214 
215 my $counter = 0;
216 my $state   = 0;
217 my $center  = -1;
218 my @lines;
219 my @reglines;
220 
221 sub InRange {
222         my ($address, $target) = @_;
223         my $ad = "0x".$address;
224         my $ta = "0x".$target;
225         my $delta = Math::BigInt->from_hex($ad) - Math::BigInt->from_hex($ta);
226 
227         if (($delta > -4096) && ($delta < 4096)) {
228                 return 1;
229         }
230         return 0;
231 }
232 
233 
234 
235 # first, parse the input into the lines array, but to keep size down,
236 # we only do this for 4Kb around the sweet spot
237 
238 open(FILE, $cross_compile."objdump -dS --adjust-vma=$vmaoffset --start-address=$decodestart --stop-address=$decodestop $filename |") || die "Cannot start objdump";
239 
240 while (<FILE>) {
241         my $line = $_;
242         chomp($line);
243         if ($state == 0) {
244                 if ($line =~ /^([a-f0-9]+)\:/) {
245                         if (InRange($1, $target)) {
246                                 $state = 1;
247                         }
248                 }
249         }
250         if ($state == 1) {
251                 if ($line =~ /^([a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9][a-f0-9]+)\:/) {
252                         my $val = $1;
253                         if (!InRange($val, $target)) {
254                                 last;
255                         }
256                         if ($val eq $target) {
257                                 $center = $counter;
258                         }
259                 }
260                 $lines[$counter] = $line;
261 
262                 $counter = $counter + 1;
263         }
264 }
265 
266 close(FILE);
267 
268 if ($counter == 0) {
269         print "No matching code found \n";
270         exit;
271 }
272 
273 if ($center == -1) {
274         print "No matching code found \n";
275         exit;
276 }
277 
278 my $start;
279 my $finish;
280 my $codelines = 0;
281 my $binarylines = 0;
282 # now we go up and down in the array to find how much we want to print
283 
284 $start = $center;
285 
286 while ($start > 1) {
287         $start = $start - 1;
288         my $line = $lines[$start];
289         if ($line =~ /^([a-f0-9]+)\:/) {
290                 $binarylines = $binarylines + 1;
291         } else {
292                 $codelines = $codelines + 1;
293         }
294         if ($codelines > 10) {
295                 last;
296         }
297         if ($binarylines > 20) {
298                 last;
299         }
300 }
301 
302 
303 $finish = $center;
304 $codelines = 0;
305 $binarylines = 0;
306 while ($finish < $counter) {
307         $finish = $finish + 1;
308         my $line = $lines[$finish];
309         if ($line =~ /^([a-f0-9]+)\:/) {
310                 $binarylines = $binarylines + 1;
311         } else {
312                 $codelines = $codelines + 1;
313         }
314         if ($codelines > 10) {
315                 last;
316         }
317         if ($binarylines > 20) {
318                 last;
319         }
320 }
321 
322 
323 my $i;
324 
325 
326 # start annotating the registers in the asm.
327 # this goes from the oopsing point back, so that the annotator
328 # can track (opportunistically) which registers got written and
329 # whos value no longer is relevant.
330 
331 $i = $center;
332 while ($i >= $start) {
333         $reglines[$i] = process_x86_regs($lines[$i], $center - $i);
334         $i = $i - 1;
335 }
336 
337 $i = $start;
338 while ($i < $finish) {
339         my $line;
340         if ($i == $center) {
341                 $line =  "*$lines[$i] ";
342         } else {
343                 $line =  " $lines[$i] ";
344         }
345         print $line;
346         if (defined($reglines[$i]) && length($reglines[$i]) > 0) {
347                 my $c = 60 - length($line);
348                 while ($c > 0) { print " "; $c = $c - 1; };
349                 print "| $reglines[$i]";
350         }
351         if ($i == $center) {
352                 print "<--- faulting instruction";
353         }
354         print "\n";
355         $i = $i +1;
356 }
357 
358 sub usage {
359         print <<EOT;
360 Usage:
361   dmesg | perl $0 [OPTION] [VMLINUX]
362 
363 OPTION:
364   -c, --cross-compile CROSS_COMPILE     Specify the prefix used for toolchain.
365   -m, --module MODULE_DIRNAME           Specify the module filename.
366   -h, --help                            Help.
367 EOT
368         exit;
369 }

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us