tsan: add another fork test

[dvyukov]

Summary

Add a fork test that models what happens on Mac
where fork calls malloc/free inside of our atfork
callbacks.

[yln]

LGTM, but most be landed together with the fix in D112603.

[yln]

In D114250#3143577, @yln wrote:

... must be landed together with the fix ...

Scratch that, I was confused. We are good to go! :)

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

 #include "ubsan/ubsan_init.h"
 
 volatile int __tsan_resumed = 0;
 
 extern "C" void __tsan_resume() {
   __tsan_resumed = 1;
 }
 
+SANITIZER_WEAK_DEFAULT_IMPL
+void __tsan_test_only_on_fork() {}
+
 namespace __tsan {
 
 #if !SANITIZER_GO
 void (*on_initialize)(void);
 int (*on_finalize)(int);
 #endif
 
 #if !SANITIZER_GO && !SANITIZER_MAC
void ForkBefore(ThreadState *thr, uptr pc) NO_THREAD_SAFETY_ANALYSIS {
   // Suppress all reports in the pthread_atfork callbacks.
   // Reports will deadlock on the report_mtx.
   // We could ignore sync operations as well,
   // but so far it's unclear if it will do more good or harm.
   // Unnecessarily ignoring things can lead to false positives later.
   thr->suppress_reports++;
   // On OS X, REAL(fork) can call intercepted functions (OSSpinLockLock), and
   // we'll assert in CheckNoLocks() unless we ignore interceptors.
+  // On OS X libSystem_atfork_prepare/parent/child callbacks are called
+  // after/before our callbacks and they call free.
   thr->ignore_interceptors++;
+
+  __tsan_test_only_on_fork();
 }
 
 void ForkParentAfter(ThreadState *thr, uptr pc) NO_THREAD_SAFETY_ANALYSIS {
   thr->suppress_reports--;  // Enabled in ForkBefore.
   thr->ignore_interceptors--;
   ScopedErrorReportLock::Unlock();
   ctx->report_mtx.Unlock();
   ctx->thread_registry.Unlock();

compiler-rt/test/tsan/Linux/fork_deadlock.cpp

+// RUN: %clangxx_tsan -O1 %s -o %t && %env_tsan_opts=atexit_sleep_ms=0 %run %t 2>&1 | FileCheck %s
+
+// This test models what happens on Mac when fork
+// calls malloc/free inside of our atfork callbacks.
+// and ensures that we don't deadlock on malloc/free calls.
+
+#include "../test.h"
+#include "syscall.h"
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+void alloc_free_blocks() {
+  // Allocate a bunch of blocks to drain local allocator cache
+  // and provoke it to lock allocator global mutexes.
+  const int kBlocks = 1000;
+  void *blocks[kBlocks];
+  for (int i = 0; i < kBlocks; i++) {
+    void *p = malloc(10);
+    *(volatile char *)p = 0;
+    blocks[i] = p;
+  }
+  for (int i = 0; i < kBlocks; i++)
+    free(blocks[i]);
+}
+
+__attribute__((disable_sanitizer_instrumentation)) extern "C" void
+__tsan_test_only_on_fork() {
+  const char *msg = "__tsan_test_only_on_fork\n";
+  write(2, msg, strlen(msg));
+  alloc_free_blocks();
+}
+
+static void *background(void *p) {
+  for (;;)
+    alloc_free_blocks();
+  return 0;
+}
+
+int main() {
+  pthread_t th;
+  pthread_create(&th, 0, background, 0);
+  pthread_detach(th);
+  for (int i = 0; i < 10; i++) {
+    int pid = myfork();
+    if (pid < 0) {
+      fprintf(stderr, "failed to fork (%d)\n", errno);
+      exit(1);
+    }
+    if (pid == 0) {
+      // child
+      exit(0);
+    }
+    // parent
+    while (wait(0) < 0) {
+    }
+  }
+  fprintf(stderr, "DONE\n");
+}
+
+// CHECK: __tsan_test_only_on_fork
+// CHECK: DONE