scripts/decode_stacktrace.sh

   1 #!/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3 # (c) 2014, Sasha Levin <sasha.levin@oracle.com>
   4 #set -x
   5
   6 if [[ $# < 1 ]]; then
   7         echo "Usage:"
   8         echo "  $0 -r <release> | <vmlinux> [base path] [modules path]"
   9         exit 1
  10 fi
  11
  12 if [[ $1 == "-r" ]] ; then
  13         vmlinux=""
  14         basepath="auto"
  15         modpath=""
  16         release=$2
  17
  18         for fn in {,/usr/lib/debug}/boot/vmlinux-$release{,.debug} /lib/modules/$release{,/build}/vmlinux ; do
  19                 if [ -e "$fn" ] ; then
  20                         vmlinux=$fn
  21                         break
  22                 fi
  23         done
  24
  25         if [[ $vmlinux == "" ]] ; then
  26                 echo "ERROR! vmlinux image for release $release is not found" >&2
  27                 exit 2
  28         fi
  29 else
  30         vmlinux=$1
  31         basepath=${2-auto}
  32         modpath=$3
  33         release=""
  34 fi
  35
  36 declare -A cache
  37 declare -A modcache
  38
  39 find_module() {
  40         if [[ "$modpath" != "" ]] ; then
  41                 for fn in $(find "$modpath" -name "${module//_/[-_]}.ko*") ; do
  42                         if readelf -WS "$fn" | grep -qwF .debug_line ; then
  43                                 echo $fn
  44                                 return
  45                         fi
  46                 done
  47                 return 1
  48         fi
  49
  50         modpath=$(dirname "$vmlinux")
  51         find_module && return
  52
  53         if [[ $release == "" ]] ; then
  54                 release=$(gdb -ex 'print init_uts_ns.name.release' -ex 'quit' -quiet -batch "$vmlinux" | sed -n 's/\$1 = "\(.*\)".*/\1/p')
  55         fi
  56
  57         for dn in {/usr/lib/debug,}/lib/modules/$release ; do
  58                 if [ -e "$dn" ] ; then
  59                         modpath="$dn"
  60                         find_module && return
  61                 fi
  62         done
  63
  64         modpath=""
  65         return 1
  66 }
  67
  68 parse_symbol() {
  69         # The structure of symbol at this point is:
  70         #   ([name]+[offset]/[total length])
  71         #
  72         # For example:
  73         #   do_basic_setup+0x9c/0xbf
  74
  75         if [[ $module == "" ]] ; then
  76                 local objfile=$vmlinux
  77         elif [[ "${modcache[$module]+isset}" == "isset" ]]; then
  78                 local objfile=${modcache[$module]}
  79         else
  80                 local objfile=$(find_module)
  81                 if [[ $objfile == "" ]] ; then
  82                         echo "WARNING! Modules path isn't set, but is needed to parse this symbol" >&2
  83                         return
  84                 fi
  85                 modcache[$module]=$objfile
  86         fi
  87
  88         # Remove the englobing parenthesis
  89         symbol=${symbol#\(}
  90         symbol=${symbol%\)}
  91
  92         # Strip segment
  93         local segment
  94         if [[ $symbol == *:* ]] ; then
  95                 segment=${symbol%%:*}:
  96                 symbol=${symbol#*:}
  97         fi
  98
  99         # Strip the symbol name so that we could look it up
 100         local name=${symbol%+*}
 101
 102         # Use 'nm vmlinux' to figure out the base address of said symbol.
 103         # It's actually faster to call it every time than to load it
 104         # all into bash.
 105         if [[ "${cache[$module,$name]+isset}" == "isset" ]]; then
 106                 local base_addr=${cache[$module,$name]}
 107         else
 108                 local base_addr=$(nm "$objfile" | awk '$3 == "'$name'" && ($2 == "t" || $2 == "T") {print $1; exit}')
 109                 if [[ $base_addr == "" ]] ; then
 110                         # address not found
 111                         return
 112                 fi
 113                 cache[$module,$name]="$base_addr"
 114         fi
 115         # Let's start doing the math to get the exact address into the
 116         # symbol. First, strip out the symbol total length.
 117         local expr=${symbol%/*}
 118
 119         # Now, replace the symbol name with the base address we found
 120         # before.
 121         expr=${expr/$name/0x$base_addr}
 122
 123         # Evaluate it to find the actual address
 124         expr=$((expr))
 125         local address=$(printf "%x\n" "$expr")
 126
 127         # Pass it to addr2line to get filename and line number
 128         # Could get more than one result
 129         if [[ "${cache[$module,$address]+isset}" == "isset" ]]; then
 130                 local code=${cache[$module,$address]}
 131         else
 132                 local code=$(${CROSS_COMPILE}addr2line -i -e "$objfile" "$address")
 133                 cache[$module,$address]=$code
 134         fi
 135
 136         # addr2line doesn't return a proper error code if it fails, so
 137         # we detect it using the value it prints so that we could preserve
 138         # the offset/size into the function and bail out
 139         if [[ $code == "??:0" ]]; then
 140                 return
 141         fi
 142
 143         # Strip out the base of the path on each line
 144         code=$(while read -r line; do echo "${line#$basepath/}"; done <<< "$code")
 145
 146         # In the case of inlines, move everything to same line
 147         code=${code//$'\n'/' '}
 148
 149         # Replace old address with pretty line numbers
 150         symbol="$segment$name ($code)"
 151 }
 152
 153 decode_code() {
 154         local scripts=`dirname "${BASH_SOURCE[0]}"`
 155
 156         echo "$1" | $scripts/decodecode
 157 }
 158
 159 handle_line() {
 160         local words
 161
 162         # Tokenize
 163         read -a words <<<"$1"
 164
 165         # Remove hex numbers. Do it ourselves until it happens in the
 166         # kernel
 167
 168         # We need to know the index of the last element before we
 169         # remove elements because arrays are sparse
 170         local last=$(( ${#words[@]} - 1 ))
 171
 172         for i in "${!words[@]}"; do
 173                 # Remove the address
 174                 if [[ ${words[$i]} =~ \[\<([^]]+)\>\] ]]; then
 175                         unset words[$i]
 176                 fi
 177
 178                 # Format timestamps with tabs
 179                 if [[ ${words[$i]} == \[ && ${words[$i+1]} == *\] ]]; then
 180                         unset words[$i]
 181                         words[$i+1]=$(printf "[%13s\n" "${words[$i+1]}")
 182                 fi
 183         done
 184
 185         if [[ ${words[$last]} =~ \[([^]]+)\] ]]; then
 186                 module=${words[$last]}
 187                 module=${module#\[}
 188                 module=${module%\]}
 189                 symbol=${words[$last-1]}
 190                 unset words[$last-1]
 191         else
 192                 # The symbol is the last element, process it
 193                 symbol=${words[$last]}
 194                 module=
 195         fi
 196
 197         unset words[$last]
 198         parse_symbol # modifies $symbol
 199
 200         # Add up the line number to the symbol
 201         echo "${words[@]}" "$symbol $module"
 202 }
 203
 204 if [[ $basepath == "auto" ]] ; then
 205         module=""
 206         symbol="kernel_init+0x0/0x0"
 207         parse_symbol
 208         basepath=${symbol#kernel_init (}
 209         basepath=${basepath%/init/main.c:*)}
 210 fi
 211
 212 while read line; do
 213         # Let's see if we have an address in the line
 214         if [[ $line =~ \[\<([^]]+)\>\] ]] ||
 215            [[ $line =~ [^+\ ]+\+0x[0-9a-f]+/0x[0-9a-f]+ ]]; then
 216                 # Translate address to line numbers
 217                 handle_line "$line"
 218         # Is it a code line?
 219         elif [[ $line == *Code:* ]]; then
 220                 decode_code "$line"
 221         else
 222                 # Nothing special in this line, show it as is
 223                 echo "$line"
 224         fi
 225 done