Use the libc clone wrapper in sys_clone.

sandbox/linux/services/syscall_wrappers_unittest.cc

 // Copyright 2014 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 "sandbox/linux/services/syscall_wrappers.h"
 
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
@@ skipping 40 matching lines @@
     _exit(1);
   }
 
   ASSERT_NE(-1, pid);
   int status = 0;
   ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
   ASSERT_TRUE(WIFEXITED(status));
   EXPECT_EQ(kSuccessExit, WEXITSTATUS(status));
 }
 
+// Some libcs cache the result of the getpid syscall. This tests that
+// the cache is updated after sys_clone.
+TEST(SyscallWrappers, CloneUpdatesPidCache) {
+  // Warm up the PID cache.
+  ASSERT_EQ(sys_getpid(), getpid());
+
+  pid_t ctid = 0;
+  pid_t pid =
+      sys_clone(CLONE_CHILD_SETTID | SIGCHLD, nullptr, nullptr, &ctid, nullptr);
+
+  const int kSuccessExit = 0;
+  if (0 == pid) {
+    // In child. The pid cache should have been updated.
+    ASSERT_EQ(ctid, getpid());

[jln (very slow on Chromium), 2014/12/15 23:31:35]

Let's not use ASSERT in there, it's confusing. I would just _exit(1) like the
test above.

I would actually even merge these tests.

[rickyz (no longer on Chrome), 2014/12/16 00:35:09]

I merged the tests, but actually, I'm curious as to why you prefer _exit(1) over
ASSERT. I prefer ASSERT because it writes a useful message to stderr, which
shows me the cause when a test fails due to an unexpected return code. With just
_exit(1), I can't tell precisely why the test failed from the test output.

[jln (very slow on Chromium), 2014/12/16 01:11:22]

ASSERT is only guaranteed to return from the current function. It's not
guaranteed to terminate the process and if it does, it's not guaranteed to
terminate the process.

In general, it's really error prone to rely in implementation detail of the
testing framework in subprocesses (which are not supported by the testing
framework). Even doing exit() instead of _exit() in a subprocess would fail.

SANDBOX_TEST() have to go through some hoops to be "somewhat" reliable, by
failing if *anything* gets written to stderr and rely on very specific unlikely
exit codes to detect success.

If you need to do anything complicated in a subprocess of your test, I suggest
using SANDBOX_TEST.

Moreover: I think we'll want to move this code to base/. Unlikely sandbox/, in
base/ unittests are not careful with threads. So you could end-up forking with
other threads running here. So controlling tightly what we're doing in the
subprocess is important if we don't want to end-up with deadlocks when the
testing framework runs the test with existing threads.

+    _exit(kSuccessExit);
+  }
+
+  ASSERT_NE(-1, pid);
+  int status = 0;
+  ASSERT_EQ(pid, HANDLE_EINTR(waitpid(pid, &status, 0)));
+  ASSERT_TRUE(WIFEXITED(status));
+  EXPECT_EQ(kSuccessExit, WEXITSTATUS(status));
+}
+
 }  // namespace
 
 }  // namespace sandbox