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

sandbox/linux/seccomp/ipc.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"
 
 namespace playground {
 
 #ifndef IPC_PRIVATE
 #define IPC_PRIVATE 0
 #endif
 #ifndef IPC_RMID
 #define IPC_RMID    0
 #endif
 #ifndef IPC_64
 #define IPC_64      256
 #endif
 
 #if defined(__NR_shmget)
 void* Sandbox::sandbox_shmat(int shmid, const void* shmaddr, int shmflg) {
-  Debug::syscall(__NR_shmat, "Executing handler");
+  long long tm;
+  Debug::syscall(&tm, __NR_shmat, "Executing handler");
 
   struct {
     int       sysnum;
     long long cookie;
     ShmAt     shmat_req;
   } __attribute__((packed)) request;
   request.sysnum             = __NR_shmat;
   request.cookie             = cookie();
   request.shmat_req.shmid    = shmid;
   request.shmat_req.shmaddr  = shmaddr;
   request.shmat_req.shmflg   = shmflg;
 
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward shmat() request [sandbox]");
   }
+  Debug::elapsed(tm, __NR_shmat);
   return reinterpret_cast<void *>(rc);
 }
 
 int Sandbox::sandbox_shmctl(int shmid, int cmd, void* buf) {
-  Debug::syscall(__NR_shmctl, "Executing handler");
+  long long tm;
+  Debug::syscall(&tm, __NR_shmctl, "Executing handler");
 
   struct {
     int       sysnum;
     long long cookie;
     ShmCtl    shmctl_req;
   } __attribute__((packed)) request;
   request.sysnum           = __NR_shmctl;
   request.cookie           = cookie();
   request.shmctl_req.shmid = shmid;
   request.shmctl_req.cmd   = cmd;
   request.shmctl_req.buf   = buf;
 
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward shmctl() request [sandbox]");
   }
+  Debug::elapsed(tm, __NR_shmctl);
   return static_cast<int>(rc);
 }
 
 int Sandbox::sandbox_shmdt(const void* shmaddr) {
-  Debug::syscall(__NR_shmdt, "Executing handler");
+  long long tm;
+  Debug::syscall(&tm, __NR_shmdt, "Executing handler");
 
   struct {
     int       sysnum;
     long long cookie;
     ShmDt     shmdt_req;
   } __attribute__((packed)) request;
   request.sysnum             = __NR_shmdt;
   request.cookie             = cookie();
   request.shmdt_req.shmaddr  = shmaddr;
 
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward shmdt() request [sandbox]");
   }
+  Debug::elapsed(tm, __NR_shmdt);
   return static_cast<int>(rc);
 }
 
 int Sandbox::sandbox_shmget(int key, size_t size, int shmflg) {
-  Debug::syscall(__NR_shmget, "Executing handler");
+  long long tm;
+  Debug::syscall(&tm, __NR_shmget, "Executing handler");
 
   struct {
     int       sysnum;
     long long cookie;
     ShmGet    shmget_req;
   } __attribute__((packed)) request;
   request.sysnum            = __NR_shmget;
   request.cookie            = cookie();
   request.shmget_req.key    = key;
   request.shmget_req.size   = size;
   request.shmget_req.shmflg = shmflg;
 
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward shmget() request [sandbox]");
   }
+  Debug::elapsed(tm, __NR_shmget);
   return static_cast<int>(rc);
 }
 
 bool Sandbox::process_shmat(int parentMapsFd, int sandboxFd, int threadFdPub,
                             int threadFd, SecureMem::Args* mem) {
   // Read request
   ShmAt shmat_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &shmat_req, sizeof(shmat_req)) !=
       sizeof(shmat_req)) {
@@ skipping 111 matching lines @@
 #endif
 #ifndef SHMGET
 #define SHMGET      23
 #endif
 #ifndef SHMCTL
 #define SHMCTL      24
 #endif
 
 int Sandbox::sandbox_ipc(unsigned call, int first, int second, int third,
                          void* ptr, long fifth) {
-  Debug::syscall(__NR_ipc, "Executing handler", call);
+  long long tm;
+  Debug::syscall(&tm, __NR_ipc, "Executing handler", call);
   struct {
     int       sysnum;
     long long cookie;
     IPC       ipc_req;
   } __attribute__((packed)) request;
   request.sysnum         = __NR_ipc;
   request.cookie         = cookie();
   request.ipc_req.call   = call;
   request.ipc_req.first  = first;
   request.ipc_req.second = second;
   request.ipc_req.third  = third;
   request.ipc_req.ptr    = ptr;
   request.ipc_req.fifth  = fifth;
 
   long rc;
   SysCalls sys;
   if (write(sys, processFdPub(), &request, sizeof(request)) !=
       sizeof(request) ||
       read(sys, threadFdPub(), &rc, sizeof(rc)) != sizeof(rc)) {
     die("Failed to forward ipc() request [sandbox]");
   }
+  Debug::elapsed(tm, __NR_ipc, call);
   return static_cast<int>(rc);
 }
 
 bool Sandbox::process_ipc(int parentMapsFd, int sandboxFd, int threadFdPub,
                           int threadFd, SecureMem::Args* mem) {
   // Read request
   IPC ipc_req;
   SysCalls sys;
   if (read(sys, sandboxFd, &ipc_req, sizeof(ipc_req)) != sizeof(ipc_req)) {
     die("Failed to read parameters for ipc() [process]");
@@ skipping 57 matching lines @@
       // other SysV IPC calls.
     deny:
       mem->shmId = -1;
       SecureMem::abandonSystemCall(threadFd, -EINVAL);
       return false;
   }
 }
 #endif
 
 } // namespace