| # Copyright 2018 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import logging |
| import os |
| import re |
| import subprocess |
| |
| # Matches the coarse syntax of a backtrace entry. |
| _BACKTRACE_PREFIX_RE = re.compile(r'(\[[0-9.]+\] )?bt#(?P<frame_id>\d+): ') |
| |
| # Matches the specific fields of a backtrace entry. |
| # Back-trace line matcher/parser assumes that 'pc' is always present, and |
| # expects that 'sp' and ('binary','pc_offset') may also be provided. |
| _BACKTRACE_ENTRY_RE = re.compile( |
| r'pc 0(?:x[0-9a-f]+)?' + |
| r'(?: sp 0x[0-9a-f]+)?' + |
| r'(?: \((?P<binary>\S+),(?P<pc_offset>0x[0-9a-f]+)\))?$') |
| |
| |
| def _GetUnstrippedPath(path): |
| """If there is a binary located at |path|, returns a path to its unstripped |
| source. |
| |
| Returns None if |path| isn't a binary or doesn't exist in the lib.unstripped |
| or exe.unstripped directories.""" |
| |
| if path.endswith('.so'): |
| maybe_unstripped_path = os.path.normpath( |
| os.path.join(path, os.path.pardir, 'lib.unstripped', |
| os.path.basename(path))) |
| else: |
| maybe_unstripped_path = os.path.normpath( |
| os.path.join(path, os.path.pardir, 'exe.unstripped', |
| os.path.basename(path))) |
| |
| if not os.path.exists(maybe_unstripped_path): |
| return None |
| |
| with open(maybe_unstripped_path, 'rb') as f: |
| file_tag = f.read(4) |
| if file_tag != '\x7fELF': |
| logging.warn('Expected an ELF binary: ' + maybe_unstripped_path) |
| return None |
| |
| return maybe_unstripped_path |
| |
| |
| def FilterStream(stream, package_name, manifest_path, output_dir): |
| """Looks for backtrace lines from an iterable |stream| and symbolizes them. |
| Yields a stream of strings with symbolized entries replaced.""" |
| |
| return _SymbolizerFilter(package_name, |
| manifest_path, |
| output_dir).SymbolizeStream(stream) |
| |
| |
| class _SymbolizerFilter(object): |
| """Adds backtrace symbolization capabilities to a process output stream.""" |
| |
| def __init__(self, package_name, manifest_path, output_dir): |
| self._symbols_mapping = {} |
| self._output_dir = output_dir |
| self._package_name = package_name |
| |
| # Compute remote/local path mappings using the manifest data. |
| for next_line in open(manifest_path): |
| target, source = next_line.strip().split('=') |
| stripped_binary_path = _GetUnstrippedPath(os.path.join(output_dir, |
| source)) |
| if not stripped_binary_path: |
| continue |
| |
| self._symbols_mapping[os.path.basename(target)] = stripped_binary_path |
| self._symbols_mapping[target] = stripped_binary_path |
| if target == 'bin/app': |
| self._symbols_mapping[package_name] = stripped_binary_path |
| logging.debug('Symbols: %s -> %s' % (source, target)) |
| |
| def _SymbolizeEntries(self, entries): |
| """Symbolizes the parsed backtrace |entries| by calling addr2line. |
| |
| Returns a set of (frame_id, result) pairs.""" |
| |
| filename_re = re.compile(r'at ([-._a-zA-Z0-9/+]+):(\d+)') |
| |
| # Use addr2line to symbolize all the |pc_offset|s in |entries| in one go. |
| # Entries with no |debug_binary| are also processed here, so that we get |
| # consistent output in that case, with the cannot-symbolize case. |
| addr2line_output = None |
| if entries[0].has_key('debug_binary'): |
| addr2line_args = (['addr2line', '-Cipf', '-p', |
| '--exe=' + entries[0]['debug_binary']] + |
| map(lambda entry: entry['pc_offset'], entries)) |
| addr2line_output = subprocess.check_output(addr2line_args).splitlines() |
| assert addr2line_output |
| |
| results = {} |
| for entry in entries: |
| raw, frame_id = entry['raw'], entry['frame_id'] |
| prefix = '#%s: ' % frame_id |
| |
| if not addr2line_output: |
| # Either there was no addr2line output, or too little of it. |
| filtered_line = raw |
| else: |
| output_line = addr2line_output.pop(0) |
| |
| # Relativize path to the current working (output) directory if we see |
| # a filename. |
| def RelativizePath(m): |
| relpath = os.path.relpath(os.path.normpath(m.group(1))) |
| return 'at ' + relpath + ':' + m.group(2) |
| filtered_line = filename_re.sub(RelativizePath, output_line) |
| |
| if '??' in filtered_line.split(): |
| # If symbolization fails just output the raw backtrace. |
| filtered_line = raw |
| else: |
| # Release builds may inline things, resulting in "(inlined by)" lines. |
| inlined_by_prefix = " (inlined by)" |
| while (addr2line_output and |
| addr2line_output[0].startswith(inlined_by_prefix)): |
| inlined_by_line = \ |
| '\n' + (' ' * len(prefix)) + addr2line_output.pop(0) |
| filtered_line += filename_re.sub(RelativizePath, inlined_by_line) |
| |
| results[entry['frame_id']] = prefix + filtered_line |
| |
| return results |
| |
| def _LookupDebugBinary(self, entry): |
| """Looks up the binary listed in |entry| in the |_symbols_mapping|. |
| Returns the corresponding host-side binary's filename, or None.""" |
| |
| binary = entry['binary'] |
| if not binary: |
| return None |
| |
| app_prefix = 'app:' |
| if binary.startswith(app_prefix): |
| binary = binary[len(app_prefix):] |
| |
| # We change directory into /system/ before running the target executable, so |
| # all paths are relative to "/system/", and will typically start with "./". |
| # Some crashes still uses the full filesystem path, so cope with that, too. |
| pkg_prefix = '/pkg/' |
| cwd_prefix = './' |
| if binary.startswith(cwd_prefix): |
| binary = binary[len(cwd_prefix):] |
| elif binary.startswith(pkg_prefix): |
| binary = binary[len(pkg_prefix):] |
| # Allow other paths to pass-through; sometimes neither prefix is present. |
| |
| if binary in self._symbols_mapping: |
| return self._symbols_mapping[binary] |
| |
| # |binary| may be truncated by the crashlogger, so if there is a unique |
| # match for the truncated name in |symbols_mapping|, use that instead. |
| matches = filter(lambda x: x.startswith(binary), |
| self._symbols_mapping.keys()) |
| if len(matches) == 1: |
| return self._symbols_mapping[matches[0]] |
| |
| return None |
| |
| def _SymbolizeBacktrace(self, backtrace): |
| """Group |backtrace| entries according to the associated binary, and locate |
| the path to the debug symbols for that binary, if any.""" |
| |
| batches = {} |
| |
| for entry in backtrace: |
| debug_binary = self._LookupDebugBinary(entry) |
| if debug_binary: |
| entry['debug_binary'] = debug_binary |
| batches.setdefault(debug_binary, []).append(entry) |
| |
| # Run _SymbolizeEntries on each batch and collate the results. |
| symbolized = {} |
| for batch in batches.itervalues(): |
| symbolized.update(self._SymbolizeEntries(batch)) |
| |
| # Map each entry to its symbolized form, by frame-id, and return the list. |
| return map(lambda entry: symbolized[entry['frame_id']], backtrace) |
| |
| def SymbolizeStream(self, stream): |
| """Creates a symbolized logging stream object using the output from |
| |stream|.""" |
| |
| # A buffer of backtrace entries awaiting symbolization, stored as dicts: |
| # raw: The original back-trace line that followed the prefix. |
| # frame_id: backtrace frame number (starting at 0). |
| # binary: path to executable code corresponding to the current frame. |
| # pc_offset: memory offset within the executable. |
| backtrace_entries = [] |
| |
| # Read from the stream until we hit EOF. |
| for line in stream: |
| line = line.rstrip() |
| |
| # Look for the back-trace prefix, otherwise just emit the line. |
| matched = _BACKTRACE_PREFIX_RE.match(line) |
| if not matched: |
| yield line |
| continue |
| backtrace_line = line[matched.end():] |
| |
| # If this was the end of a back-trace then symbolize and emit it. |
| frame_id = matched.group('frame_id') |
| if backtrace_line == 'end': |
| if backtrace_entries: |
| for processed in self._SymbolizeBacktrace(backtrace_entries): |
| yield processed |
| backtrace_entries = [] |
| continue |
| |
| # Parse the program-counter offset, etc into |backtrace_entries|. |
| matched = _BACKTRACE_ENTRY_RE.match(backtrace_line) |
| if matched: |
| # |binary| and |pc_offset| will be None if not present. |
| backtrace_entries.append( |
| {'raw': backtrace_line, 'frame_id': frame_id, |
| 'binary': matched.group('binary'), |
| 'pc_offset': matched.group('pc_offset')}) |
| else: |
| backtrace_entries.append( |
| {'raw': backtrace_line, 'frame_id': frame_id, |
| 'binary': None, 'pc_offset': None}) |
