| #!/usr/bin/env python |
| # |
| # Copyright (C) 2013 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """stack symbolizes native crash dumps.""" |
| |
| import getopt |
| import glob |
| import os |
| import re |
| import sys |
| |
| import stack_core |
| import subprocess |
| import symbol |
| |
| _DEFAULT_SYMROOT = '/tmp/symbols' |
| _DEFAULT_BUILD_DIR = 'out/android_Debug' |
| _DEFAULT_NDK_DIR = 'third_party/android_tools/ndk' |
| |
| |
| def PrintUsage(): |
| """Print usage and exit with error.""" |
| # pylint: disable-msg=C6310 |
| print |
| print " usage: " + sys.argv[0] + " [options] [FILE]" |
| print |
| print " --symbols-dir=path" |
| print " the path to a symbols dir, this is generally for system level" |
| print " symbols" |
| print |
| print " --build-dir=path" |
| print " the path to a directory containing Mojo symbols (can be" |
| print " absolute or relative to src), such as =out/android_Debug" |
| |
| print " --ndk-dir=path" |
| print " the path to a directory containing Android NDK" |
| print |
| print " --symbols-zip=path" |
| print " the path to a symbols zip file, such as =dream-symbols-12345.zip" |
| print |
| print " --more-info" |
| print " --less-info" |
| print " Change the level of detail in the output." |
| print " --more-info is slower and more verbose, but more functions will" |
| print " be fully qualified with namespace/classname and have full" |
| print " argument information. Also, the 'stack data' section will be" |
| print " printed." |
| print |
| print " --arch=arm|arm64|x64|x86|mips" |
| print " the target architecture" |
| print |
| print " FILE should contain a stack trace in it somewhere" |
| print " the tool will find that and re-print it with" |
| print " source files and line numbers. If you don't" |
| print " pass FILE, or if file is -, it reads from" |
| print " stdin." |
| print |
| # pylint: enable-msg=C6310 |
| sys.exit(1) |
| |
| def UnzipSymbols(symbolfile, symdir=None): |
| """Unzips a file to _DEFAULT_SYMROOT and returns the unzipped location. |
| |
| Args: |
| symbolfile: The .zip file to unzip |
| symdir: Optional temporary directory to use for extraction |
| |
| Returns: |
| A tuple containing (the directory into which the zip file was unzipped, |
| the path to the "symbols" directory in the unzipped file). To clean |
| up, the caller can delete the first element of the tuple. |
| |
| Raises: |
| SymbolDownloadException: When the unzip fails. |
| """ |
| if not symdir: |
| symdir = "%s/%s" % (_DEFAULT_SYMROOT, hash(symbolfile)) |
| if not os.path.exists(symdir): |
| os.makedirs(symdir) |
| |
| print "extracting %s..." % symbolfile |
| saveddir = os.getcwd() |
| os.chdir(symdir) |
| try: |
| unzipcode = subprocess.call(["unzip", "-qq", "-o", symbolfile]) |
| if unzipcode > 0: |
| os.remove(symbolfile) |
| raise SymbolDownloadException("failed to extract symbol files (%s)." |
| % symbolfile) |
| finally: |
| os.chdir(saveddir) |
| |
| android_symbols = glob.glob("%s/out/target/product/*/symbols" % symdir) |
| if android_symbols: |
| return (symdir, android_symbols[0]) |
| else: |
| # This is a zip of Chrome symbols, so symbol.CHROME_SYMBOLS_DIR needs to be |
| # updated to point here. |
| symbol.CHROME_SYMBOLS_DIR = symdir |
| return (symdir, symdir) |
| |
| |
| def GetBasenameFromMojoApp(url): |
| """Used by GetSymbolMapping() to extract the basename from the location the |
| mojo app was downloaded from. The location is a URL, e.g. |
| http://foo/bar/x.so.""" |
| index = url.rfind('/') |
| return url[(index + 1):] if index != -1 else url |
| |
| |
| def GetSymboledNameForMojoApp(path): |
| """Used by GetSymbolMapping to get the non-stripped library name for an |
| installed mojo app.""" |
| # e.g. tracing.mojo -> libtracing_library.so |
| name, ext = os.path.splitext(path) |
| if ext != '.mojo': |
| return path |
| return 'lib%s_library.so' % name |
| |
| |
| def GetSymbolMapping(lines): |
| """Returns a mapping (dictionary) from download file to .so.""" |
| regex = re.compile('Caching mojo app (\S+) at (\S+)') |
| mappings = {} |
| for line in lines: |
| result = regex.search(line) |
| if result: |
| url = GetBasenameFromMojoApp(result.group(1)) |
| mappings[result.group(2)] = GetSymboledNameForMojoApp(url) |
| return mappings |
| |
| |
| def _LowestAncestorContainingRelpath(dir_path, relpath): |
| """Returns the lowest ancestor dir of |dir_path| that contains |relpath|. |
| """ |
| cur_dir_path = os.path.abspath(dir_path) |
| while True: |
| if os.path.exists(os.path.join(cur_dir_path, relpath)): |
| return cur_dir_path |
| |
| next_dir_path = os.path.dirname(cur_dir_path) |
| if next_dir_path != cur_dir_path: |
| cur_dir_path = next_dir_path |
| else: |
| return None |
| |
| |
| def _GuessDir(relpath): |
| """Returns absolute path to location |relpath| in the lowest ancestor of this |
| file that contains it.""" |
| lowest_ancestor = _LowestAncestorContainingRelpath( |
| os.path.dirname(__file__), relpath) |
| if not lowest_ancestor: |
| return None |
| return os.path.join(lowest_ancestor, relpath) |
| |
| |
| |
| def main(): |
| try: |
| options, arguments = getopt.getopt(sys.argv[1:], "", |
| ["more-info", |
| "less-info", |
| "build-dir=", |
| "ndk-dir=", |
| "symbols-dir=", |
| "symbols-zip=", |
| "arch=", |
| "help"]) |
| except getopt.GetoptError, unused_error: |
| PrintUsage() |
| |
| zip_arg = None |
| more_info = False |
| for option, value in options: |
| if option == "--help": |
| PrintUsage() |
| elif option == "--symbols-dir": |
| symbol.SYMBOLS_DIR = os.path.expanduser(value) |
| elif option == "--symbols-zip": |
| zip_arg = os.path.expanduser(value) |
| elif option == "--arch": |
| symbol.ARCH = value |
| elif option == "--build-dir": |
| symbol.BUILD_DIR = value |
| elif option == "--ndk-dir": |
| symbol.NDK_DIR = value |
| elif option == "--more-info": |
| more_info = True |
| elif option == "--less-info": |
| more_info = False |
| |
| if not symbol.BUILD_DIR: |
| guess = _GuessDir(_DEFAULT_BUILD_DIR) |
| if not guess: |
| print "Couldn't find the build directory, please pass --build-dir." |
| return 1 |
| print "Inferring the build directory path as " + guess |
| symbol.BUILD_DIR = guess |
| |
| if not symbol.NDK_DIR: |
| guess = _GuessDir(_DEFAULT_NDK_DIR) |
| if not guess: |
| print "Couldn't find the Android NDK, please pass --ndk-dir." |
| return 1 |
| print "Inferring the Android NDK path as " + guess |
| symbol.NDK_DIR = guess |
| |
| |
| if len(arguments) > 1: |
| PrintUsage() |
| |
| if not arguments or arguments[0] == "-": |
| print "Reading native crash info from stdin" |
| f = sys.stdin |
| else: |
| print "Searching for native crashes in %s" % arguments[0] |
| f = open(arguments[0], "r") |
| |
| lines = f.readlines() |
| f.close() |
| |
| rootdir = None |
| if zip_arg: |
| rootdir, symbol.SYMBOLS_DIR = UnzipSymbols(zip_arg) |
| |
| if symbol.SYMBOLS_DIR: |
| print "Reading Android symbols from", symbol.SYMBOLS_DIR |
| |
| print "Reading Mojo symbols from", symbol.BUILD_DIR |
| stack_core.ConvertTrace(lines, more_info, GetSymbolMapping(lines)) |
| |
| if rootdir: |
| # be a good citizen and clean up...os.rmdir and os.removedirs() don't work |
| cmd = "rm -rf \"%s\"" % rootdir |
| print "\ncleaning up (%s)" % cmd |
| os.system(cmd) |
| |
| if __name__ == "__main__": |
| main() |
| |
| # vi: ts=2 sw=2 |
