| #!/usr/bin/python |
| # Copyright (c) 2011 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. |
| |
| """A tool to collect crash signatures for Chrome builds on Linux.""" |
| |
| import fnmatch |
| import optparse |
| import os |
| import shutil |
| import subprocess |
| import struct |
| import sys |
| import tempfile |
| |
| |
| def VerifySymbolAndCopyToTempDir(symbol_file, temp_dir, sym_module_name): |
| """Verify the symbol file looks correct and copy it to the right place |
| in temp_dir. |
| |
| Args: |
| symbol_file: the path to the symbol file. |
| temp_dir: the base of the temp directory where the symbol file will reside. |
| Returns: |
| True on success. |
| """ |
| symbol = open(symbol_file) |
| signature_line = symbol.readline().strip().split() |
| symbol.close() |
| # signature_line should look like: |
| # MODULE Linux x86 28D8A79A426807B5462CBA24F56746750 chrome |
| if (len(signature_line) == 5 and signature_line[0] == 'MODULE' and |
| signature_line[1] == 'Linux' and signature_line[4] == sym_module_name and |
| len(signature_line[3]) == 33): |
| dest = os.path.join(temp_dir, signature_line[4], signature_line[3]) |
| os.makedirs(dest) |
| dest_file = os.path.join(dest, '%s.sym' % signature_line[4]) |
| shutil.copyfile(symbol_file, dest_file) |
| return True |
| return False |
| |
| |
| def GetCommandOutput(command): |
| """Runs the command list, returning its output. |
| |
| Prints the given command (which should be a list of one or more strings), |
| then runs it and returns its output (stdout and stderr) as a string. |
| |
| If the command exits with an error, raises OSError. |
| |
| From chromium_utils. |
| """ |
| proc = subprocess.Popen(command, stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, bufsize=1) |
| output = proc.communicate()[0] |
| if proc.returncode: |
| raise OSError('%s: %s' % (subprocess.list2cmdline(command), output)) |
| return output |
| |
| |
| def GetCrashDumpDir(): |
| """Returns the default crash dump directory used by Chromium.""" |
| config_home = os.environ.get('XDG_CONFIG_HOME') |
| if not config_home: |
| home = os.path.expanduser('~') |
| if not home: |
| return '' |
| config_home = os.path.join(home, '.config') |
| return os.path.join(config_home, 'chromium', 'Crash Reports') |
| |
| |
| def GetStackTrace(processor_bin, symbol_path, dump_file): |
| """Gets and prints the stack trace from a crash dump file. |
| |
| Args: |
| processor_bin: the path to the processor. |
| symbol_path: root dir for the symbols. |
| dump_file: the path to the dump file. |
| Returns: |
| A string representing the stack trace. |
| """ |
| # Run processor to analyze crash dump. |
| cmd = [processor_bin, '-m', dump_file, symbol_path] |
| |
| try: |
| output = GetCommandOutput(cmd) |
| except OSError: |
| return 'Cannot get stack trace.' |
| |
| # Retrieve stack trace from processor output. Processor output looks like: |
| # ---------------- |
| # Debug output |
| # ... |
| # Debug output |
| # Module ... |
| # ... |
| # Module ... |
| # |
| # N|... <--+ |
| # ... |--- crashed thread stack trace |
| # N|... <--+ |
| # M|... |
| # ... |
| # ---------------- |
| # where each line of the stack trace looks like: |
| # ThreadNumber|FrameNumber|ExeName|Function|SourceFile|LineNo|Offset |
| |
| stack_trace_frames = [] |
| idx = output.find('\nModule') |
| if idx >= 0: |
| output = output[idx+1:] |
| idx = output.find('\n\n') |
| if idx >= 0: |
| output = output[idx+2:].splitlines() |
| if output: |
| first_line = output[0].split('|') |
| if first_line: |
| crashed_thread = first_line[0] |
| for line in output: |
| line_split = line.split('|') |
| if not line_split: |
| break |
| if line_split[0] != crashed_thread: |
| break |
| stack_trace_frames.append(line_split) |
| if not stack_trace_frames: |
| return 'Cannot get stack trace.' |
| stack_trace = [] |
| for frame in stack_trace_frames: |
| if len(frame) != 7: |
| continue |
| (exe, func, source, line, offset) = frame[2:] |
| if not exe or not source or not line or not offset: |
| continue |
| idx = func.find('(') |
| if idx >= 0: |
| func = func[:idx] |
| if not func: |
| continue |
| frame_output = '%s!%s+%s [%s @ %s]' % (exe, func, offset, source, line) |
| stack_trace.append(frame_output) |
| return '\n'.join(stack_trace) |
| |
| |
| def LocateFiles(pattern, root=os.curdir): |
| """Yields files matching pattern found in root and its subdirectories. |
| |
| An exception is thrown if root doesn't exist. |
| |
| From chromium_utils.""" |
| root = os.path.expanduser(root) |
| for path, dirs, files in os.walk(os.path.abspath(root)): |
| for filename in fnmatch.filter(files, pattern): |
| yield os.path.join(path, filename) |
| |
| |
| def ProcessDump(dump_file, temp_dir): |
| """Extracts the part of the dump file that minidump_stackwalk can read. |
| |
| Args: |
| dump_file: the dump file that needs to be processed. |
| temp_dir: the temp directory to put the dump file in. |
| Returns: |
| path of the processed dump file. |
| """ |
| dump = open(dump_file, 'rb') |
| dump_data = dump.read() |
| dump.close() |
| idx = dump_data.find('MDMP') |
| if idx < 0: |
| return '' |
| |
| dump_data = dump_data[idx:] |
| if not dump_data: |
| return '' |
| (dump_fd, dump_name) = tempfile.mkstemp(suffix='chromedump', dir=temp_dir) |
| os.write(dump_fd, dump_data) |
| os.close(dump_fd) |
| return dump_name |
| |
| |
| def main_linux(options, args): |
| # minidump_stackwalk is part of Google Breakpad. You may need to checkout |
| # the code and build your own copy. http://google-breakpad.googlecode.com/ |
| LINUX_PROCESSOR = 'minidump_stackwalk' |
| processor_bin = None |
| if options.processor_dir: |
| bin = os.path.join(os.path.expanduser(options.processor_dir), |
| LINUX_PROCESSOR) |
| if os.access(bin, os.X_OK): |
| processor_bin = bin |
| else: |
| for path in os.environ['PATH'].split(':'): |
| bin = os.path.join(path, LINUX_PROCESSOR) |
| if os.access(bin, os.X_OK): |
| processor_bin = bin |
| break |
| if not processor_bin: |
| print 'Cannot find minidump_stackwalk.' |
| return 1 |
| |
| if options.symbol_filename: |
| symbol_file = options.symbol_filename |
| else: |
| if options.architecture: |
| bits = options.architecture |
| else: |
| bits = struct.calcsize('P') * 8 |
| if bits == 32: |
| symbol_file = 'chrome.breakpad.ia32' |
| elif bits == 64: |
| symbol_file = 'chrome.breakpad.x64' |
| else: |
| print 'Unknown architecture' |
| return 1 |
| |
| symbol_dir = options.symbol_dir |
| if not options.symbol_dir: |
| symbol_dir = os.curdir |
| symbol_dir = os.path.abspath(os.path.expanduser(symbol_dir)) |
| symbol_file = os.path.join(symbol_dir, symbol_file) |
| if not os.path.exists(symbol_file): |
| print 'Cannot find symbols.' |
| return 1 |
| symbol_time = os.path.getmtime(symbol_file) |
| |
| dump_files = [] |
| if options.dump_file: |
| dump_files.append(options.dump_file) |
| else: |
| dump_dir = options.dump_dir |
| if not dump_dir: |
| dump_dir = GetCrashDumpDir() |
| if not dump_dir: |
| print 'Cannot find dump files.' |
| return 1 |
| for dump_file in LocateFiles(pattern='*.dmp', root=dump_dir): |
| file_time = os.path.getmtime(dump_file) |
| if file_time < symbol_time: |
| # Ignore dumps older than symbol file. |
| continue |
| dump_files.append(dump_file) |
| |
| temp_dir = tempfile.mkdtemp(suffix='chromedump') |
| if not VerifySymbolAndCopyToTempDir(symbol_file, temp_dir, |
| options.sym_module_name): |
| print 'Cannot parse symbols.' |
| shutil.rmtree(temp_dir) |
| return 1 |
| |
| dump_count = 0 |
| for dump_file in dump_files: |
| processed_dump_file = ProcessDump(dump_file, temp_dir) |
| if not processed_dump_file: |
| continue |
| print '-------------------------' |
| print GetStackTrace(processor_bin, temp_dir, processed_dump_file) |
| print |
| os.remove(processed_dump_file) |
| dump_count += 1 |
| |
| shutil.rmtree(temp_dir) |
| print '%s dumps found' % dump_count |
| return 0 |
| |
| |
| if '__main__' == __name__: |
| parser = optparse.OptionParser() |
| parser.add_option('', '--processor-dir', type='string', default='', |
| help='The directory where the processor is installed. ' |
| 'The processor is used to get stack trace from dumps. ' |
| 'Searches $PATH by default') |
| parser.add_option('', '--dump-file', type='string', default='', |
| help='The path of the dump file to be processed. ' |
| 'Overwrites dump-path.') |
| parser.add_option('', '--dump-dir', type='string', default='', |
| help='The directory where dump files are stored. ' |
| 'Searches this directory if dump-file is not ' |
| 'specified. Default is the Chromium crash directory.') |
| parser.add_option('', '--symbol-dir', default='', |
| help='The directory with the symbols file. [Required]') |
| parser.add_option('', '--symbol-filename', default='', |
| help='The name of the symbols file to use. ' |
| 'This argument overrides --architecture.') |
| parser.add_option('', '--architecture', type='int', default=None, |
| help='Override automatic x86/x86-64 detection. ' |
| 'Valid values are 32 and 64') |
| parser.add_option('', '--sym-module-name', type='string', default='chrome', |
| help='The module name for the symbol file. ' |
| 'Default: chrome') |
| |
| (options, args) = parser.parse_args() |
| |
| if sys.platform.startswith('linux'): |
| sys.exit(main_linux(options, args)) |
| else: |
| sys.exit(1) |
