tsan: intercept clone

[dvyukov]

Summary

gtest uses clone for death tests and it needs the same
handling as fork to prevent deadlock (take runtime mutexes
before and release them after).

[melver]

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

2217

minor: Not sure which style is being followed, but if Google-style, then this should just be 'struct Arg'. I don't see the _t suffix used consistently elsewhere.

[dvyukov]

s/arg_t/Arg/

[thakis]

This breaks building on mac (and probably on non-linux in general): http://45.33.8.238/mac/38681/step_4.txt

Please take a look.

[dvyukov]

In D113677#3125046, @thakis wrote:

This breaks building on mac (and probably on non-linux in general): http://45.33.8.238/mac/38681/step_4.txt

Please take a look.

Hi Nico,

I've just looking at the greendragon email. I've mailed https://reviews.llvm.org/D113693
Thanks for notifying.

[thakis]

Thanks for the quick fix. Bots are happy again :)

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

TSAN_INTERCEPTOR(int, vfork, int fake) {
   // We could disable interceptors in the child process. But it's not possible
   // to simply intercept and wrap vfork, because vfork child is not allowed
   // to return from the function that calls vfork, and that's exactly what
   // we would do. So this would require some assembly trickery as well.
   // Instead we simply turn vfork into fork.
   return WRAP(fork)(fake);
 }
 
+TSAN_INTERCEPTOR(int, clone, int (*fn)(void *), void *stack, int flags,
+                 void *arg, int *parent_tid, void *tls, pid_t *child_tid) {
+  SCOPED_INTERCEPTOR_RAW(clone, fn, stack, flags, arg, parent_tid, tls,
+                         child_tid);
+  struct Arg {
+    int (*fn)(void *);
+    void *arg;
+  };
+  auto wrapper = +[](void *p) -> int {
+    auto *thr = cur_thread();
+    uptr pc = GET_CURRENT_PC();
+    ForkChildAfter(thr, pc);
+    FdOnFork(thr, pc);
+    auto *arg = static_cast<Arg *>(p);
+    return arg->fn(arg->arg);
+  };
+  ForkBefore(thr, pc);
+  Arg arg_wrapper = {fn, arg};
+  int pid = REAL(clone)(wrapper, stack, flags, &arg_wrapper, parent_tid, tls,
+                        child_tid);
+  ForkParentAfter(thr, pc);
+  return pid;
+}
+
 #if !SANITIZER_MAC && !SANITIZER_ANDROID
 typedef int (*dl_iterate_phdr_cb_t)(__sanitizer_dl_phdr_info *info, SIZE_T size,
                                     void *data);
 struct dl_iterate_phdr_data {
   ThreadState *thr;
   uptr pc;
   dl_iterate_phdr_cb_t cb;
   void *data;
#endif
   TSAN_INTERCEPT(usleep);
   TSAN_INTERCEPT(nanosleep);
   TSAN_INTERCEPT(pause);
   TSAN_INTERCEPT(gettimeofday);
   TSAN_INTERCEPT(getaddrinfo);
 
   TSAN_INTERCEPT(fork);
   TSAN_INTERCEPT(vfork);
+  TSAN_INTERCEPT(clone);
 #if !SANITIZER_ANDROID
   TSAN_INTERCEPT(dl_iterate_phdr);
 #endif
   TSAN_MAYBE_INTERCEPT_ON_EXIT;
   TSAN_INTERCEPT(__cxa_atexit);
   TSAN_INTERCEPT(_exit);
 
 #ifdef NEED_TLS_GET_ADDR

compiler-rt/test/tsan/clone_deadlock.cpp

+// RUN: %clangxx_tsan -O1 %s -o %t && %env_tsan_opts=atexit_sleep_ms=0 %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <errno.h>
+#include <sched.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+long counter;
+
+static void *incrementer(void *arg) {
+  for (;;)
+    __sync_fetch_and_add(&counter, 1);
+  return 0;
+}
+
+static int cloned(void *arg) {
+  for (int i = 0; i < 1000; i++)
+    __sync_fetch_and_add(&counter, 1);
+  exit(0);
+  return 0;
+}
+
+int main() {
+  barrier_init(&barrier, 2);
+  pthread_t th;
+  pthread_create(&th, 0, incrementer, 0);
+  for (int i = 0; i < 100; i++) {
+    char stack[64 << 10] __attribute__((aligned(64)));
+    int pid = clone(cloned, stack + sizeof(stack), SIGCHLD, 0);
+    if (pid == -1) {
+      fprintf(stderr, "failed to clone: %d\n", errno);
+      exit(1);
+    }
+    while (wait(0) != pid) {
+    }
+  }
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: DONE