autotest: Test that logs can be sent when processes crash

client/site_tests/logging_UserCrash/logging_UserCrash.py

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import grp, logging, os, pwd, re, stat, subprocess
 from signal import SIGSEGV
 from autotest_lib.client.bin import site_crash_test, site_utils, test
 from autotest_lib.client.common_lib import error, utils
 
 _COLLECTION_ERROR_SIGNATURE = 'crash_reporter-user-collection'
@@ skipping 38 matching lines @@
         if output != 'core':
             raise error.TestFail('core pattern should have been core, not %s' %
                                  output)
 
 
     def _prepare_crasher(self):
         """Extract the crasher and set its permissions.
 
         crasher is only gzipped to subvert Portage stripping.
         """
-        self.enable_crash_filtering('crasher_nobreakpad')
         self._crasher_path = os.path.join(self.srcdir, 'crasher_nobreakpad')
         utils.system('cd %s; tar xzf crasher.tgz-unmasked' %
                      self.srcdir)
         # Make sure all users (specifically chronos) have access to
         # this directory and its decendents in order to run crasher
         # executable as different users.
         utils.system('chmod -R a+rx ' + self.bindir)
 
 
     def _populate_symbols(self):
@@ skipping 88 matching lines @@
         if not self._is_frame_in_stack(15, basename, 'recbomb',
                                        'bomb.cc', 12, stack):
             raise error.TestFail('Did not show recursion line on stack')
 
         # Should identify main line
         if not self._is_frame_in_stack(16, basename, 'main',
                                        'crasher.cc', 21, stack):
             raise error.TestFail('Did not show main on stack')
 
 
-    def _run_crasher_process(self, username, cause_crash=True, consent=True):
+    def _run_crasher_process(self, username, cause_crash=True, consent=True,
+                             crasher_path=None):
         """Runs the crasher process.
 
         Args:
           username: runs as given user
           extra_args: additional parameters to pass to crasher process
 
         Returns:
           A dictionary with keys:
             returncode: return code of the crasher
             crashed: did the crasher return segv error code
             crash_reporter_caught: did crash_reporter catch a segv
             output: stderr/stdout output of the crasher process
         """
-        self._prepare_crasher()
-        self._populate_symbols()
+        if crasher_path is None: crasher_path=self._crasher_path
+        self.enable_crash_filtering(os.path.basename(crasher_path))
 
         if username != 'root':
             crasher_command = ['su', username, '-c']
             expected_result = 128 + SIGSEGV
         else:
             crasher_command = []
             expected_result = -SIGSEGV
 
-        crasher_command.append(self._crasher_path)
-        basename = os.path.basename(self._crasher_path)
+        crasher_command.append(crasher_path)
+        basename = os.path.basename(crasher_path)
         if not cause_crash:
             crasher_command.append('--nocrash')
         self._set_consent(consent)
         crasher = subprocess.Popen(crasher_command,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE)
         output = crasher.communicate()[1]
         logging.debug('Output from %s: %s' %
                       (crasher_command, output))
 
@@ skipping 94 matching lines @@
 
         # Check version matches.
         lsb_release = utils.read_file('/etc/lsb-release')
         version_match = re.search(r'CHROMEOS_RELEASE_VERSION=(.*)', lsb_release)
         if not ('Version: %s' % version_match.group(1)) in result['output']:
             raise error.TestFail('Did not find version %s in log output' %
                                  version_match.group(1))
 
 
     def _run_crasher_process_and_analyze(self, username,
-                                         cause_crash=True, consent=True):
+                                         cause_crash=True, consent=True,
+                                         crasher_path=None):
         self._log_reader.set_start_by_current()
 
+        if crasher_path is None: crasher_path=self._crasher_path
         result = self._run_crasher_process(username, cause_crash=cause_crash,
-                                           consent=consent)
+                                           consent=consent,
+                                           crasher_path=crasher_path)
 
         if not result['crashed'] or not result['crash_reporter_caught']:
             return result;
 
         crash_dir = self._get_crash_dir(username)
 
         if not consent:
             if os.path.exists(crash_dir):
                 raise error.TestFail('Crash directory should not exist')
             return result
 
         crash_contents = os.listdir(crash_dir)
-        basename = os.path.basename(self._crasher_path)
+        basename = os.path.basename(crasher_path)
 
         breakpad_minidump = None
         crash_reporter_minidump = None
         crash_reporter_meta = None
         crash_reporter_log = None
 
         self._check_crash_directory_permissions(crash_dir)
 
         logging.debug('Contents in %s: %s' % (crash_dir, crash_contents))
 
@@ skipping 117 matching lines @@
         site_utils.poll_for_condition(
             lambda: self._log_reader.can_find(to_find),
             timeout=10,
             exception=error.TestError(
               'Timeout waiting for: ' + to_find + ' in ' +
               self._log_reader.get_logs()))
 
 
     def _test_crash_filtering(self):
         """Test that crash filtering (a feature needed for testing) works."""
-        self._prepare_crasher()
         crasher_basename = os.path.basename(self._crasher_path)
         self._log_reader.set_start_by_current()
 
         self.enable_crash_filtering('none')
         self._check_filter_crasher(False)
 
         self.enable_crash_filtering('sleep')
         self._check_filter_crasher(False)
 
         self.disable_crash_filtering()
@@ skipping 78 matching lines @@
         self._check_collection_failure('--core2md_failure_test',
                                        'Problem during %s [result=1]: Usage:' %
                                        _CORE2MD_PATH)
 
 
     def _test_internal_directory_failure(self):
         self._check_collection_failure('--directory_failure_test',
                                        'Purposefully failing to create')
 
 
+    def _test_crash_logs_creation(self):
+        logs_triggering_crasher = os.path.join(os.path.dirname(self.bindir),
+                                               'crash_log_test')
+        # Copy crasher_path to a test location with correct mode and a
+        # special name to trigger crash log creation.
+        utils.system('cp -a "%s" "%s"' % (self._crasher_path,
+                                          logs_triggering_crasher))
+        result = self._run_crasher_process_and_analyze(
+            'root', crasher_path=logs_triggering_crasher)
+        self._check_crashed_and_caught(result)
+        contents = utils.read_file(result['log'])
+        if contents != 'hello world\n':
+            raise error.TestFail('Crash log contents unexpected: %s' % contents)
+        if not ('log=' + result['log']) in utils.read_file(result['meta']):
+            raise error.TestFail('Meta file does not reference log')
+
+
+    def _test_crash_log_infinite_recursion(self):
+        recursion_triggering_crasher = os.path.join(
+            os.path.dirname(self.bindir), 'crash_log_recursion_test')
+        # The configuration file hardcodes this path, so make sure it's still
+        # the same.
+        if (recursion_triggering_crasher !=
+            '/home/autotest/tests/crash_log_recursion_test'):
+          raise error.TestError('Path to recursion test changed')
+        # Copy crasher_path to a test location with correct mode and a
+        # special name to trigger crash log creation.
+        utils.system('cp -a "%s" "%s"' % (self._crasher_path,
+                                          recursion_triggering_crasher))
+        # Simply completing this command means that we avoided
+        # infinite recursion.
+        result = self._run_crasher_process(
+            'root', crasher_path=recursion_triggering_crasher)
+
+
     def _check_core_file_persisting(self, expect_persist):
         self._log_reader.set_start_by_current()
 
         result = self._run_crasher_process('root')
 
         if not result['crashed']:
             raise error.TestFail('crasher did not crash')
 
         crash_contents = os.listdir(self._get_crash_dir('root'))
 
@@ skipping 44 matching lines @@
                 raise error.TestFail('.leave_core file did not disappear')
             self._check_core_file_persisting(False)
         finally:
             os.system('umount /root')
 
 
     # TODO(kmixter): Test crashing a process as ntp or some other
     # non-root, non-chronos user.
 
     def run_once(self):
+        self._prepare_crasher()
+        self._populate_symbols()
         self.run_crash_tests(['reporter_startup',
                               'reporter_shutdown',
                               'no_crash',
                               'chronos_crasher',
                               'chronos_crasher_no_consent',
                               'root_crasher',
                               'root_crasher_no_consent',
                               'crash_filtering',
                               'max_enqueued_crashes',
                               'core2md_failure',
                               'internal_directory_failure',
+                              'crash_logs_creation',
+                              'crash_log_infinite_recursion',
                               'core_file_persists_in_debug',
                               'core_file_removed_in_production'],
                               initialize_crash_reporter = True)