win: Validate readability of memory ranges added to minidump

snapshot/win/end_to_end_test.py

 #!/usr/bin/env python
 
 # Copyright 2015 The Crashpad Authors. All rights reserved.
 #
 # 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
 #
@@ skipping 58 matching lines @@
       'Debugging Tools For Windows (x86)',
       'Debugging Tools For Windows',)
   for possible_path in possible_paths:
     app_path = os.path.join(possible_path, 'cdb.exe')
     app_path = FindInstalledWindowsApplication(app_path)
     if app_path:
       return app_path
   return None
 
 
-def GetDumpFromCrashyProgram(out_dir, pipe_name):
-  """Initialize a crash database, run crashpad_handler, run crashy_program
+def GetDumpFromProgram(out_dir, pipe_name, executable_name):
+  """Initialize a crash database, run crashpad_handler, run |executable_name|
   connecting to the crash_handler. Returns the minidump generated by
   crash_handler for further testing.
   """
   test_database = MakeTempDir()
   handler = None
 
   try:
     if subprocess.call(
         [os.path.join(out_dir, 'crashpad_database_util.exe'), '--create',
          '--database=' + test_database]) != 0:
       print 'could not initialize report database'
       return None
 
     handler = subprocess.Popen([
         os.path.join(out_dir, 'crashpad_handler.exe'),
         '--pipe-name=' + pipe_name,
         '--database=' + test_database
     ])
 
-    subprocess.call([os.path.join(out_dir, 'crashy_program.exe'), pipe_name])
+    subprocess.call([os.path.join(out_dir, executable_name), pipe_name])
 
     out = subprocess.check_output([
         os.path.join(out_dir, 'crashpad_database_util.exe'),
         '--database=' + test_database,
         '--show-completed-reports',
         '--show-all-report-info',
     ])
     for line in out.splitlines():
       if line.strip().startswith('Path:'):
         return line.partition(':')[2].strip()
   finally:
     if handler:
       handler.kill()
 
 
+def GetDumpFromCrashyProgram(out_dir, pipe_name):
+  return GetDumpFromProgram(out_dir, pipe_name, 'crashy_program.exe')
+
+
+def GetDumpFromSelfDestroyingProgram(out_dir, pipe_name):
+  return GetDumpFromProgram(out_dir, pipe_name, 'self_destroying_program.exe')
+
+
 class CdbRun(object):
   """Run cdb.exe passing it a cdb command and capturing the output.
   `Check()` searches for regex patterns in sequence allowing verification of
   expected output.
   """
 
   def __init__(self, cdb_path, dump_path, command):
     # Run a command line that loads the dump, runs the specified cdb command,
     # and then quits, and capturing stdout.
     self.out = subprocess.check_output([
@@ skipping 14 matching lines @@
       print >>sys.stderr, 'FAILED - %s' % message
       print >>sys.stderr, '-' * 80
       print >>sys.stderr, 'did not match:\n  %s' % pattern
       print >>sys.stderr, '-' * 80
       print >>sys.stderr, 'remaining output was:\n  %s' % self.out
       print >>sys.stderr, '-' * 80
       sys.stderr.flush()
       sys.exit(1)
 
 
-def RunTests(cdb_path, dump_path, pipe_name):
+def RunTests(cdb_path, dump_path, destroyed_dump_path, pipe_name):
   """Runs various tests in sequence. Runs a new cdb instance on the dump for
   each block of tests to reduce the chances that output from one command is
   confused for output from another.
   """
   out = CdbRun(cdb_path, dump_path, '.ecxr')
   out.Check('This dump file has an exception of interest stored in it',
             'captured exception')
   out.Check(
       'crashy_program!crashpad::`anonymous namespace\'::SomeCrashyFunction',
       'exception at correct location')
@@ skipping 24 matching lines @@
             r'g_test_critical_section', 'lock was captured')
   if platform.win32_ver()[0] != '7':
     # We can't allocate CRITICAL_SECTIONs with .DebugInfo on Win 7.
     out.Check(r'\*\*\* Locked', 'lock debug info was captured, and is locked')
 
   out = CdbRun(cdb_path, dump_path, '!handle')
   out.Check(r'\d+ Handles', 'captured handles')
   out.Check(r'Event\s+\d+', 'capture some event handles')
   out.Check(r'File\s+\d+', 'capture some file handles')
 
+  # Check that there is no stack trace in the self-destroyed process. Confirm
+  # that the top is where we expect it (that's based only on IP), but subsequent
+  # stack entries will not be available. This confirms that we have a mostly
+  # valid dump, but that the stack was omitted.

[Mark Mentovai, 2015/10/21 22:49:29]

Is it worth also checking that the module list is included?

[scottmg, 2015/10/21 22:58:08]

Sure, done.

+  out = CdbRun(cdb_path, destroyed_dump_path, '.ecxr;k 2')
+  out.Check(r'self_destroying_program!crashpad::`anonymous namespace\'::'
+                r'FreeOwnStackAndBreak.*\nquit:',
+            'at correct location, no additional stack entries')
+
 def main(args):
   try:
     if len(args) != 1:
       print >>sys.stderr, 'must supply binary dir'
       return 1
 
     cdb_path = GetCdbPath()
     if not cdb_path:
       print >>sys.stderr, 'could not find cdb'
       return 1
 
     # Make sure we can download Windows symbols.
     if not os.environ.get('_NT_SYMBOL_PATH'):
       symbol_dir = MakeTempDir()
       protocol = 'https' if platform.win32_ver()[0] != 'XP' else 'http'
       os.environ['_NT_SYMBOL_PATH'] = (
           'SRV*' + symbol_dir + '*' +
           protocol + '://msdl.microsoft.com/download/symbols')
 
     pipe_name = r'\\.\pipe\end-to-end_%s_%s' % (
         os.getpid(), str(random.getrandbits(64)))
 
-    dump_path = GetDumpFromCrashyProgram(args[0], pipe_name)
-    if not dump_path:
+    crashy_dump_path = GetDumpFromCrashyProgram(args[0], pipe_name)
+    if not crashy_dump_path:
       return 1
 
-    RunTests(cdb_path, dump_path, pipe_name)
+    destroyed_dump_path = GetDumpFromSelfDestroyingProgram(args[0], pipe_name)
+    if not destroyed_dump_path:
+      return 1
+
+    RunTests(cdb_path, crashy_dump_path, destroyed_dump_path, pipe_name)
 
     return 0
   finally:
     CleanUpTempDirs()
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))