LXR linux/scripts/markup

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