| #!/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, |
| universal_newlines=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, elf): |
| self._arch = os.getenv('CROSS_COMPILE') |
| if self._arch: |
| return |
| p = subprocess.Popen(['file', '-L', elf], 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, elf): |
| self.set_arch(elf) |
| 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', elf) |
| if not cmd: |
| return |
| self._addr2line = self.my_Popen([cmd, '-f', '-p', '-e', elf]) |
| self._addr2line_elf_name = elf_name |
| |
| # 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', elf) |
| 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', elf) |
| 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) |
| if not elf: |
| return |
| cmd = self.arch_prefix('objdump', elf) |
| 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) |
| # The call stack contains return addresses (LR/ELR values). |
| # Heuristic: subtract 2 to obtain the call site of the function |
| # or the location of the exception. This value works for A64, |
| # A32 as well as Thumb. |
| pc = 0 |
| lr = int(addr, 16) |
| if lr: |
| pc = lr - 2 |
| res = self.resolve('0x{:x}'.format(pc)) |
| 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() |
