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