[sanitizer_common] Add internal_clone().

[earthdok]

Summary

Add a wrapper for the clone syscall for use in StopTheWorld. We
implement it only for x86_64, so stop building StopTheWorld for other platforms
(no one uses it outside x86_64 anyway).

See https://code.google.com/p/address-sanitizer/issues/detail?id=214 for why we
can't use the glibc clone() wrapper.

[eugenis]

Looks great.
Please explain the stale cache issue in the comments.

lib/sanitizer_common/sanitizer_linux_libcdep.cc

292 ↗

(On Diff #3922)

add some comments explaining how this is different from the libc clone() wrapper.

[glider]

(other comments discussed offline)

lib/sanitizer_common/sanitizer_linux_libcdep.cc

299 ↗

(On Diff #3922)

I suggest to assert that child_stack is aligned on 16.

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

375

/*parent_tidptr*/0, ...

[glider]

lib/sanitizer_common/sanitizer_linux_libcdep.cc

331 ↗

(On Diff #3922)

_exit(%rax)

[pcc]

lib/sanitizer_common/sanitizer_linux.h

32

Make this declaration conditional on defined(x86_64).

lib/sanitizer_common/sanitizer_linux_libcdep.cc

347 ↗

(On Diff #3922)

The other syscall wrappers return a uptr with a potentially negative error value instead of setting errno. You can easily do that here as well, this would also allow you to move the implementation to sanitizer_linux.cc.

[earthdok]

• addressed all comments

[earthdok]

• eliminated a file with whitespace-only changes

[glider]

LGTM with a nit.

lib/sanitizer_common/sanitizer_linux.cc

682

s/taks/task

[earthdok]

Committed r189753

lib/sanitizer_common/sanitizer_linux.h

 // the one in <dirent.h>, which is used by readdir().
 struct linux_dirent;
 
 // Syscall wrappers.
 uptr internal_getdents(fd_t fd, struct linux_dirent *dirp, unsigned int count);
 uptr internal_prctl(int option, uptr arg2, uptr arg3, uptr arg4, uptr arg5);
 uptr internal_sigaltstack(const struct sigaltstack* ss,
                           struct sigaltstack* oss);
+#ifdef __x86_64__
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr);
+#endif
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:
   explicit ThreadLister(int pid);
   ~ThreadLister();
   // GetNextTID returns -1 if the list of threads is exhausted, or if there has
   // been an error.

lib/sanitizer_common/sanitizer_linux.cc

if (phdr->p_type == PT_LOAD) {
       seg_start = RoundDownTo(seg_start, GetPageSizeCached());
       seg_end = RoundUpTo(seg_end, GetPageSizeCached());
       cb((void *)seg_start, seg_end - seg_start);
     }
   }
 }
 #endif
 
+#if defined(__x86_64__)
+// We cannot use glibc's clone wrapper, because it messes with the child
+// taks's TLS. It writes the PID and TID of the child task to its thread
+// descriptor, but in our case the child task shares the thread descriptor with
+// the parent (because we don't know how to allocate a new thread
+// descriptor to keep glibc happy). So the stock version of clone(), when
+// used with CLONE_VM, would end up corrupting the parent's thread descriptor.
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
+                    int *parent_tidptr, void *newtls, int *child_tidptr) {
+  long long res;
+  if (!fn || !child_stack)
+    return -EINVAL;
+  CHECK_EQ(0, (uptr)child_stack % 16);
+  child_stack = (char *)child_stack - 2 * sizeof(void *);
+  ((void **)child_stack)[0] = (void *)(uptr)fn;
+  ((void **)child_stack)[1] = arg;
+  __asm__ __volatile__(
+                       /* %rax = syscall(%rax = __NR_clone,
+                        *                %rdi = flags,
+                        *                %rsi = child_stack,
+                        *                %rdx = parent_tidptr,
+                        *                %r8  = new_tls,
+                        *                %r10 = child_tidptr)
+                        */
+                       "movq   %6,%%r8\n"
+                       "movq   %7,%%r10\n"
+                       ".cfi_endproc\n"
+                       "syscall\n"
+
+                       /* if (%rax != 0)
+                        *   return;
+                        */
+                       "testq  %%rax,%%rax\n"
+                       "jnz    1f\n"
+
+                       /* In the child. Terminate unwind chain. */
+                       ".cfi_startproc\n"
+                       ".cfi_undefined %%rip;\n"
+                       "xorq   %%rbp,%%rbp\n"
+
+                       /* Call "fn(arg)". */
+                       "popq   %%rax\n"
+                       "popq   %%rdi\n"
+                       "call   *%%rax\n"
+
+                       /* Call _exit(%rax). */
+                       "movq   %%rax,%%rdi\n"
+                       "movq   %2,%%rax\n"
+                       "syscall\n"
+
+                       /* Return to parent. */
+                     "1:\n"
+                       : "=a" (res)
+                       : "a"(__NR_clone), "i"(__NR_exit),
+                         "S"(child_stack),
+                         "D"(flags),
+                         "d"(parent_tidptr),
+                         "r"(newtls),
+                         "r"(child_tidptr)
+                       : "rsp", "memory", "r8", "r10", "r11", "rcx");
+  return res;
+}
+#endif  // defined(__x86_64__)
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

 //===-- sanitizer_stoptheworld_linux_libcdep.cc ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // See sanitizer_stoptheworld.h for details.
 // This implementation was inspired by Markus Gutschke's linuxthreads.cc.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "sanitizer_platform.h"
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && defined(__x86_64__)
 
 #include "sanitizer_stoptheworld.h"
 
 #include <errno.h>
-#include <sched.h> // for clone
+#include <sched.h> // for CLONE_* definitions
 #include <stddef.h>
 #include <sys/prctl.h> // for PR_* definitions
 #include <sys/ptrace.h> // for PTRACE_* definitions
 #include <sys/types.h> // for pid_t
 #if SANITIZER_ANDROID && defined(__arm__)
 # include <linux/user.h>  // for pt_regs
 #else
 # include <sys/user.h>  // for user_regs_struct

 //
 // * We lack custom implementations of sigfillset() and sigaction(), so we use
 // the libc versions instead. The same assumptions as above apply.
 //
 // * It is safe to call libc functions before the cloned thread is spawned or
 // after it has exited. The following functions are used in this manner:
 // sigdelset()
 // sigprocmask()
-// clone()
 
 COMPILER_CHECK(sizeof(SuspendedThreadID) == sizeof(pid_t));
 
 namespace __sanitizer {
 // This class handles thread suspending/unsuspending in the tracer thread.
 class ThreadSuspender {
  public:
   explicit ThreadSuspender(pid_t pid)
void StopTheWorld(StopTheWorldCallback callback, void *argument) {
   struct TracerThreadArgument tracer_thread_argument;
   tracer_thread_argument.callback = callback;
   tracer_thread_argument.callback_argument = argument;
   const uptr kTracerStackSize = 2 * 1024 * 1024;
   ScopedStackSpaceWithGuard tracer_stack(kTracerStackSize);
   // Block the execution of TracerThread until after we have set ptrace
   // permissions.
   tracer_thread_argument.mutex.Lock();
-  pid_t tracer_pid = clone(TracerThread, tracer_stack.Bottom(),
-                           CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_UNTRACED,
-                           &tracer_thread_argument);
-  if (tracer_pid < 0) {
-    Report("Failed spawning a tracer thread (errno %d).\n", errno);
+  uptr tracer_pid = internal_clone(
+      TracerThread, tracer_stack.Bottom(),
+      &tracer_thread_argument, 0 /* parent_tidptr */, 0 /* newtls */, 0
+      /* child_tidptr */);
+  int local_errno = 0;
+  if (internal_iserror(tracer_pid, &local_errno)) {
+    Report("Failed spawning a tracer thread (errno %d).\n", local_errno);
     tracer_thread_argument.mutex.Unlock();
   } else {
     // On some systems we have to explicitly declare that we want to be traced
     // by the tracer thread.
 #ifdef PR_SET_PTRACER
     internal_prctl(PR_SET_PTRACER, tracer_pid, 0, 0, 0);
 #endif
     // Allow the tracer thread to start.
     tracer_thread_argument.mutex.Unlock();
     // Since errno is shared between this thread and the tracer thread, we
     // must avoid using errno while the tracer thread is running.
     // At this point, any signal will either be blocked or kill us, so waitpid
     // should never return (and set errno) while the tracer thread is alive.
     uptr waitpid_status = internal_waitpid(tracer_pid, NULL, __WALL);
-    int wperrno;
-    if (internal_iserror(waitpid_status, &wperrno))
-      Report("Waiting on the tracer thread failed (errno %d).\n", wperrno);
+    if (internal_iserror(waitpid_status, &local_errno))
+      Report("Waiting on the tracer thread failed (errno %d).\n", local_errno);
   }
 }
 
 // Platform-specific methods from SuspendedThreadsList.
 #if SANITIZER_ANDROID && defined(__arm__)
 typedef pt_regs regs_struct;
 #define REG_SP ARM_sp
 
int SuspendedThreadsList::GetRegistersAndSP(uptr index,
   return 0;
 }
 
 uptr SuspendedThreadsList::RegisterCount() {
   return sizeof(regs_struct) / sizeof(uptr);
 }
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_LINUX
+#endif  // SANITIZER_LINUX && defined(__x86_64__)

lib/sanitizer_common/tests/sanitizer_stoptheworld_test.cc

 //===-- sanitizer_stoptheworld_test.cc ------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Tests for sanitizer_stoptheworld.h
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX && defined(__x86_64__)
 
 #include "sanitizer_common/sanitizer_stoptheworld.h"
 #include "gtest/gtest.h"
 
 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_common.h"
 
 #include <pthread.h>
TEST(StopTheWorld, SuspendThreadsAdvanced) {
   pthread_mutex_unlock(&advanced_incrementer_thread_exit_mutex);
   for (uptr i = 0; i < kThreadCount; i++)
     ASSERT_EQ(0, pthread_join(argument.thread_ids[i], NULL));
   pthread_mutex_destroy(&advanced_incrementer_thread_exit_mutex);
 }
 
 }  // namespace __sanitizer
 
-#endif  // SANITIZER_LINUX
+#endif  // SANITIZER_LINUX && defined(__x86_64__)