Merge tag 'afs-next-20190507' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowel...
[sfrench/cifs-2.6.git] / 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 [[ $# < 2 ]]; then
7         echo "Usage:"
8         echo "  $0 [vmlinux] [base path] [modules path]"
9         exit 1
10 fi
11
12 vmlinux=$1
13 basepath=$2
14 modpath=$3
15 declare -A cache
16 declare -A modcache
17
18 parse_symbol() {
19         # The structure of symbol at this point is:
20         #   ([name]+[offset]/[total length])
21         #
22         # For example:
23         #   do_basic_setup+0x9c/0xbf
24
25         if [[ $module == "" ]] ; then
26                 local objfile=$vmlinux
27         elif [[ "${modcache[$module]+isset}" == "isset" ]]; then
28                 local objfile=${modcache[$module]}
29         else
30                 [[ $modpath == "" ]] && return
31                 local objfile=$(find "$modpath" -name $module.ko -print -quit)
32                 [[ $objfile == "" ]] && return
33                 modcache[$module]=$objfile
34         fi
35
36         # Remove the englobing parenthesis
37         symbol=${symbol#\(}
38         symbol=${symbol%\)}
39
40         # Strip segment
41         local segment
42         if [[ $symbol == *:* ]] ; then
43                 segment=${symbol%%:*}:
44                 symbol=${symbol#*:}
45         fi
46
47         # Strip the symbol name so that we could look it up
48         local name=${symbol%+*}
49
50         # Use 'nm vmlinux' to figure out the base address of said symbol.
51         # It's actually faster to call it every time than to load it
52         # all into bash.
53         if [[ "${cache[$module,$name]+isset}" == "isset" ]]; then
54                 local base_addr=${cache[$module,$name]}
55         else
56                 local base_addr=$(nm "$objfile" | grep -i ' t ' | awk "/ $name\$/ {print \$1}" | head -n1)
57                 cache[$module,$name]="$base_addr"
58         fi
59         # Let's start doing the math to get the exact address into the
60         # symbol. First, strip out the symbol total length.
61         local expr=${symbol%/*}
62
63         # Now, replace the symbol name with the base address we found
64         # before.
65         expr=${expr/$name/0x$base_addr}
66
67         # Evaluate it to find the actual address
68         expr=$((expr))
69         local address=$(printf "%x\n" "$expr")
70
71         # Pass it to addr2line to get filename and line number
72         # Could get more than one result
73         if [[ "${cache[$module,$address]+isset}" == "isset" ]]; then
74                 local code=${cache[$module,$address]}
75         else
76                 local code=$(addr2line -i -e "$objfile" "$address")
77                 cache[$module,$address]=$code
78         fi
79
80         # addr2line doesn't return a proper error code if it fails, so
81         # we detect it using the value it prints so that we could preserve
82         # the offset/size into the function and bail out
83         if [[ $code == "??:0" ]]; then
84                 return
85         fi
86
87         # Strip out the base of the path
88         code=${code//^$basepath/""}
89
90         # In the case of inlines, move everything to same line
91         code=${code//$'\n'/' '}
92
93         # Replace old address with pretty line numbers
94         symbol="$segment$name ($code)"
95 }
96
97 decode_code() {
98         local scripts=`dirname "${BASH_SOURCE[0]}"`
99
100         echo "$1" | $scripts/decodecode
101 }
102
103 handle_line() {
104         local words
105
106         # Tokenize
107         read -a words <<<"$1"
108
109         # Remove hex numbers. Do it ourselves until it happens in the
110         # kernel
111
112         # We need to know the index of the last element before we
113         # remove elements because arrays are sparse
114         local last=$(( ${#words[@]} - 1 ))
115
116         for i in "${!words[@]}"; do
117                 # Remove the address
118                 if [[ ${words[$i]} =~ \[\<([^]]+)\>\] ]]; then
119                         unset words[$i]
120                 fi
121
122                 # Format timestamps with tabs
123                 if [[ ${words[$i]} == \[ && ${words[$i+1]} == *\] ]]; then
124                         unset words[$i]
125                         words[$i+1]=$(printf "[%13s\n" "${words[$i+1]}")
126                 fi
127         done
128
129         if [[ ${words[$last]} =~ \[([^]]+)\] ]]; then
130                 module=${words[$last]}
131                 module=${module#\[}
132                 module=${module%\]}
133                 symbol=${words[$last-1]}
134                 unset words[$last-1]
135         else
136                 # The symbol is the last element, process it
137                 symbol=${words[$last]}
138                 module=
139         fi
140
141         unset words[$last]
142         parse_symbol # modifies $symbol
143
144         # Add up the line number to the symbol
145         echo "${words[@]}" "$symbol $module"
146 }
147
148 while read line; do
149         # Let's see if we have an address in the line
150         if [[ $line =~ \[\<([^]]+)\>\] ]] ||
151            [[ $line =~ [^+\ ]+\+0x[0-9a-f]+/0x[0-9a-f]+ ]]; then
152                 # Translate address to line numbers
153                 handle_line "$line"
154         # Is it a code line?
155         elif [[ $line == *Code:* ]]; then
156                 decode_code "$line"
157         else
158                 # Nothing special in this line, show it as is
159                 echo "$line"
160         fi
161 done