[tsan] Handle libdispatch worker threads on OS X

[kubamracek]

Summary

On OS X, GCD worker threads are created without a call to pthread_create. We need to properly register these threads with ThreadCreate and ThreadStart. If we don't do that, the first interceptor called on such a thread will crash.

This patch uses a libpthread API (pthread_introspection_hook_install) to get notifications about new threads and about threads that are about to be destroyed. The worker threads don't have a parent thread, as they are created "spuriously", so a few internal functions need to be modified to accept an invalid (kInvalidTid) parent thread ID.

(This is part of an effort to port TSan to OS X, and it's one the very first steps. Don't expect TSan on OS X to actually work or pass tests at this point.)

[dvyukov]

lib/tsan/rtl/tsan_platform_mac.cc

95 ↗

(On Diff #39181)

Don't we need to pass detached=true?
If a thread is not detached, runtime will wait for pthread_join call before getting rid of all associated state.

97 ↗

(On Diff #39181)

call this var 'thr'
each and every reference to the current thread is called 'thr' throughout the runtime code

101 ↗

(On Diff #39181)

same here

107 ↗

(On Diff #39181)

I guess the order will actually be reversed, because user will install the hook after tsan runtime. So if user hook calls any intercepted functions or is instrumented, this still will crash.
We can solve it later.

lib/tsan/rtl/tsan_rtl.h

668 ↗

(On Diff #39181)

I think it belongs to tsan_defs.h
tsan_rtl.h includes a bunch of tsan headers, so we won't be able to use the const in any of these headers. For this reason the very base, non-dependent on anything things are declared in tsan_defs.h

lib/tsan/rtl/tsan_rtl_thread.cc

58 ↗

(On Diff #39181)

please-please-please one statement per line

[kubamracek]

Updating patch.

I guess the order will actually be reversed, because user will install the hook after tsan runtime. So if user hook calls any intercepted functions or is instrumented, this still will crash. We can solve it later.

The API is actually private and should not be used by user code (although the header files and API declarations are publicly available on opensource.apple.com). The only user of this hook that I know of is Xcode's debugger, which actually calls the previous function at the beginning of its hook, so we're fine here. Anyway, if this becomes an issue later, I'll take a look at it.

[dvyukov]

LGTM

The only user of this hook that I know of is Xcode's debugger, which actually calls the previous function at the beginning of its hook, so we're fine here.

ack

[zaks.anna]

On OS X, GCD worker threads are created without a call to pthread_create. We need to properly register these threads with ThreadCreate and ThreadStart.

How do we deal with these in ASan?

[dvyukov]

How do we deal with these in ASan?

In asan we can deal with the case when we don't have an initialized thread:

AsanThread *t = GetCurrentThread();
void *allocated;
bool check_rss_limit = true;
if (t) {
  AllocatorCache *cache = GetAllocatorCache(&t->malloc_storage());
  allocated =
      allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
} else {
  SpinMutexLock l(&fallback_mutex);
  AllocatorCache *cache = &fallback_allocator_cache;
  allocated =
      allocator.Allocate(cache, needed_size, 8, false, check_rss_limit);
}

That was added due to the same problems we are now struggling with tsan (bootstrap, thread start/end on different platforms). But it was easier to solve as in asan thread state is used only as an optimization. This path uses a global mutex for all allocations and deallocations, and so is extremely slow, that is fine because it is meant to be used only during said short periods of time.

Now I wonder if this path is actually heavily used in some contexts (e.g. mac + gcd), but nobody noticed.

compiler-rt/trunk/lib/tsan/rtl/tsan_clock.cc

 #ifndef SANITIZER_GO
 # define CPP_STAT_INC(typ) StatInc(cur_thread(), typ)
 #else
 # define CPP_STAT_INC(typ) (void)0
 #endif
 
 namespace __tsan {
 
-const unsigned kInvalidTid = (unsigned)-1;
-
 ThreadClock::ThreadClock(unsigned tid, unsigned reused)
     : tid_(tid)
     , reused_(reused + 1) {  // 0 has special meaning
   CHECK_LT(tid, kMaxTidInClock);
   CHECK_EQ(reused_, ((u64)reused_ << kClkBits) >> kClkBits);
   nclk_ = tid_ + 1;
   last_acquire_ = 0;
   internal_memset(clk_, 0, sizeof(clk_));

compiler-rt/trunk/lib/tsan/rtl/tsan_defs.h

 const uptr kMetaShadowSize = 4;
 
 #if TSAN_NO_HISTORY
 const bool kCollectHistory = false;
 #else
 const bool kCollectHistory = true;
 #endif
 
+const unsigned kInvalidTid = (unsigned)-1;
+
 // The following "build consistency" machinery ensures that all source files
 // are built in the same configuration. Inconsistent builds lead to
 // hard to debug crashes.
 #if SANITIZER_DEBUG
 void build_consistency_debug();
 #else
 void build_consistency_release();
 #endif

compiler-rt/trunk/lib/tsan/rtl/tsan_interceptors.cc

extern "C" void INTERFACE_ATTRIBUTE __cxa_guard_release(atomic_uint32_t *g) {
   atomic_store(g, 1, memory_order_release);
 }
 
 extern "C" void INTERFACE_ATTRIBUTE __cxa_guard_abort(atomic_uint32_t *g) {
   SCOPED_INTERCEPTOR_RAW(__cxa_guard_abort, g);
   atomic_store(g, 0, memory_order_relaxed);
 }
 
+namespace __tsan {
+void DestroyThreadState() {
+  ThreadState *thr = cur_thread();
+  ThreadFinish(thr);
+  ThreadSignalContext *sctx = thr->signal_ctx;
+  if (sctx) {
+    thr->signal_ctx = 0;
+    UnmapOrDie(sctx, sizeof(*sctx));
+  }
+}
+}  // namespace __tsan
+
 static void thread_finalize(void *v) {
   uptr iter = (uptr)v;
   if (iter > 1) {
     if (pthread_setspecific(g_thread_finalize_key, (void*)(iter - 1))) {
       Printf("ThreadSanitizer: failed to set thread key\n");
       Die();
     }
     return;
   }
-  {
-    ThreadState *thr = cur_thread();
-    ThreadFinish(thr);
-    ThreadSignalContext *sctx = thr->signal_ctx;
-    if (sctx) {
-      thr->signal_ctx = 0;
-      UnmapOrDie(sctx, sizeof(*sctx));
-    }
-  }
+  DestroyThreadState();
 }
 
 
 struct ThreadParam {
   void* (*callback)(void *arg);
   void *param;
   atomic_uintptr_t tid;
 };

compiler-rt/trunk/lib/tsan/rtl/tsan_platform.h

 bool IsGlobalVar(uptr addr);
 int ExtractResolvFDs(void *state, int *fds, int nfd);
 int ExtractRecvmsgFDs(void *msg, int *fds, int nfd);
 
 int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
     void *abstime), void *c, void *m, void *abstime,
     void(*cleanup)(void *arg), void *arg);
 
+void DestroyThreadState();
+
 }  // namespace __tsan
 
 #endif  // TSAN_PLATFORM_H

compiler-rt/trunk/lib/tsan/rtl/tsan_platform_mac.cc

 
 void WriteMemoryProfile(char *buf, uptr buf_size, uptr nthread, uptr nlive) {
 }
 
 #ifndef SANITIZER_GO
 void InitializeShadowMemoryPlatform() { }
 #endif
 
+// On OS X, GCD worker threads are created without a call to pthread_create. We
+// need to properly register these threads with ThreadCreate and ThreadStart.
+// These threads don't have a parent thread, as they are created "spuriously".
+// We're using a libpthread API that notifies us about a newly created thread.
+// The `thread == pthread_self()` check indicates this is actually a worker
+// thread. If it's just a regular thread, this hook is called on the parent
+// thread.
+typedef void (*pthread_introspection_hook_t)(unsigned int event,
+                                             pthread_t thread, void *addr,
+                                             size_t size);
+extern "C" pthread_introspection_hook_t pthread_introspection_hook_install(
+    pthread_introspection_hook_t hook);
+static const uptr PTHREAD_INTROSPECTION_THREAD_CREATE = 1;
+static const uptr PTHREAD_INTROSPECTION_THREAD_DESTROY = 4;
+static pthread_introspection_hook_t prev_pthread_introspection_hook;
+static void my_pthread_introspection_hook(unsigned int event, pthread_t thread,
+                                          void *addr, size_t size) {
+  if (event == PTHREAD_INTROSPECTION_THREAD_CREATE) {
+    if (thread == pthread_self()) {
+      // The current thread is a newly created GCD worker thread.
+      ThreadState *parent_thread_state = nullptr;  // No parent.
+      int tid = ThreadCreate(parent_thread_state, 0, (uptr)thread, true);
+      CHECK_NE(tid, 0);
+      ThreadState *thr = cur_thread();
+      ThreadStart(thr, tid, GetTid());
+    }
+  } else if (event == PTHREAD_INTROSPECTION_THREAD_DESTROY) {
+    ThreadState *thr = cur_thread();
+    if (thr->tctx->parent_tid == kInvalidTid) {
+      DestroyThreadState();
+    }
+  }
+
+  if (prev_pthread_introspection_hook != nullptr)
+    prev_pthread_introspection_hook(event, thread, addr, size);
+}
+
 void InitializePlatform() {
   DisableCoreDumperIfNecessary();
 #ifndef SANITIZER_GO
   CheckAndProtect();
 #endif
+
+  prev_pthread_introspection_hook =
+      pthread_introspection_hook_install(&my_pthread_introspection_hook);
 }
 
 #ifndef SANITIZER_GO
 // Note: this function runs with async signals enabled,
 // so it must not touch any tsan state.
 int call_pthread_cancel_with_cleanup(int(*fn)(void *c, void *m,
     void *abstime), void *c, void *m, void *abstime,
     void(*cleanup)(void *arg), void *arg) {

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl_thread.cc

struct OnCreatedArgs {
   uptr pc;
 };
 
 void ThreadContext::OnCreated(void *arg) {
   thr = 0;
   if (tid == 0)
     return;
   OnCreatedArgs *args = static_cast<OnCreatedArgs *>(arg);
+  if (!args->thr)  // GCD workers don't have a parent thread.
+    return;
   args->thr->fast_state.IncrementEpoch();
   // Can't increment epoch w/o writing to the trace as well.
   TraceAddEvent(args->thr, args->thr->fast_state, EventTypeMop, 0);
   ReleaseImpl(args->thr, 0, &sync);
   creation_stack_id = CurrentStackId(args->thr, args->pc);
   if (reuse_count == 0)
     StatInc(args->thr, StatThreadMaxTid);
 }
int ThreadCount(ThreadState *thr) {
   uptr result;
   ctx->thread_registry->GetNumberOfThreads(0, 0, &result);
   return (int)result;
 }
 
 int ThreadCreate(ThreadState *thr, uptr pc, uptr uid, bool detached) {
   StatInc(thr, StatThreadCreate);
   OnCreatedArgs args = { thr, pc };
-  int tid = ctx->thread_registry->CreateThread(uid, detached, thr->tid, &args);
-  DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", thr->tid, tid, uid);
+  u32 parent_tid = thr ? thr->tid : kInvalidTid;  // No parent for GCD workers.
+  int tid =
+      ctx->thread_registry->CreateThread(uid, detached, parent_tid, &args);
+  DPrintf("#%d: ThreadCreate tid=%d uid=%zu\n", parent_tid, tid, uid);
   StatSet(thr, StatThreadMaxAlive, ctx->thread_registry->GetMaxAliveThreads());
   return tid;
 }
 
 void ThreadStart(ThreadState *thr, int tid, uptr os_id) {
   uptr stk_addr = 0;
   uptr stk_size = 0;
   uptr tls_addr = 0;