build/android/tombstones.py - chromium/src - Git at Google

 #!/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())
	#!/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())