| #!/usr/bin/env python |
| # |
| # Copyright 2013 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. |
| # |
| # Find the most recent tombstone file(s) on all connected devices |
| # and prints their stacks. |
| # |
| # Assumes tombstone file was created with current symbols. |
| |
| import argparse |
| import datetime |
| import logging |
| import os |
| import sys |
| |
| from multiprocessing.pool import ThreadPool |
| |
| import devil_chromium |
| |
| from devil.android import device_blacklist |
| from devil.android import device_errors |
| from devil.android import device_utils |
| from devil.utils import run_tests_helper |
| from pylib import constants |
| from pylib.symbols import stack_symbolizer |
| |
| |
| _TZ_UTC = {'TZ': 'UTC'} |
| |
| |
| def _ListTombstones(device): |
| """List the tombstone files on the device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| |
| Yields: |
| Tuples of (tombstone filename, date time of file on device). |
| """ |
| try: |
| if not device.PathExists('/data/tombstones', as_root=True): |
| return |
| entries = device.StatDirectory('/data/tombstones', as_root=True) |
| for entry in entries: |
| if 'tombstone' in entry['filename']: |
| yield (entry['filename'], |
| datetime.datetime.fromtimestamp(entry['st_mtime'])) |
| except device_errors.CommandFailedError: |
| logging.exception('Could not retrieve tombstones.') |
| except device_errors.DeviceUnreachableError: |
| logging.exception('Device unreachable retrieving tombstones.') |
| except device_errors.CommandTimeoutError: |
| logging.exception('Timed out retrieving tombstones.') |
| |
| |
| def _GetDeviceDateTime(device): |
| """Determine the date time on the device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| |
| Returns: |
| A datetime instance. |
| """ |
| device_now_string = device.RunShellCommand( |
| ['date'], check_return=True, env=_TZ_UTC) |
| return datetime.datetime.strptime( |
| device_now_string[0], '%a %b %d %H:%M:%S %Z %Y') |
| |
| |
| def _GetTombstoneData(device, tombstone_file): |
| """Retrieve the tombstone data from the device |
| |
| Args: |
| device: An instance of DeviceUtils. |
| tombstone_file: the tombstone to retrieve |
| |
| Returns: |
| A list of lines |
| """ |
| return device.ReadFile( |
| '/data/tombstones/' + tombstone_file, as_root=True).splitlines() |
| |
| |
| def _EraseTombstone(device, tombstone_file): |
| """Deletes a tombstone from the device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| tombstone_file: the tombstone to delete. |
| """ |
| return device.RunShellCommand( |
| ['rm', '/data/tombstones/' + tombstone_file], |
| as_root=True, check_return=True) |
| |
| |
| def _ResolveTombstone(args): |
| tombstone = args[0] |
| tombstone_symbolizer = args[1] |
| lines = [] |
| lines += [tombstone['file'] + ' created on ' + str(tombstone['time']) + |
| ', about this long ago: ' + |
| (str(tombstone['device_now'] - tombstone['time']) + |
| ' Device: ' + tombstone['serial'])] |
| logging.info('\n'.join(lines)) |
| logging.info('Resolving...') |
| lines += tombstone_symbolizer.ExtractAndResolveNativeStackTraces( |
| tombstone['data'], |
| tombstone['device_abi'], |
| tombstone['stack']) |
| return lines |
| |
| |
| def _ResolveTombstones(jobs, tombstones, tombstone_symbolizer): |
| """Resolve a list of tombstones. |
| |
| Args: |
| jobs: the number of jobs to use with multithread. |
| tombstones: a list of tombstones. |
| """ |
| if not tombstones: |
| logging.warning('No tombstones to resolve.') |
| return [] |
| if len(tombstones) == 1: |
| data = [_ResolveTombstone([tombstones[0], tombstone_symbolizer])] |
| else: |
| pool = ThreadPool(jobs) |
| data = pool.map( |
| _ResolveTombstone, |
| [[tombstone, tombstone_symbolizer] for tombstone in tombstones]) |
| pool.close() |
| pool.join() |
| resolved_tombstones = [] |
| for tombstone in data: |
| resolved_tombstones.extend(tombstone) |
| return resolved_tombstones |
| |
| |
| def _GetTombstonesForDevice(device, resolve_all_tombstones, |
| include_stack_symbols, |
| wipe_tombstones): |
| """Returns a list of tombstones on a given device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| resolve_all_tombstone: Whether to resolve every tombstone. |
| include_stack_symbols: Whether to include symbols for stack data. |
| wipe_tombstones: Whether to wipe tombstones. |
| """ |
| ret = [] |
| all_tombstones = list(_ListTombstones(device)) |
| if not all_tombstones: |
| logging.warning('No tombstones.') |
| return ret |
| |
| # Sort the tombstones in date order, descending |
| all_tombstones.sort(cmp=lambda a, b: cmp(b[1], a[1])) |
| |
| # Only resolve the most recent unless --all-tombstones given. |
| tombstones = all_tombstones if resolve_all_tombstones else [all_tombstones[0]] |
| |
| device_now = _GetDeviceDateTime(device) |
| try: |
| for tombstone_file, tombstone_time in tombstones: |
| ret += [{'serial': str(device), |
| 'device_abi': device.product_cpu_abi, |
| 'device_now': device_now, |
| 'time': tombstone_time, |
| 'file': tombstone_file, |
| 'stack': include_stack_symbols, |
| 'data': _GetTombstoneData(device, tombstone_file)}] |
| except device_errors.CommandFailedError: |
| for entry in device.StatDirectory( |
| '/data/tombstones', as_root=True, timeout=60): |
| logging.info('%s: %s', str(device), entry) |
| raise |
| |
| # Erase all the tombstones if desired. |
| if wipe_tombstones: |
| for tombstone_file, _ in all_tombstones: |
| _EraseTombstone(device, tombstone_file) |
| |
| return ret |
| |
| |
| def ClearAllTombstones(device): |
| """Clear all tombstones in the device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| """ |
| all_tombstones = list(_ListTombstones(device)) |
| if not all_tombstones: |
| logging.warning('No tombstones to clear.') |
| |
| for tombstone_file, _ in all_tombstones: |
| _EraseTombstone(device, tombstone_file) |
| |
| |
| def ResolveTombstones(device, resolve_all_tombstones, include_stack_symbols, |
| wipe_tombstones, jobs=4, apk_under_test=None, |
| tombstone_symbolizer=None): |
| """Resolve tombstones in the device. |
| |
| Args: |
| device: An instance of DeviceUtils. |
| resolve_all_tombstone: Whether to resolve every tombstone. |
| include_stack_symbols: Whether to include symbols for stack data. |
| wipe_tombstones: Whether to wipe tombstones. |
| jobs: Number of jobs to use when processing multiple crash stacks. |
| |
| Returns: |
| A list of resolved tombstones. |
| """ |
| return _ResolveTombstones(jobs, |
| _GetTombstonesForDevice(device, |
| resolve_all_tombstones, |
| include_stack_symbols, |
| wipe_tombstones), |
| (tombstone_symbolizer |
| or stack_symbolizer.Symbolizer(apk_under_test))) |
| |
| |
| def main(): |
| custom_handler = logging.StreamHandler(sys.stdout) |
| custom_handler.setFormatter(run_tests_helper.CustomFormatter()) |
| logging.getLogger().addHandler(custom_handler) |
| logging.getLogger().setLevel(logging.INFO) |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument('--device', |
| help='The serial number of the device. If not specified ' |
| 'will use all devices.') |
| parser.add_argument('--blacklist-file', help='Device blacklist JSON file.') |
| parser.add_argument('-a', '--all-tombstones', action='store_true', |
| help='Resolve symbols for all tombstones, rather than ' |
| 'just the most recent.') |
| parser.add_argument('-s', '--stack', action='store_true', |
| help='Also include symbols for stack data') |
| parser.add_argument('-w', '--wipe-tombstones', action='store_true', |
| help='Erase all tombstones from device after processing') |
| parser.add_argument('-j', '--jobs', type=int, |
| default=4, |
| help='Number of jobs to use when processing multiple ' |
| 'crash stacks.') |
| parser.add_argument('--output-directory', |
| help='Path to the root build directory.') |
| parser.add_argument('--adb-path', type=os.path.abspath, |
| help='Path to the adb binary.') |
| args = parser.parse_args() |
| |
| devil_chromium.Initialize(adb_path=args.adb_path) |
| |
| blacklist = (device_blacklist.Blacklist(args.blacklist_file) |
| if args.blacklist_file |
| else None) |
| |
| if args.output_directory: |
| constants.SetOutputDirectory(args.output_directory) |
| # Do an up-front test that the output directory is known. |
| constants.CheckOutputDirectory() |
| |
| if args.device: |
| devices = [device_utils.DeviceUtils(args.device)] |
| else: |
| devices = device_utils.DeviceUtils.HealthyDevices(blacklist) |
| |
| # This must be done serially because strptime can hit a race condition if |
| # used for the first time in a multithreaded environment. |
| # http://bugs.python.org/issue7980 |
| for device in devices: |
| resolved_tombstones = ResolveTombstones( |
| device, args.all_tombstones, |
| args.stack, args.wipe_tombstones, args.jobs) |
| for line in resolved_tombstones: |
| logging.info(line) |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |