Compute and pring the time that it takes to execute system calls. This data...

sandbox/linux/seccomp/syscall.cc

 // Copyright (c) 2010 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.
 
 #include "debug.h"
 #include "sandbox_impl.h"
 #include "syscall_table.h"
 
 namespace playground {
 
@@ skipping 253 matching lines @@
 
 void* Sandbox::defaultSystemCallHandler(int syscallNum, void* arg0, void* arg1,
                                         void* arg2, void* arg3, void* arg4,
                                         void* arg5) {
   // TODO(markus): The following comment is currently not true, we do intercept these system calls. Try to fix that.
 
   // We try to avoid intercepting read(), write(), and sigreturn(), as
   // these system calls are not restricted in Seccomp mode. But depending on
   // the exact instruction sequence in libc, we might not be able to reliably
   // filter out these system calls at the time when we instrument the code.
-  SysCalls sys;
-  long     rc;
+  SysCalls  sys;
+  long      rc;
+  long long tm;
   switch (syscallNum) {
     case __NR_read:
-      Debug::syscall(syscallNum, "Allowing unrestricted system call");
+      Debug::syscall(&tm, syscallNum, "Allowing unrestricted system call");
       rc             = sys.read((long)arg0, arg1, (size_t)arg2);
       break;
     case __NR_write:
-      Debug::syscall(syscallNum, "Allowing unrestricted system call");
+      Debug::syscall(&tm, syscallNum, "Allowing unrestricted system call");
       rc             = sys.write((long)arg0, arg1, (size_t)arg2);
       break;
     case __NR_rt_sigreturn:
-      Debug::syscall(syscallNum, "Allowing unrestricted system call");
+      Debug::syscall(&tm, syscallNum, "Allowing unrestricted system call");
       rc             = sys.rt_sigreturn((unsigned long)arg0);
       break;
     default:
       if (Debug::isEnabled()) {
         // In debug mode, prevent stderr from being closed
         if (syscallNum == __NR_close && arg0 == (void *)2)
           return 0;
       }
 
       if ((unsigned)syscallNum <= maxSyscall &&
           syscallTable[syscallNum].handler == UNRESTRICTED_SYSCALL) {
-        Debug::syscall(syscallNum, "Allowing unrestricted system call");
+        Debug::syscall(&tm, syscallNum, "Allowing unrestricted system call");
      perform_unrestricted:
         struct {
           int          sysnum;
           void*        unrestricted_req[6];
         } __attribute__((packed)) request = {
           syscallNum, { arg0, arg1, arg2, arg3, arg4, arg5 } };
 
         int   thread = threadFdPub();
         void* rc;
         if (write(sys, thread, &request, sizeof(request)) != sizeof(request) ||
             read(sys, thread, &rc, sizeof(rc)) != sizeof(rc)) {
           die("Failed to forward unrestricted system call");
         }
+        Debug::elapsed(tm, syscallNum);
         return rc;
       } else if (Debug::isEnabled()) {
-        Debug::syscall(syscallNum,
+        Debug::syscall(&tm, syscallNum,
                        "In production mode, this call would be disallowed");
         goto perform_unrestricted;
       } else {
         return (void *)-ENOSYS;
       }
   }
   if (rc < 0) {
     rc               = -sys.my_errno;
   }
+  Debug::elapsed(tm, syscallNum);
   return (void *)rc;
 }
 
 } // namespace