Make the seccomp sandbox compatible with tcmalloc:...

third_party/tcmalloc/chromium/src/base/spinlock_linux-inl.h

 /* Copyright (c) 2009, Google Inc.
  * All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * ---
  * This file is a Linux-specific part of spinlock.cc
  */
 
 #include <sched.h>
 #include <time.h>
-#include "base/linux_syscall_support.h"
 
 #define FUTEX_WAIT 0
 #define FUTEX_WAKE 1
 #define FUTEX_PRIVATE_FLAG 128
 
+// Note: Instead of making direct system calls that are inlined, we rely
+//       on the syscall() function in glibc to do the right thing. This
+//       is necessary to make the code compatible with the seccomp sandbox,
+//       which needs to be able to find and patch all places where system
+//       calls are made. Scanning through and patching glibc is fast, but
+//       doing so on the entire Chrome binary would be prohibitively
+//       expensive.
+//       This is a notable change from the upstream version of tcmalloc,
+//       which prefers direct system calls in order to improve compatibility
+//       with older toolchains and runtime libraries.
+
 static bool have_futex;
 static int futex_private_flag = FUTEX_PRIVATE_FLAG;
 
 namespace {
 static struct InitModule {
   InitModule() {
     int x = 0;
     // futexes are ints, so we can use them only when
     // that's the same size as the lockword_ in SpinLock.
     have_futex = (sizeof (Atomic32) == sizeof (int) && 
-                  sys_futex(&x, FUTEX_WAKE, 1, 0) >= 0);
+                  syscall(__NR_futex, &x, FUTEX_WAKE, 1, 0) >= 0);
     if (have_futex &&
-        sys_futex(&x, FUTEX_WAKE | futex_private_flag, 1, 0) < 0) {
+        syscall(__NR_futex, &x, FUTEX_WAKE | futex_private_flag, 1, 0) < 0) {
       futex_private_flag = 0;
     }
   }
 } init_module;
 }  // anonymous namespace
 
 static void SpinLockWait(volatile Atomic32 *w) {
   int save_errno = errno;
   struct timespec tm;
   tm.tv_sec = 0;
   if (have_futex) {
     int value;
     tm.tv_nsec = 1000000;   // 1ms; really we're trying to sleep for one kernel
                             // clock tick
     while ((value = base::subtle::Acquire_CompareAndSwap(w, 0, 1)) != 0) {
-      sys_futex(reinterpret_cast<int *>(const_cast<Atomic32 *>(w)),
+      syscall(__NR_futex, reinterpret_cast<int *>(const_cast<Atomic32 *>(w)),
           FUTEX_WAIT | futex_private_flag,
           value, reinterpret_cast<struct kernel_timespec *>(&tm));
     }
   } else {
     tm.tv_nsec = 2000001;       // above 2ms so linux 2.4 doesn't spin
     if (base::subtle::NoBarrier_Load(w) != 0) {
       sched_yield();
     }
     while (base::subtle::Acquire_CompareAndSwap(w, 0, 1) != 0) {
       nanosleep(&tm, NULL);

[Markus (顧孟勤), 2013/01/25 22:24:00]

I was researching some unrelated problem, and came across
http://stackoverflow.com/questions/7086220/what-does-rep-nop-mean-in-x86-asse...

It sounds as if our current code can wreak havoc with hyper-threading. We should
probably insert an:

  asm volatile("rep nop");

We might also need this instruction for the syscall(__NR_futex); not entirely
sure if it is needed there though. The system call might already do this.

We should probably run this past somebody who knows more about CPU
architectures? Maybe, m3b?

     }
   }
   errno = save_errno;
 }
 
 static void SpinLockWake(volatile Atomic32 *w) {
   if (have_futex) {
-    sys_futex(reinterpret_cast<int *>(const_cast<Atomic32 *>(w)),
+    syscall(__NR_futex, reinterpret_cast<int *>(const_cast<Atomic32 *>(w)),
               FUTEX_WAKE | futex_private_flag, 1, 0);
   }
 }