Always accept strace logs to have the last line corrupted.

trace_inputs.py

 #!/usr/bin/env python
 # coding=utf-8
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Traces an executable and its child processes and extract the files accessed
 by them.
 
 The implementation uses OS-specific API. The native Kernel logger and the ETL
@@ skipping 1089 matching lines @@
     class Process(ApiBase.Context.Process):
       """Represents the state of a process.
 
       Contains all the information retrieved from the pid-specific log.
       """
       # Function names are using ([a-z_0-9]+)
       # This is the most common format. function(args) = result
       RE_HEADER = re.compile(r'^([a-z_0-9]+)\((.+?)\)\s+= (.+)$')
       # An interrupted function call, only grab the minimal header.
       RE_UNFINISHED = re.compile(r'^([^\(]+)(.*) \<unfinished \.\.\.\>$')
-      # An interrupted function call, with the process exiting. It must be the
-      # last line in the log.
-      RE_UNFINISHED_EXIT = re.compile(
-          r'^([^\(]+)(.*) \<unfinished \.\.\.\ exit status \d+>$')
-      # An interrupted function call the hard way. Usually observed with futex()
-      # on ubuntu 12.04.
-      RE_INTERRUPTED_HARD = re.compile(r'^([^\(]+)\('
-                                       '[A-Z0-9a-z:\,\_\|\{\}\(\)\>\< ]*$')
       # A resumed function call.
       RE_RESUMED = re.compile(r'^<\.\.\. ([^ ]+) resumed> (.+)$')
       # A process received a signal.
       RE_SIGNAL = re.compile(r'^--- SIG[A-Z]+ .+ ---')
       # A process didn't handle a signal. Ignore any junk appearing before,
       # because the process was forcibly killed so it won't open any new file.
       RE_KILLED = re.compile(
           r'^.*\+\+\+ killed by ([A-Z]+)( \(core dumped\))? \+\+\+$')
       # The process has exited.
       RE_PROCESS_EXITED = re.compile(r'^\+\+\+ exited with (\d+) \+\+\+')
@@ skipping 93 matching lines @@
 
         The validity is only guaranteed once all the logs are processed.
         """
         return self.initial_cwd.render()
 
       def on_line(self, line):
         assert isinstance(line, str)
         self._line_number += 1
         if self._done:
           raise TracingFailure(
-              'Found a trace for a terminated process',
+              'Found a trace for a terminated process or corrupted log',
               None, None, None)
 
         if self.RE_SIGNAL.match(line):
           # Ignore signals.
           return
 
         try:
           match = self.RE_KILLED.match(line)
           if match:
             # Converts a '+++ killed by Foo +++' trace into an exit_group().
@@ skipping 10 matching lines @@
           if match:
             if match.group(1) in self._pending_calls:
               raise TracingFailure(
                   'Found two unfinished calls for the same function',
                   None, None, None,
                   self._pending_calls)
             self._pending_calls[match.group(1)] = (
                 match.group(1) + match.group(2))
             return
 
-          match = (
-              self.RE_UNFINISHED_EXIT.match(line) or
-              self.RE_INTERRUPTED_HARD.match(line))
-          if match:
-            # The process died. No other line can be processed afterward.
-            self._done = True
-            return
-
           match = self.RE_UNAVAILABLE.match(line)
           if match:
             # This usually means a process was killed and a pending call was
             # canceled.
             # TODO(maruel): Look up the last exit_group() trace just above and
             # make sure any self._pending_calls[anything] is properly flushed.
             return
 
           match = self.RE_RESUMED.match(line)
           if match:
             if match.group(1) not in self._pending_calls:
               raise TracingFailure(
                   'Found a resumed call that was not logged as unfinished',
                   None, None, None,
                   self._pending_calls)
             pending = self._pending_calls.pop(match.group(1))
             # Reconstruct the line.
             line = pending + match.group(2)
 
           match = self.RE_HEADER.match(line)
           if not match:
-            raise TracingFailure(
-                'Found an invalid line: %s' % line,
-                None, None, None)
+            # The line is corrupted. It happens occasionally when a process is
+            # killed forcibly with activity going on. Assume the process died.
+            # No other line can be processed afterward.
+            self._done = True
+            return
+
           if match.group(1) == self.UNNAMED_FUNCTION:
             return
 
           # It's a valid line, handle it.
           handler = getattr(self, 'handle_%s' % match.group(1), None)
           if not handler:
             self._handle_unknown(match.group(1), match.group(2), match.group(3))
           return handler(match.group(2), match.group(3))
         except TracingFailure, e:
           # Hack in the values since the handler could be a static function.
@@ skipping 2247 matching lines @@
     main_impl(argv)
   except TracingFailure, e:
     sys.stderr.write('\nError: ')
     sys.stderr.write(str(e))
     sys.stderr.write('\n')
     return 1
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))