OLD | NEW |
(Empty) | |
| 1 #!/usr/bin/env python |
| 2 # |
| 3 # Copyright 2013 The Chromium Authors. All rights reserved. |
| 4 # Use of this source code is governed by a BSD-style license that can be |
| 5 # found in the LICENSE file. |
| 6 # |
| 7 # Find the most recent tombstone file(s) on all connected devices |
| 8 # and prints their stacks. |
| 9 # |
| 10 # Assumes tombstone file was created with current symbols. |
| 11 |
| 12 import datetime |
| 13 import itertools |
| 14 import logging |
| 15 import multiprocessing |
| 16 import os |
| 17 import re |
| 18 import subprocess |
| 19 import sys |
| 20 import optparse |
| 21 |
| 22 from pylib.device import adb_wrapper |
| 23 from pylib.device import device_errors |
| 24 from pylib.device import device_utils |
| 25 from pylib.utils import run_tests_helper |
| 26 |
| 27 |
| 28 _TZ_UTC = {'TZ': 'UTC'} |
| 29 |
| 30 def _ListTombstones(device): |
| 31 """List the tombstone files on the device. |
| 32 |
| 33 Args: |
| 34 device: An instance of DeviceUtils. |
| 35 |
| 36 Yields: |
| 37 Tuples of (tombstone filename, date time of file on device). |
| 38 """ |
| 39 try: |
| 40 lines = device.RunShellCommand( |
| 41 ['ls', '-a', '-l', '/data/tombstones'], |
| 42 as_root=True, check_return=True, env=_TZ_UTC, timeout=60) |
| 43 for line in lines: |
| 44 if 'tombstone' in line and not 'No such file or directory' in line: |
| 45 details = line.split() |
| 46 t = datetime.datetime.strptime(details[-3] + ' ' + details[-2], |
| 47 '%Y-%m-%d %H:%M') |
| 48 yield details[-1], t |
| 49 except device_errors.CommandFailedError: |
| 50 logging.exception('Could not retrieve tombstones.') |
| 51 |
| 52 |
| 53 def _GetDeviceDateTime(device): |
| 54 """Determine the date time on the device. |
| 55 |
| 56 Args: |
| 57 device: An instance of DeviceUtils. |
| 58 |
| 59 Returns: |
| 60 A datetime instance. |
| 61 """ |
| 62 device_now_string = device.RunShellCommand( |
| 63 ['date'], check_return=True, env=_TZ_UTC) |
| 64 return datetime.datetime.strptime( |
| 65 device_now_string[0], '%a %b %d %H:%M:%S %Z %Y') |
| 66 |
| 67 |
| 68 def _GetTombstoneData(device, tombstone_file): |
| 69 """Retrieve the tombstone data from the device |
| 70 |
| 71 Args: |
| 72 device: An instance of DeviceUtils. |
| 73 tombstone_file: the tombstone to retrieve |
| 74 |
| 75 Returns: |
| 76 A list of lines |
| 77 """ |
| 78 return device.ReadFile( |
| 79 '/data/tombstones/' + tombstone_file, as_root=True).splitlines() |
| 80 |
| 81 |
| 82 def _EraseTombstone(device, tombstone_file): |
| 83 """Deletes a tombstone from the device. |
| 84 |
| 85 Args: |
| 86 device: An instance of DeviceUtils. |
| 87 tombstone_file: the tombstone to delete. |
| 88 """ |
| 89 return device.RunShellCommand( |
| 90 ['rm', '/data/tombstones/' + tombstone_file], |
| 91 as_root=True, check_return=True) |
| 92 |
| 93 |
| 94 def _DeviceAbiToArch(device_abi): |
| 95 # The order of this list is significant to find the more specific match (e.g., |
| 96 # arm64) before the less specific (e.g., arm). |
| 97 arches = ['arm64', 'arm', 'x86_64', 'x86_64', 'x86', 'mips'] |
| 98 for arch in arches: |
| 99 if arch in device_abi: |
| 100 return arch |
| 101 raise RuntimeError('Unknown device ABI: %s' % device_abi) |
| 102 |
| 103 def _ResolveSymbols(tombstone_data, include_stack, device_abi): |
| 104 """Run the stack tool for given tombstone input. |
| 105 |
| 106 Args: |
| 107 tombstone_data: a list of strings of tombstone data. |
| 108 include_stack: boolean whether to include stack data in output. |
| 109 device_abi: the default ABI of the device which generated the tombstone. |
| 110 |
| 111 Yields: |
| 112 A string for each line of resolved stack output. |
| 113 """ |
| 114 # Check if the tombstone data has an ABI listed, if so use this in preference |
| 115 # to the device's default ABI. |
| 116 for line in tombstone_data: |
| 117 found_abi = re.search('ABI: \'(.+?)\'', line) |
| 118 if found_abi: |
| 119 device_abi = found_abi.group(1) |
| 120 arch = _DeviceAbiToArch(device_abi) |
| 121 if not arch: |
| 122 return |
| 123 |
| 124 stack_tool = os.path.join(os.path.dirname(__file__), '..', '..', |
| 125 'third_party', 'android_platform', 'development', |
| 126 'scripts', 'stack') |
| 127 proc = subprocess.Popen([stack_tool, '--arch', arch], stdin=subprocess.PIPE, |
| 128 stdout=subprocess.PIPE) |
| 129 output = proc.communicate(input='\n'.join(tombstone_data))[0] |
| 130 for line in output.split('\n'): |
| 131 if not include_stack and 'Stack Data:' in line: |
| 132 break |
| 133 yield line |
| 134 |
| 135 |
| 136 def _ResolveTombstone(tombstone): |
| 137 lines = [] |
| 138 lines += [tombstone['file'] + ' created on ' + str(tombstone['time']) + |
| 139 ', about this long ago: ' + |
| 140 (str(tombstone['device_now'] - tombstone['time']) + |
| 141 ' Device: ' + tombstone['serial'])] |
| 142 logging.info('\n'.join(lines)) |
| 143 logging.info('Resolving...') |
| 144 lines += _ResolveSymbols(tombstone['data'], tombstone['stack'], |
| 145 tombstone['device_abi']) |
| 146 return lines |
| 147 |
| 148 |
| 149 def _ResolveTombstones(jobs, tombstones): |
| 150 """Resolve a list of tombstones. |
| 151 |
| 152 Args: |
| 153 jobs: the number of jobs to use with multiprocess. |
| 154 tombstones: a list of tombstones. |
| 155 """ |
| 156 if not tombstones: |
| 157 logging.warning('No tombstones to resolve.') |
| 158 return |
| 159 if len(tombstones) == 1: |
| 160 data = [_ResolveTombstone(tombstones[0])] |
| 161 else: |
| 162 pool = multiprocessing.Pool(processes=jobs) |
| 163 data = pool.map(_ResolveTombstone, tombstones) |
| 164 for tombstone in data: |
| 165 for line in tombstone: |
| 166 logging.info(line) |
| 167 |
| 168 |
| 169 def _GetTombstonesForDevice(device, options): |
| 170 """Returns a list of tombstones on a given device. |
| 171 |
| 172 Args: |
| 173 device: An instance of DeviceUtils. |
| 174 options: command line arguments from OptParse |
| 175 """ |
| 176 ret = [] |
| 177 all_tombstones = list(_ListTombstones(device)) |
| 178 if not all_tombstones: |
| 179 logging.warning('No tombstones.') |
| 180 return ret |
| 181 |
| 182 # Sort the tombstones in date order, descending |
| 183 all_tombstones.sort(cmp=lambda a, b: cmp(b[1], a[1])) |
| 184 |
| 185 # Only resolve the most recent unless --all-tombstones given. |
| 186 tombstones = all_tombstones if options.all_tombstones else [all_tombstones[0]] |
| 187 |
| 188 device_now = _GetDeviceDateTime(device) |
| 189 try: |
| 190 for tombstone_file, tombstone_time in tombstones: |
| 191 ret += [{'serial': str(device), |
| 192 'device_abi': device.product_cpu_abi, |
| 193 'device_now': device_now, |
| 194 'time': tombstone_time, |
| 195 'file': tombstone_file, |
| 196 'stack': options.stack, |
| 197 'data': _GetTombstoneData(device, tombstone_file)}] |
| 198 except device_errors.CommandFailedError: |
| 199 for line in device.RunShellCommand( |
| 200 ['ls', '-a', '-l', '/data/tombstones'], |
| 201 as_root=True, check_return=True, env=_TZ_UTC, timeout=60): |
| 202 logging.info('%s: %s', str(device), line) |
| 203 raise |
| 204 |
| 205 # Erase all the tombstones if desired. |
| 206 if options.wipe_tombstones: |
| 207 for tombstone_file, _ in all_tombstones: |
| 208 _EraseTombstone(device, tombstone_file) |
| 209 |
| 210 return ret |
| 211 |
| 212 |
| 213 def main(): |
| 214 custom_handler = logging.StreamHandler(sys.stdout) |
| 215 custom_handler.setFormatter(run_tests_helper.CustomFormatter()) |
| 216 logging.getLogger().addHandler(custom_handler) |
| 217 logging.getLogger().setLevel(logging.INFO) |
| 218 |
| 219 parser = optparse.OptionParser() |
| 220 parser.add_option('--device', |
| 221 help='The serial number of the device. If not specified ' |
| 222 'will use all devices.') |
| 223 parser.add_option('-a', '--all-tombstones', action='store_true', |
| 224 help="""Resolve symbols for all tombstones, rather than just |
| 225 the most recent""") |
| 226 parser.add_option('-s', '--stack', action='store_true', |
| 227 help='Also include symbols for stack data') |
| 228 parser.add_option('-w', '--wipe-tombstones', action='store_true', |
| 229 help='Erase all tombstones from device after processing') |
| 230 parser.add_option('-j', '--jobs', type='int', |
| 231 default=4, |
| 232 help='Number of jobs to use when processing multiple ' |
| 233 'crash stacks.') |
| 234 options, _ = parser.parse_args() |
| 235 |
| 236 if options.device: |
| 237 devices = [device_utils.DeviceUtils(options.device)] |
| 238 else: |
| 239 devices = device_utils.DeviceUtils.HealthyDevices() |
| 240 |
| 241 # This must be done serially because strptime can hit a race condition if |
| 242 # used for the first time in a multithreaded environment. |
| 243 # http://bugs.python.org/issue7980 |
| 244 tombstones = [] |
| 245 for device in devices: |
| 246 tombstones += _GetTombstonesForDevice(device, options) |
| 247 |
| 248 _ResolveTombstones(options.jobs, tombstones) |
| 249 |
| 250 |
| 251 if __name__ == '__main__': |
| 252 sys.exit(main()) |
OLD | NEW |