Grokdump: new shell command, "lm"

tools/grokdump.py

 #!/usr/bin/env python
 #
 # Copyright 2012 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import bisect
 import cmd
 import codecs
 import ctypes
+import datetime
 import disasm
 import mmap
 import optparse
 import os
 import re
 import struct
 import sys
 import types
 
-
 USAGE="""usage: %prog [OPTIONS] [DUMP-FILE]
 
 Minidump analyzer.
 
 Shows the processor state at the point of exception including the
 stack of the active thread and the referenced objects in the V8
 heap. Code objects are disassembled and the addresses linked from the
 stack (e.g. pushed return addresses) are marked with "=>".
 
 Examples:
@@ skipping 381 matching lines @@
   ("ted", ctypes.c_uint64),
   ("stack", MINIDUMP_MEMORY_DESCRIPTOR.ctype),
   ("context", MINIDUMP_LOCATION_DESCRIPTOR.ctype)
 ])
 
 MINIDUMP_THREAD_LIST = Descriptor([
   ("thread_count", ctypes.c_uint32),
   ("threads", lambda t: MINIDUMP_THREAD.ctype * t.thread_count)
 ])
 
+MINIDUMP_VS_FIXEDFILEINFO = Descriptor([
+  ("dwSignature", ctypes.c_uint32),
+  ("dwStrucVersion", ctypes.c_uint32),
+  ("dwFileVersionMS", ctypes.c_uint32),
+  ("dwFileVersionLS", ctypes.c_uint32),
+  ("dwProductVersionMS", ctypes.c_uint32),
+  ("dwProductVersionLS", ctypes.c_uint32),
+  ("dwFileFlagsMask", ctypes.c_uint32),
+  ("dwFileFlags", ctypes.c_uint32),
+  ("dwFileOS", ctypes.c_uint32),
+  ("dwFileType", ctypes.c_uint32),
+  ("dwFileSubtype", ctypes.c_uint32),
+  ("dwFileDateMS", ctypes.c_uint32),
+  ("dwFileDateLS", ctypes.c_uint32)
+])
+
 MINIDUMP_RAW_MODULE = Descriptor([
   ("base_of_image", ctypes.c_uint64),
   ("size_of_image", ctypes.c_uint32),
   ("checksum", ctypes.c_uint32),
   ("time_date_stamp", ctypes.c_uint32),
   ("module_name_rva", ctypes.c_uint32),
-  ("version_info", ctypes.c_uint32 * 13),
+  ("version_info", MINIDUMP_VS_FIXEDFILEINFO.ctype),
   ("cv_record", MINIDUMP_LOCATION_DESCRIPTOR.ctype),
   ("misc_record", MINIDUMP_LOCATION_DESCRIPTOR.ctype),
   ("reserved0", ctypes.c_uint32 * 2),
   ("reserved1", ctypes.c_uint32 * 2)
 ])
 
 MINIDUMP_MODULE_LIST = Descriptor([
   ("number_of_modules", ctypes.c_uint32),
   ("modules", lambda t: MINIDUMP_RAW_MODULE.ctype * t.number_of_modules)
 ])
@@ skipping 316 matching lines @@
           size = int(result.group(2), 16)
           name = result.group(4).rstrip()
           bisect.insort_left(self.symbols,
                              FuncSymbol(baseaddr + start, size, name))
     print " ... done"
 
   def TryLoadSymbolsFor(self, modulename, module):
     try:
       symfile = os.path.join(self.symdir,
                              modulename.replace('.', '_') + ".pdb.sym")
-      self._LoadSymbolsFrom(symfile, module.base_of_image)
-      self.modules_with_symbols.append(module)
+      if os.path.isfile(symfile):
+        self._LoadSymbolsFrom(symfile, module.base_of_image)
+        self.modules_with_symbols.append(module)
     except Exception as e:
       print "  ... failure (%s)" % (e)
 
   # Returns true if address is covered by some module that has loaded symbols.
   def _IsInModuleWithSymbols(self, addr):
     for module in self.modules_with_symbols:
       start = module.base_of_image
       end = start + module.size_of_image
       if (start <= addr) and (addr < end):
         return True
@@ skipping 1204 matching lines @@
     """
      List all available memory regions.
     """
     def print_region(reader, start, size, location):
       print "  %s - %s (%d bytes)" % (reader.FormatIntPtr(start),
                                       reader.FormatIntPtr(start + size),
                                       size)
     print "Available memory regions:"
     self.reader.ForEachMemoryRegion(print_region)
 
+  def do_lm(self, arg):
+    """
+     List details for all loaded modules in the minidump. An argument can
+     be passed to limit the output to only those modules that contain the
+     argument as a substring (case insensitive match).
+    """
+    for module in self.reader.module_list.modules:
+      if arg:
+        name = GetModuleName(self.reader, module).lower()
+        if name.find(arg.lower()) >= 0:
+          PrintModuleDetails(self.reader, module)
+      else:
+        PrintModuleDetails(self.reader, module)
+    print
+
   def do_s(self, word):
     """
      Search for a given word in available memory regions. The given word
      is expanded to full pointer size and searched at aligned as well as
      un-aligned memory locations. Use 'sa' to search aligned locations
      only.
     """
     try:
       word = int(word, 0)
     except ValueError:
@@ skipping 38 matching lines @@
        'r8', 'r9', 'r10', 'r11', 'r12', 'r13', 'r14', 'r15'],
     MD_CPU_ARCHITECTURE_ARM:
       ['r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9',
        'r10', 'r11', 'r12', 'sp', 'lr', 'pc'],
     MD_CPU_ARCHITECTURE_X86:
       ['eax', 'ebx', 'ecx', 'edx', 'edi', 'esi', 'ebp', 'esp', 'eip']
 }
 
 KNOWN_MODULES = {'chrome.exe', 'chrome.dll'}
 
+def GetVersionString(ms, ls):
+  return "%d.%d.%d.%d" % (ms >> 16, ms & 0xffff, ls >> 16, ls & 0xffff)
+
+
 def GetModuleName(reader, module):
   name = reader.ReadMinidumpString(module.module_name_rva)
+  # simplify for path manipulation
+  name = name.encode('utf-8')
   return str(os.path.basename(str(name).replace("\\", "/")))
 
+
+def PrintModuleDetails(reader, module):
+  print "%s" % GetModuleName(reader, module)
+  file_version = GetVersionString(module.version_info.dwFileVersionMS,
+                                  module.version_info.dwFileVersionLS)
+  product_version = GetVersionString(module.version_info.dwProductVersionMS,
+                                     module.version_info.dwProductVersionLS)
+  print "  base: %s" % reader.FormatIntPtr(module.base_of_image)
+  print "  end: %s" % reader.FormatIntPtr(module.base_of_image +
+                                          module.size_of_image)
+  print "  file version: %s" % file_version
+  print "  product version: %s" % product_version
+  time_date_stamp = datetime.datetime.fromtimestamp(module.time_date_stamp)
+  print "  timestamp: %s" % time_date_stamp
+
+
 def AnalyzeMinidump(options, minidump_name):
   reader = MinidumpReader(options, minidump_name)
   heap = None
   DebugPrint("========================================")
   if reader.exception is None:
     print "Minidump has no exception info"
   else:
     print "Exception info:"
     exception_thread = reader.thread_map[reader.exception.thread_id]
     print "  thread id: %d" % exception_thread.id
     print "  code: %08X" % reader.exception.exception.code
     print "  context:"
     for r in CONTEXT_FOR_ARCH[reader.arch]:
       print "    %s: %s" % (r, reader.FormatIntPtr(reader.Register(r)))
     # TODO(vitalyr): decode eflags.
     if reader.arch == MD_CPU_ARCHITECTURE_ARM:
       print "    cpsr: %s" % bin(reader.exception_context.cpsr)[2:]
     else:
       print "    eflags: %s" % bin(reader.exception_context.eflags)[2:]
 
-    # TODO(mstarzinger): Disabled because broken, needs investigation.
-    #print
-    #print "  modules:"
-    #for module in reader.module_list.modules:
-    #  name = GetModuleName(reader, module)
-    #  if name in KNOWN_MODULES:
-    #    print "    %s at %08X" % (name, module.base_of_image)
-    #    reader.TryLoadSymbolsFor(name, module)
+    print
+    print "  modules:"
+    for module in reader.module_list.modules:
+      name = GetModuleName(reader, module)
+      if name in KNOWN_MODULES:
+        print "    %s at %08X" % (name, module.base_of_image)
+        reader.TryLoadSymbolsFor(name, module)
     print
 
     stack_top = reader.ExceptionSP()
     stack_bottom = exception_thread.stack.start + \
         exception_thread.stack.memory.data_size
     stack_map = {reader.ExceptionIP(): -1}
     for slot in xrange(stack_top, stack_bottom, reader.PointerSize()):
       maybe_address = reader.ReadUIntPtr(slot)
       if not maybe_address in stack_map:
         stack_map[maybe_address] = slot
@@ skipping 16 matching lines @@
     for line in lines:
       print FormatDisasmLine(disasm_start, heap, line)
     print
 
   if heap is None:
     heap = V8Heap(reader, None)
 
   if options.full:
     FullDump(reader, heap)
 
+  if options.command:
+    InspectionShell(reader, heap).onecmd(options.command)
+
   if options.shell:
     try:
       InspectionShell(reader, heap).cmdloop("type help to get help")
     except KeyboardInterrupt:
       print "Kthxbye."
-  else:
+  elif not options.command:
     if reader.exception is not None:
       print "Annotated stack (from exception.esp to bottom):"
       for slot in xrange(stack_top, stack_bottom, reader.PointerSize()):
         maybe_address = reader.ReadUIntPtr(slot)
         heap_object = heap.FindObject(maybe_address)
         maybe_symbol = reader.FindSymbol(maybe_address)
         print "%s: %s %s" % (reader.FormatIntPtr(slot),
                              reader.FormatIntPtr(maybe_address),
                              maybe_symbol or "")
         if heap_object:
           heap_object.Print(Printer())
           print
 
   reader.Dispose()
 
 
 if __name__ == "__main__":
   parser = optparse.OptionParser(USAGE)
   parser.add_option("-s", "--shell", dest="shell", action="store_true",
                     help="start an interactive inspector shell")
+  parser.add_option("-c", "--command", dest="command", default="",
+                    help="run an interactive inspector shell command and exit")
   parser.add_option("-f", "--full", dest="full", action="store_true",
                     help="dump all information contained in the minidump")
   parser.add_option("--symdir", dest="symdir", default=".",
                     help="directory containing *.pdb.sym file with symbols")
   parser.add_option("--objdump",
                     default="/usr/bin/objdump",
                     help="objdump tool to use [default: %default]")
   options, args = parser.parse_args()
   if os.path.exists(options.objdump):
     disasm.OBJDUMP_BIN = options.objdump
     OBJDUMP_BIN = options.objdump
   else:
     print "Cannot find %s, falling back to default objdump" % options.objdump
   if len(args) != 1:
     parser.print_help()
     sys.exit(1)
   AnalyzeMinidump(options, args[0])