blob: 206e820714b6fecba7b9169482d5325598a018df [file] [log] [blame]
#!/usr/bin/env python3
# SPDX-License-Identifier: BSD-2-Clause
#
# Copyright (c) 2017, Linaro Limited
#
import argparse
import errno
import glob
import os
import re
import subprocess
import sys
import termios
CALL_STACK_RE = re.compile('Call stack:')
TEE_LOAD_ADDR_RE = re.compile(r'TEE load address @ (?P<load_addr>0x[0-9a-f]+)')
# This gets the address from lines looking like this:
# E/TC:0 0x001044a8
STACK_ADDR_RE = re.compile(
r'[UEIDFM]/(TC|LD):(\?*|[0-9]*) [0-9]* +(?P<addr>0x[0-9a-f]+)')
ABORT_ADDR_RE = re.compile(r'-abort at address (?P<addr>0x[0-9a-f]+)')
REGION_RE = re.compile(r'region +[0-9]+: va (?P<addr>0x[0-9a-f]+) '
r'pa 0x[0-9a-f]+ size (?P<size>0x[0-9a-f]+)'
r'( flags .{4} (\[(?P<elf_idx>[0-9]+)\])?)?')
ELF_LIST_RE = re.compile(r'\[(?P<idx>[0-9]+)\] (?P<uuid>[0-9a-f\-]+)'
r' @ (?P<load_addr>0x[0-9a-f\-]+)')
FUNC_GRAPH_RE = re.compile(r'Function graph')
GRAPH_ADDR_RE = re.compile(r'(?P<addr>0x[0-9a-f]+)')
GRAPH_RE = re.compile(r'}')
epilog = '''
This scripts reads an OP-TEE abort or panic message from stdin and adds debug
information to the output, such as '<function> at <file>:<line>' next to each
address in the call stack. Any message generated by OP-TEE and containing a
call stack can in principle be processed by this script. This currently
includes aborts and panics from the TEE core as well as from any TA.
The paths provided on the command line are used to locate the appropriate ELF
binary (tee.elf or Trusted Application). The GNU binutils (addr2line, objdump,
nm) are used to extract the debug info. If the CROSS_COMPILE environment
variable is set, it is used as a prefix to the binutils tools. That is, the
script will invoke $(CROSS_COMPILE)addr2line etc. If it is not set however,
the prefix will be determined automatically for each ELF file based on its
architecture (arm-linux-gnueabihf-, aarch64-linux-gnu-). The resulting command
is then expected to be found in the user's PATH.
OP-TEE abort and panic messages are sent to the secure console. They look like
the following:
E/TC:0 User TA data-abort at address 0xffffdecd (alignment fault)
...
E/TC:0 Call stack:
E/TC:0 0x4000549e
E/TC:0 0x40001f4b
E/TC:0 0x4000273f
E/TC:0 0x40005da7
Inspired by a script of the same name by the Chromium project.
Sample usage:
$ scripts/symbolize.py -d out/arm-plat-hikey/core -d ../optee_test/out/ta/*
<paste whole dump here>
^D
Also, this script reads function graph generated for OP-TEE user TA from
/tmp/ftrace-<ta_uuid>.out file and resolves function addresses to corresponding
symbols.
Sample usage:
$ cat /tmp/ftrace-<ta_uuid>.out | scripts/symbolize.py -d <ta_uuid>.elf
<paste function graph here>
^D
'''
def get_args():
parser = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
description='Symbolizes OP-TEE abort dumps or function graphs',
epilog=epilog)
parser.add_argument('-d', '--dir', action='append', nargs='+',
help='Search for ELF file in DIR. tee.elf is needed '
'to decode a TEE Core or pseudo-TA abort, while '
'<TA_uuid>.elf is required if a user-mode TA has '
'crashed. For convenience, ELF files may also be '
'given.')
parser.add_argument('-s', '--strip_path', nargs='?',
help='Strip STRIP_PATH from file paths (default: '
'current directory, use -s with no argument to show '
'full paths)', default=os.getcwd())
return parser.parse_args()
class Symbolizer(object):
def __init__(self, out, dirs, strip_path):
self._out = out
self._dirs = dirs
self._strip_path = strip_path
self._addr2line = None
self.reset()
def my_Popen(self, cmd):
try:
return subprocess.Popen(cmd, stdin=subprocess.PIPE,
stdout=subprocess.PIPE, text=True,
bufsize=1)
except OSError as e:
if e.errno == errno.ENOENT:
print("*** Error:{}: command not found".format(cmd[0]),
file=sys.stderr)
sys.exit(1)
def get_elf(self, elf_or_uuid):
if not elf_or_uuid.endswith('.elf'):
elf_or_uuid += '.elf'
for d in self._dirs:
if d.endswith(elf_or_uuid) and os.path.isfile(d):
return d
elf = glob.glob(d + '/' + elf_or_uuid)
if elf:
return elf[0]
def set_arch(self):
if self._arch:
return
self._arch = os.getenv('CROSS_COMPILE')
if self._arch:
return
elf = self.get_elf(self._elfs[0][0])
if elf is None:
return
p = subprocess.Popen(['file', self.get_elf(self._elfs[0][0])],
stdout=subprocess.PIPE)
output = p.stdout.readlines()
p.terminate()
if b'ARM aarch64,' in output[0]:
self._arch = 'aarch64-linux-gnu-'
elif b'ARM,' in output[0]:
self._arch = 'arm-linux-gnueabihf-'
def arch_prefix(self, cmd):
self.set_arch()
if self._arch is None:
return ''
return self._arch + cmd
def spawn_addr2line(self, elf_name):
if elf_name is None:
return
if self._addr2line_elf_name is elf_name:
return
if self._addr2line:
self._addr2line.terminate
self._addr2line = None
elf = self.get_elf(elf_name)
if not elf:
return
cmd = self.arch_prefix('addr2line')
if not cmd:
return
self._addr2line = self.my_Popen([cmd, '-f', '-p', '-e', elf])
# If addr falls into a region that maps a TA ELF file, return the load
# address of that file.
def elf_load_addr(self, addr):
if self._regions:
for r in self._regions:
r_addr = int(r[0], 16)
r_size = int(r[1], 16)
i_addr = int(addr, 16)
if (i_addr >= r_addr and i_addr < (r_addr + r_size)):
# Found region
elf_idx = r[2]
if elf_idx is not None:
return self._elfs[int(elf_idx)][1]
# In case address is not found in TA ELF file, fallback to tee.elf
# especially to symbolize mixed (user-space and kernel) addresses
# which is true when syscall ftrace is enabled along with TA
# ftrace.
return self._tee_load_addr
else:
# tee.elf
return self._tee_load_addr
def elf_for_addr(self, addr):
l_addr = self.elf_load_addr(addr)
if l_addr == self._tee_load_addr:
return 'tee.elf'
for k in self._elfs:
e = self._elfs[k]
if int(e[1], 16) == int(l_addr, 16):
return e[0]
return None
def subtract_load_addr(self, addr):
l_addr = self.elf_load_addr(addr)
if l_addr is None:
return None
if int(l_addr, 16) > int(addr, 16):
return ''
return '0x{:x}'.format(int(addr, 16) - int(l_addr, 16))
def resolve(self, addr):
reladdr = self.subtract_load_addr(addr)
self.spawn_addr2line(self.elf_for_addr(addr))
if not reladdr or not self._addr2line:
return '???'
if self.elf_for_addr(addr) == 'tee.elf':
reladdr = '0x{:x}'.format(int(reladdr, 16) +
int(self.first_vma('tee.elf'), 16))
try:
print(reladdr, file=self._addr2line.stdin)
ret = self._addr2line.stdout.readline().rstrip('\n')
except IOError:
ret = '!!!'
return ret
def symbol_plus_offset(self, addr):
ret = ''
prevsize = 0
reladdr = self.subtract_load_addr(addr)
elf_name = self.elf_for_addr(addr)
if elf_name is None:
return ''
elf = self.get_elf(elf_name)
cmd = self.arch_prefix('nm')
if not reladdr or not elf or not cmd:
return ''
ireladdr = int(reladdr, 16)
nm = self.my_Popen([cmd, '--numeric-sort', '--print-size', elf])
for line in iter(nm.stdout.readline, ''):
try:
addr, size, _, name = line.split()
except ValueError:
# Size is missing
try:
addr, _, name = line.split()
size = '0'
except ValueError:
# E.g., undefined (external) symbols (line = "U symbol")
continue
iaddr = int(addr, 16)
isize = int(size, 16)
if iaddr == ireladdr:
ret = name
break
if iaddr < ireladdr and iaddr + isize >= ireladdr:
offs = ireladdr - iaddr
ret = name + '+' + str(offs)
break
if iaddr > ireladdr and prevsize == 0:
offs = iaddr + ireladdr
ret = prevname + '+' + str(offs)
break
prevsize = size
prevname = name
nm.terminate()
return ret
def section_plus_offset(self, addr):
ret = ''
reladdr = self.subtract_load_addr(addr)
elf_name = self.elf_for_addr(addr)
if elf_name is None:
return ''
elf = self.get_elf(elf_name)
cmd = self.arch_prefix('objdump')
if not reladdr or not elf or not cmd:
return ''
iaddr = int(reladdr, 16)
objdump = self.my_Popen([cmd, '--section-headers', elf])
for line in iter(objdump.stdout.readline, ''):
try:
idx, name, size, vma, lma, offs, algn = line.split()
except ValueError:
continue
ivma = int(vma, 16)
isize = int(size, 16)
if ivma == iaddr:
ret = name
break
if ivma < iaddr and ivma + isize >= iaddr:
offs = iaddr - ivma
ret = name + '+' + str(offs)
break
objdump.terminate()
return ret
def process_abort(self, line):
ret = ''
match = re.search(ABORT_ADDR_RE, line)
addr = match.group('addr')
pre = match.start('addr')
post = match.end('addr')
sym = self.symbol_plus_offset(addr)
sec = self.section_plus_offset(addr)
if sym or sec:
ret += line[:pre]
ret += addr
if sym:
ret += ' ' + sym
if sec:
ret += ' ' + sec
ret += line[post:]
return ret
# Return all ELF sections with the ALLOC flag
def read_sections(self, elf_name):
if elf_name is None:
return
if elf_name in self._sections:
return
elf = self.get_elf(elf_name)
cmd = self.arch_prefix('objdump')
if not elf or not cmd:
return
self._sections[elf_name] = []
objdump = self.my_Popen([cmd, '--section-headers', elf])
for line in iter(objdump.stdout.readline, ''):
try:
_, name, size, vma, _, _, _ = line.split()
except ValueError:
if 'ALLOC' in line:
self._sections[elf_name].append([name, int(vma, 16),
int(size, 16)])
def first_vma(self, elf_name):
self.read_sections(elf_name)
return '0x{:x}'.format(self._sections[elf_name][0][1])
def overlaps(self, section, addr, size):
sec_addr = section[1]
sec_size = section[2]
if not size or not sec_size:
return False
return ((addr <= (sec_addr + sec_size - 1)) and
((addr + size - 1) >= sec_addr))
def sections_in_region(self, addr, size, elf_idx):
ret = ''
addr = self.subtract_load_addr(addr)
if not addr:
return ''
iaddr = int(addr, 16)
isize = int(size, 16)
elf = self._elfs[int(elf_idx)][0]
if elf is None:
return ''
self.read_sections(elf)
if elf not in self._sections:
return ''
for s in self._sections[elf]:
if self.overlaps(s, iaddr, isize):
ret += ' ' + s[0]
return ret
def reset(self):
self._call_stack_found = False
if self._addr2line:
self._addr2line.terminate()
self._addr2line = None
self._addr2line_elf_name = None
self._arch = None
self._saved_abort_line = ''
self._sections = {} # {elf_name: [[name, addr, size], ...], ...}
self._regions = [] # [[addr, size, elf_idx, saved line], ...]
self._elfs = {0: ["tee.elf", 0]} # {idx: [uuid, load_addr], ...}
self._tee_load_addr = '0x0'
self._func_graph_found = False
self._func_graph_skip_line = True
def pretty_print_path(self, path):
if self._strip_path:
return re.sub(re.escape(self._strip_path) + '/*', '', path)
return path
def write(self, line):
if self._call_stack_found:
match = re.search(STACK_ADDR_RE, line)
if match:
addr = match.group('addr')
pre = match.start('addr')
post = match.end('addr')
self._out.write(line[:pre])
self._out.write(addr)
res = self.resolve(addr)
res = self.pretty_print_path(res)
self._out.write(' ' + res)
self._out.write(line[post:])
return
else:
self.reset()
if self._func_graph_found:
match = re.search(GRAPH_ADDR_RE, line)
match_re = re.search(GRAPH_RE, line)
if match:
addr = match.group('addr')
pre = match.start('addr')
post = match.end('addr')
self._out.write(line[:pre])
res = self.resolve(addr)
res_arr = re.split(' ', res)
self._out.write(res_arr[0])
self._out.write(line[post:])
self._func_graph_skip_line = False
return
elif match_re:
self._out.write(line)
return
elif self._func_graph_skip_line:
return
else:
self.reset()
match = re.search(REGION_RE, line)
if match:
# Region table: save info for later processing once
# we know which UUID corresponds to which ELF index
addr = match.group('addr')
size = match.group('size')
elf_idx = match.group('elf_idx')
self._regions.append([addr, size, elf_idx, line])
return
match = re.search(ELF_LIST_RE, line)
if match:
# ELF list: save info for later. Region table and ELF list
# will be displayed when the call stack is reached
i = int(match.group('idx'))
self._elfs[i] = [match.group('uuid'), match.group('load_addr'),
line]
return
match = re.search(TEE_LOAD_ADDR_RE, line)
if match:
self._tee_load_addr = match.group('load_addr')
match = re.search(CALL_STACK_RE, line)
if match:
self._call_stack_found = True
if self._regions:
for r in self._regions:
r_addr = r[0]
r_size = r[1]
elf_idx = r[2]
saved_line = r[3]
if elf_idx is None:
self._out.write(saved_line)
else:
self._out.write(saved_line.strip() +
self.sections_in_region(r_addr,
r_size,
elf_idx) +
'\n')
if self._elfs:
for k in self._elfs:
e = self._elfs[k]
if (len(e) >= 3):
# TA executable or library
self._out.write(e[2].strip())
elf = self.get_elf(e[0])
if elf:
rpath = os.path.realpath(elf)
path = self.pretty_print_path(rpath)
self._out.write(' (' + path + ')')
self._out.write('\n')
# Here is a good place to resolve the abort address because we
# have all the information we need
if self._saved_abort_line:
self._out.write(self.process_abort(self._saved_abort_line))
match = re.search(FUNC_GRAPH_RE, line)
if match:
self._func_graph_found = True
match = re.search(ABORT_ADDR_RE, line)
if match:
self.reset()
# At this point the arch and TA load address are unknown.
# Save the line so We can translate the abort address later.
self._saved_abort_line = line
self._out.write(line)
def flush(self):
self._out.flush()
def main():
args = get_args()
if args.dir:
# Flatten list in case -d is used several times *and* with multiple
# arguments
args.dirs = [item for sublist in args.dir for item in sublist]
else:
args.dirs = []
symbolizer = Symbolizer(sys.stdout, args.dirs, args.strip_path)
fd = sys.stdin.fileno()
isatty = os.isatty(fd)
if isatty:
old = termios.tcgetattr(fd)
new = termios.tcgetattr(fd)
new[3] = new[3] & ~termios.ECHO # lflags
try:
if isatty:
termios.tcsetattr(fd, termios.TCSADRAIN, new)
for line in sys.stdin:
symbolizer.write(line)
finally:
symbolizer.flush()
if isatty:
termios.tcsetattr(fd, termios.TCSADRAIN, old)
if __name__ == "__main__":
main()