Add touch-only detection for strace API implementation.

tools/isolate/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 853 matching lines @@
           if not os.path.isdir(f)
         )
         return Results.Process(
             self.pid,
             files,
             render_to_string_and_fix_case(self.executable),
             self.command,
             render_to_string_and_fix_case(self.initial_cwd),
             children)
 
-      def add_file(self, filepath):
+      def add_file(self, filepath, touch_only):
         if self.root().blacklist(unicode(filepath)):
           return
-        logging.debug('add_file(%d, %s)' % (self.pid, filepath))
-        self.files.add(filepath)
+        logging.debug('add_file(%d, %s, %s)' % (self.pid, filepath, touch_only))
+        if touch_only:
+          self.only_touched.add(filepath)
+        else:
+          self.files.add(filepath)
 
     def __init__(self, blacklist):
       self.blacklist = blacklist
       self.processes = {}
 
   class Tracer(object):
     """During it's lifetime, the tracing subsystem is enabled."""
     def __init__(self, logname):
       self._logname = logname
       self._lock = threading.Lock()
@@ skipping 117 matching lines @@
       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]+) \+\+\+$')
       # A call was canceled. Ignore any prefix.
       RE_UNAVAILABLE = re.compile(r'^.*\)\s*= \? <unavailable>$')
       # Happens when strace fails to even get the function name.
       UNNAMED_FUNCTION = '????'
 
       # Arguments parsing.
+      RE_ACCESS = re.compile(r'^\"(.+?)\", R_[A-Z]+$')
       RE_CHDIR = re.compile(r'^\"(.+?)\"$')
       RE_EXECVE = re.compile(r'^\"(.+?)\", \[(.+)\], \[\/\* \d+ vars? \*\/\]$')
       RE_OPEN2 = re.compile(r'^\"(.*?)\", ([A-Z\_\|]+)$')
       RE_OPEN3 = re.compile(r'^\"(.*?)\", ([A-Z\_\|]+), (\d+)$')
+      RE_READLINK = re.compile(r'^\"(.+?)\", \".+?\"(\.\.\.)?, \d+$')
       RE_RENAME = re.compile(r'^\"(.+?)\", \"(.+?)\"$')
+      RE_STAT = re.compile(r'\"(.+?)\", \{.+?, \.\.\.\}')
 
       class RelativePath(object):
         """A late-bound relative path."""
         def __init__(self, parent, value):
           self.parent = parent
           self.value = value
 
         def render(self):
           """Returns the current directory this instance is representing.
 
@@ skipping 105 matching lines @@
           raise
         except (KeyError, NotImplementedError, ValueError), e:
           raise TracingFailure(
               'Trace generated a %s exception: %s' % (
                   e.__class__.__name__, str(e)),
               self.pid,
               self._line_number,
               line,
               e)
 
+      def handle_access(self, args, result):
+        if result.startswith('-1'):
+          return
+        match = self.RE_ACCESS.match(args)
+        self._handle_file(match.group(1), True)
+
       def handle_chdir(self, args, result):
         """Updates cwd."""
         if not result.startswith('0'):
           return
         cwd = self.RE_CHDIR.match(args).group(1)
         self.cwd = self.RelativePath(self, cwd)
         logging.debug('handle_chdir(%d, %s)' % (self.pid, self.cwd))
 
       def handle_clone(self, _args, result):
         """Transfers cwd."""
@@ skipping 20 matching lines @@
 
       def handle_execve(self, args, result):
         if result != '0':
           return
         match = self.RE_EXECVE.match(args)
         if not match:
           raise TracingFailure(
               'Failed to process execve(%s)' % args,
               None, None, None)
         filepath = match.group(1)
-        self._handle_file(filepath)
+        self._handle_file(filepath, False)
         self.executable = self.RelativePath(self.get_cwd(), filepath)
         self.command = process_quoted_arguments(match.group(2))
 
       def handle_exit_group(self, _args, _result):
         """Removes cwd."""
         self.cwd = None
 
       @staticmethod
       def handle_fork(_args, _result):
         raise NotImplementedError('Unexpected/unimplemented trace fork()')
 
+      def handle_getcwd(self, _args, _result):
+        pass
+
+      def handle_lstat(self, args, result):
+        if result.startswith('-1'):
+          return
+        match = self.RE_STAT.match(args)
+        self._handle_file(match.group(1), True)
+
       def handle_open(self, args, result):
         if result.startswith('-1'):
           return
         args = (self.RE_OPEN3.match(args) or self.RE_OPEN2.match(args)).groups()
         if 'O_DIRECTORY' in args[1]:
           return
-        self._handle_file(args[0])
+        self._handle_file(args[0], False)
+
+      def handle_readlink(self, args, result):
+        if result.startswith('-1'):
+          return
+        match = self.RE_READLINK.match(args)
+        if not match:
+          raise TracingFailure(
+              'Failed to parse: readlink(%s) = %s' % (args, result),
+              None,
+              None,
+              None)
+        self._handle_file(match.group(1), False)
 
       def handle_rename(self, args, result):
         if result.startswith('-1'):
           return
         args = self.RE_RENAME.match(args).groups()
-        self._handle_file(args[0])
-        self._handle_file(args[1])
+        self._handle_file(args[0], False)
+        self._handle_file(args[1], False)
+
+      def handle_stat(self, args, result):
+        if result.startswith('-1'):
+          return
+        match = self.RE_STAT.match(args)
+        self._handle_file(match.group(1), True)
 
       @staticmethod
       def handle_stat64(_args, _result):
         raise NotImplementedError('Unexpected/unimplemented trace stat64()')
 
       @staticmethod
       def handle_vfork(_args, _result):
         raise NotImplementedError('Unexpected/unimplemented trace vfork()')
 
-      def _handle_file(self, filepath):
+      def _handle_file(self, filepath, touch_only):
         filepath = self.RelativePath(self.get_cwd(), filepath)
-        self.add_file(filepath)
+        #assert not touch_only, unicode(filepath)
+        self.add_file(filepath, touch_only)
 
     def __init__(self, blacklist, initial_cwd):
       super(Strace.Context, self).__init__(blacklist)
       self.initial_cwd = initial_cwd
 
     def render(self):
       """Returns the string value of the initial cwd of the root process.
 
       Used by RelativePath.
       """
@@ skipping 43 matching lines @@
 
     @classmethod
     def traces(cls):
       """Returns the list of all handled traces to pass this as an argument to
       strace.
       """
       prefix = 'handle_'
       return [i[len(prefix):] for i in dir(cls.Process) if i.startswith(prefix)]
 
   class Tracer(ApiBase.Tracer):
+    MAX_LEN = 256
+
     def trace(self, cmd, cwd, tracename, output):
       """Runs strace on an executable."""
       logging.info('trace(%s, %s, %s, %s)' % (cmd, cwd, tracename, output))
       assert os.path.isabs(cmd[0]), cmd[0]
       assert os.path.isabs(cwd), cwd
       assert os.path.normpath(cwd) == cwd, cwd
       with self._lock:
         if not self._initialized:
           raise TracingFailure(
               'Called Tracer.trace() on an unitialized object',
               None, None, None, tracename)
         assert tracename not in (i['trace'] for i in self._traces)
       stdout = stderr = None
       if output:
         stdout = subprocess.PIPE
         stderr = subprocess.STDOUT
-      traces = ','.join(Strace.Context.traces())
+      # Ensure all file related APIs are hooked.
+      traces = ','.join(Strace.Context.traces() + ['file'])
       trace_cmd = [
         'strace',
         '-ff',
-        '-s', '256',
+        '-s', '%d' % self.MAX_LEN,
         '-e', 'trace=%s' % traces,
         '-o', self._logname + '.' + tracename,
       ]
       child = subprocess.Popen(
           trace_cmd + cmd,
           cwd=cwd,
           stdin=subprocess.PIPE,
           stdout=stdout,
           stderr=stderr)
       out = child.communicate()[0]
@@ skipping 258 matching lines @@
 
     def _handle_file(self, pid, filepath):
       if not filepath.startswith('/'):
         filepath = os.path.join(self.processes[pid].cwd, filepath)
       # We can get '..' in the path.
       filepath = os.path.normpath(filepath)
       # Sadly, still need to filter out directories here;
       # saw open_nocancel(".", 0, 0) = 0 lines.
       if os.path.isdir(filepath):
         return
-      self.processes[pid].add_file(filepath)
+      self.processes[pid].add_file(filepath, False)
 
     def handle_ftruncate(self, pid, args):
       """Just used as a signal to kill dtrace, ignoring."""
       pass
 
     @staticmethod
     def _handle_ignored(pid, args):
       """Is called for all the event traces that are not handled."""
       raise NotImplementedError('Please implement me')
 
@@ skipping 703 matching lines @@
       #IRP = self.USER_DATA
       TTID = self.USER_DATA + 1  # Thread ID, that's what we want.
       FILE_OBJECT = self.USER_DATA + 2
       #FILE_KEY = self.USER_DATA + 3
       proc = self._thread_to_process(line[TTID])
       if not proc:
         # Not a process we care about.
         return
       file_object = line[FILE_OBJECT]
       if file_object in proc.file_objects:
-        proc.add_file(proc.file_objects.pop(file_object))
+        proc.add_file(proc.file_objects.pop(file_object), False)
 
     def handle_FileIo_Create(self, line):
       """Handles a file open.
 
       All FileIo events are described at
       http://msdn.microsoft.com/library/windows/desktop/aa363884.aspx
       for some value of 'description'.
 
       " (..) process and thread id values of the IO events (..) are not valid "
       http://msdn.microsoft.com/magazine/ee358703.aspx
@@ skipping 784 matching lines @@
     return command(argv[1:])
   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:]))