scripts/decode_stacktrace.sh

   1 #!/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3 # (c) 2014, Sasha Levin <[email protected]>
   4 #set -x
   5
   6 usage() {
   7         echo "Usage:"
   8         echo "  $0 -r <release> | <vmlinux> [<base path>|auto] [<modules path>]"
   9 }
  10
  11 # Try to find a Rust demangler
  12 if type llvm-cxxfilt >/dev/null 2>&1 ; then
  13         cppfilt=llvm-cxxfilt
  14 elif type c++filt >/dev/null 2>&1 ; then
  15         cppfilt=c++filt
  16         cppfilt_opts=-i
  17 fi
  18
  19 UTIL_SUFFIX=
  20 if [[ -z ${LLVM:-} ]]; then
  21         UTIL_PREFIX=${CROSS_COMPILE:-}
  22 else
  23         UTIL_PREFIX=llvm-
  24         if [[ ${LLVM} == */ ]]; then
  25                 UTIL_PREFIX=${LLVM}${UTIL_PREFIX}
  26         elif [[ ${LLVM} == -* ]]; then
  27                 UTIL_SUFFIX=${LLVM}
  28         fi
  29 fi
  30
  31 READELF=${UTIL_PREFIX}readelf${UTIL_SUFFIX}
  32 ADDR2LINE=${UTIL_PREFIX}addr2line${UTIL_SUFFIX}
  33 NM=${UTIL_PREFIX}nm${UTIL_SUFFIX}
  34
  35 if [[ $1 == "-r" ]] ; then
  36         vmlinux=""
  37         basepath="auto"
  38         modpath=""
  39         release=$2
  40
  41         for fn in {,/usr/lib/debug}/boot/vmlinux-$release{,.debug} /lib/modules/$release{,/build}/vmlinux ; do
  42                 if [ -e "$fn" ] ; then
  43                         vmlinux=$fn
  44                         break
  45                 fi
  46         done
  47
  48         if [[ $vmlinux == "" ]] ; then
  49                 echo "ERROR! vmlinux image for release $release is not found" >&2
  50                 usage
  51                 exit 2
  52         fi
  53 else
  54         vmlinux=$1
  55         basepath=${2-auto}
  56         modpath=$3
  57         release=""
  58         debuginfod=
  59
  60         # Can we use debuginfod-find?
  61         if type debuginfod-find >/dev/null 2>&1 ; then
  62                 debuginfod=${1-only}
  63         fi
  64
  65         if [[ $vmlinux == "" && -z $debuginfod ]] ; then
  66                 echo "ERROR! vmlinux image must be specified" >&2
  67                 usage
  68                 exit 1
  69         fi
  70 fi
  71
  72 declare aarray_support=true
  73 declare -A cache 2>/dev/null
  74 if [[ $? != 0 ]]; then
  75         aarray_support=false
  76 else
  77         declare -A modcache
  78 fi
  79
  80 find_module() {
  81         if [[ -n $debuginfod ]] ; then
  82                 if [[ -n $modbuildid ]] ; then
  83                         debuginfod-find debuginfo $modbuildid && return
  84                 fi
  85
  86                 # Only using debuginfod so don't try to find vmlinux module path
  87                 if [[ $debuginfod == "only" ]] ; then
  88                         return
  89                 fi
  90         fi
  91
  92         if [[ "$modpath" != "" ]] ; then
  93                 for fn in $(find "$modpath" -name "${module//_/[-_]}.ko*") ; do
  94                         if ${READELF} -WS "$fn" | grep -qwF .debug_line ; then
  95                                 echo $fn
  96                                 return
  97                         fi
  98                 done
  99                 return 1
 100         fi
 101
 102         modpath=$(dirname "$vmlinux")
 103         find_module && return
 104
 105         if [[ $release == "" ]] ; then
 106                 release=$(gdb -ex 'print init_uts_ns.name.release' -ex 'quit' -quiet -batch "$vmlinux" 2>/dev/null | sed -n 's/\$1 = "\(.*\)".*/\1/p')
 107         fi
 108
 109         for dn in {/usr/lib/debug,}/lib/modules/$release ; do
 110                 if [ -e "$dn" ] ; then
 111                         modpath="$dn"
 112                         find_module && return
 113                 fi
 114         done
 115
 116         modpath=""
 117         return 1
 118 }
 119
 120 parse_symbol() {
 121         # The structure of symbol at this point is:
 122         #   ([name]+[offset]/[total length])
 123         #
 124         # For example:
 125         #   do_basic_setup+0x9c/0xbf
 126
 127         if [[ $module == "" ]] ; then
 128                 local objfile=$vmlinux
 129         elif [[ $aarray_support == true && "${modcache[$module]+isset}" == "isset" ]]; then
 130                 local objfile=${modcache[$module]}
 131         else
 132                 local objfile=$(find_module)
 133                 if [[ $objfile == "" ]] ; then
 134                         echo "WARNING! Modules path isn't set, but is needed to parse this symbol" >&2
 135                         return
 136                 fi
 137                 if [[ $aarray_support == true ]]; then
 138                         modcache[$module]=$objfile
 139                 fi
 140         fi
 141
 142         # Remove the englobing parenthesis
 143         symbol=${symbol#\(}
 144         symbol=${symbol%\)}
 145
 146         # Strip segment
 147         local segment
 148         if [[ $symbol == *:* ]] ; then
 149                 segment=${symbol%%:*}:
 150                 symbol=${symbol#*:}
 151         fi
 152
 153         # Strip the symbol name so that we could look it up
 154         local name=${symbol%+*}
 155
 156         # Use 'nm vmlinux' to figure out the base address of said symbol.
 157         # It's actually faster to call it every time than to load it
 158         # all into bash.
 159         if [[ $aarray_support == true && "${cache[$module,$name]+isset}" == "isset" ]]; then
 160                 local base_addr=${cache[$module,$name]}
 161         else
 162                 local base_addr=$(${NM} "$objfile" 2>/dev/null | awk '$3 == "'$name'" && ($2 == "t" || $2 == "T") {print $1; exit}')
 163                 if [[ $base_addr == "" ]] ; then
 164                         # address not found
 165                         return
 166                 fi
 167                 if [[ $aarray_support == true ]]; then
 168                         cache[$module,$name]="$base_addr"
 169                 fi
 170         fi
 171         # Let's start doing the math to get the exact address into the
 172         # symbol. First, strip out the symbol total length.
 173         local expr=${symbol%/*}
 174
 175         # Now, replace the symbol name with the base address we found
 176         # before.
 177         expr=${expr/$name/0x$base_addr}
 178
 179         # Evaluate it to find the actual address
 180         expr=$((expr))
 181         local address=$(printf "%x\n" "$expr")
 182
 183         # Pass it to addr2line to get filename and line number
 184         # Could get more than one result
 185         if [[ $aarray_support == true && "${cache[$module,$address]+isset}" == "isset" ]]; then
 186                 local code=${cache[$module,$address]}
 187         else
 188                 local code=$(${ADDR2LINE} -i -e "$objfile" "$address" 2>/dev/null)
 189                 if [[ $aarray_support == true ]]; then
 190                         cache[$module,$address]=$code
 191                 fi
 192         fi
 193
 194         # addr2line doesn't return a proper error code if it fails, so
 195         # we detect it using the value it prints so that we could preserve
 196         # the offset/size into the function and bail out
 197         if [[ $code == "??:0" ]]; then
 198                 return
 199         fi
 200
 201         # Strip out the base of the path on each line
 202         code=$(while read -r line; do echo "${line#$basepath/}"; done <<< "$code")
 203
 204         # In the case of inlines, move everything to same line
 205         code=${code//$'\n'/' '}
 206
 207         # Demangle if the name looks like a Rust symbol and if
 208         # we got a Rust demangler
 209         if [[ $name =~ ^_R && $cppfilt != "" ]] ; then
 210                 name=$("$cppfilt" "$cppfilt_opts" "$name")
 211         fi
 212
 213         # Replace old address with pretty line numbers
 214         symbol="$segment$name ($code)"
 215 }
 216
 217 debuginfod_get_vmlinux() {
 218         local vmlinux_buildid=${1##* }
 219
 220         if [[ $vmlinux != "" ]]; then
 221                 return
 222         fi
 223
 224         if [[ $vmlinux_buildid =~ ^[0-9a-f]+ ]]; then
 225                 vmlinux=$(debuginfod-find debuginfo $vmlinux_buildid)
 226                 if [[ $? -ne 0 ]] ; then
 227                         echo "ERROR! vmlinux image not found via debuginfod-find" >&2
 228                         usage
 229                         exit 2
 230                 fi
 231                 return
 232         fi
 233         echo "ERROR! Build ID for vmlinux not found. Try passing -r or specifying vmlinux" >&2
 234         usage
 235         exit 2
 236 }
 237
 238 decode_code() {
 239         local scripts=`dirname "${BASH_SOURCE[0]}"`
 240
 241         echo "$1" | $scripts/decodecode
 242 }
 243
 244 handle_line() {
 245         if [[ $basepath == "auto" && $vmlinux != "" ]] ; then
 246                 module=""
 247                 symbol="kernel_init+0x0/0x0"
 248                 parse_symbol
 249                 basepath=${symbol#kernel_init (}
 250                 basepath=${basepath%/init/main.c:*)}
 251         fi
 252
 253         local words
 254
 255         # Tokenize
 256         read -a words <<<"$1"
 257
 258         # Remove hex numbers. Do it ourselves until it happens in the
 259         # kernel
 260
 261         # We need to know the index of the last element before we
 262         # remove elements because arrays are sparse
 263         local last=$(( ${#words[@]} - 1 ))
 264
 265         for i in "${!words[@]}"; do
 266                 # Remove the address
 267                 if [[ ${words[$i]} =~ \[\<([^]]+)\>\] ]]; then
 268                         unset words[$i]
 269                 fi
 270
 271                 # Format timestamps with tabs
 272                 if [[ ${words[$i]} == \[ && ${words[$i+1]} == *\] ]]; then
 273                         unset words[$i]
 274                         words[$i+1]=$(printf "[%13s\n" "${words[$i+1]}")
 275                 fi
 276         done
 277
 278         if [[ ${words[$last]} =~ ^[0-9a-f]+\] ]]; then
 279                 words[$last-1]="${words[$last-1]} ${words[$last]}"
 280                 unset words[$last]
 281                 last=$(( $last - 1 ))
 282         fi
 283
 284         if [[ ${words[$last]} =~ \[([^]]+)\] ]]; then
 285                 module=${words[$last]}
 286                 # some traces format is "(%pS)", which like "(foo+0x0/0x1 [bar])"
 287                 # so $module may like "[bar])". Strip the right parenthesis firstly
 288                 module=${module%\)}
 289                 module=${module#\[}
 290                 module=${module%\]}
 291                 modbuildid=${module#* }
 292                 module=${module% *}
 293                 if [[ $modbuildid == $module ]]; then
 294                         modbuildid=
 295                 fi
 296                 symbol=${words[$last-1]}
 297                 unset words[$last-1]
 298         else
 299                 # The symbol is the last element, process it
 300                 symbol=${words[$last]}
 301                 module=
 302                 modbuildid=
 303         fi
 304
 305         unset words[$last]
 306         parse_symbol # modifies $symbol
 307
 308         # Add up the line number to the symbol
 309         echo "${words[@]}" "$symbol $module"
 310 }
 311
 312 while read line; do
 313         # Strip unexpected carriage return at end of line
 314         line=${line%$'\r'}
 315
 316         # Let's see if we have an address in the line
 317         if [[ $line =~ \[\<([^]]+)\>\] ]] ||
 318            [[ $line =~ [^+\ ]+\+0x[0-9a-f]+/0x[0-9a-f]+ ]]; then
 319                 # Translate address to line numbers
 320                 handle_line "$line"
 321         # Is it a code line?
 322         elif [[ $line == *Code:* ]]; then
 323                 decode_code "$line"
 324         # Is it a version line?
 325         elif [[ -n $debuginfod && $line =~ PID:\ [0-9]+\ Comm: ]]; then
 326                 debuginfod_get_vmlinux "$line"
 327         else
 328                 # Nothing special in this line, show it as is
 329                 echo "$line"
 330         fi
 331 done