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 21 matching lines @@
 import codecs
 import ctypes
 import disasm
 import mmap
 import optparse
 import os
 import re
 import struct
 import sys
 import types
-
+import datetime

[Michael Starzinger, 2013/07/01 11:17:37]

nit: Can we alpha-sort the imports?

 
 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 "=>".
 
@@ skipping 382 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 1542 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:
+          GetModuleDetails(self.reader, module)
+      else:
+        GetModuleDetails(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)
   return str(os.path.basename(str(name).replace("\\", "/")))
 
+
+def GetModuleDetails(reader, module):

[Michael Starzinger, 2013/07/01 11:17:37]

nit: Can we rename this to PrintModuleDetails, I think that better describes
semantics?

+  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
@@ skipping 44 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])