tsan: don't call dlsym during exit

[dvyukov]

Summary

dlsym calls into dynamic linker which calls malloc and other things.
It's problematic to do it during the actual exit, because
it can happen from a singal handler or from within the runtime
after we reported the first bug, etc.
See https://github.com/google/sanitizers/issues/1440 for an example
(captured in the added test).
Initialize the callbacks during startup instead.

Depends on D110159.

[• vlovich]

compiler-rt/test/tsan/signal_exit.cpp

20

Using raise might be nicer as it’s guaranteed to only return once the signal handler has run. Avoids the need for a non-deterministic sleep.

[dvyukov]

use raise instead of kill

[dvyukov]

compiler-rt/test/tsan/signal_exit.cpp

20

Done. Please take another look.

[vitalybuka]

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

76–77

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

39–42

61

Maybe: Probably cleaner to cast just after dlsym and do not keep them as void*.

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

989–990

[vitalybuka]

LGTM with nits

[dvyukov]

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

39–42

I like more encapsulation, but tsan_rtl.cpp is mostly abstract logic independent of platform. It's not a good idea to include <dlfcn.h> here and call dlsym (at the very least won't compile for windows).

I can't think of a simple way to do this. So I fixed types of the callbacks, but kept code where it is.
If you have any suggestions, I will fix.

61

Done.

[dvyukov]

use real types for the callbacks

[dvyukov]

remove unnecessary parent revision

compiler-rt/lib/tsan/rtl/tsan_interface.h

 void __tsan_go_atomic64_exchange(ThreadState *thr, uptr cpc, uptr pc, u8 *a);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic32_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,
                                          u8 *a);
 SANITIZER_INTERFACE_ATTRIBUTE
 void __tsan_go_atomic64_compare_exchange(ThreadState *thr, uptr cpc, uptr pc,
                                          u8 *a);
 
-SANITIZER_INTERFACE_ATTRIBUTE
-void __tsan_on_initialize();
-
-SANITIZER_INTERFACE_ATTRIBUTE
-int __tsan_on_finalize(int failed);
-
 }  // extern "C"
 
 }  // namespace __tsan
 
 #endif  // TSAN_INTERFACE_H

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

 //===-- tsan_platform_posix.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer (TSan), a race detector.
 //
 // POSIX-specific code.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_POSIX
 
-#include "sanitizer_common/sanitizer_common.h"
-#include "sanitizer_common/sanitizer_errno.h"
-#include "sanitizer_common/sanitizer_libc.h"
-#include "sanitizer_common/sanitizer_procmaps.h"
-#include "tsan_platform.h"
-#include "tsan_rtl.h"
+#  include <dlfcn.h>
+
+#  include "sanitizer_common/sanitizer_common.h"
+#  include "sanitizer_common/sanitizer_errno.h"
+#  include "sanitizer_common/sanitizer_libc.h"
+#  include "sanitizer_common/sanitizer_procmaps.h"
+#  include "tsan_platform.h"
+#  include "tsan_rtl.h"
 
 namespace __tsan {
 
 static const char kShadowMemoryMappingWarning[] =
     "FATAL: %s can not madvise shadow region [%zx, %zx] with %s (errno: %d)\n";
 static const char kShadowMemoryMappingHint[] =
     "HINT: if %s is not supported in your environment, you may set "
     "TSAN_OPTIONS=%s=0\n";
if (!MmapFixedSuperNoReserve(meta, meta_size, "meta shadow")) {
     Printf("FATAL: Make sure to compile with -fPIE and to link with -pie.\n");
     Die();
   }
   DontDumpShadow(meta, meta_size);
   DPrintf("meta shadow: %zx-%zx (%zuGB)\n",
       meta, meta + meta_size, meta_size >> 30);
 
   InitializeShadowMemoryPlatform();
+
+  on_initialize = reinterpret_cast<void (*)(void)>(
+      dlsym(RTLD_DEFAULT, "__tsan_on_initialize"));
+  on_finalize =
+      reinterpret_cast<int (*)(int)>(dlsym(RTLD_DEFAULT, "__tsan_on_finalize"));
 }
 
 static bool TryProtectRange(uptr beg, uptr end) {
   CHECK_LE(beg, end);
   if (beg == end)
     return true;
   return beg == (uptr)MmapFixedNoAccess(beg, end - beg);
 }

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

 void TraceFunc(ThreadState *thr, uptr pc = 0);
 void TraceMutexLock(ThreadState *thr, EventType type, uptr pc, uptr addr,
                     StackID stk);
 void TraceMutexUnlock(ThreadState *thr, uptr addr);
 void TraceTime(ThreadState *thr);
 
 }  // namespace v3
 
+#if !SANITIZER_GO
+extern void (*on_initialize)(void);
+extern int (*on_finalize)(int);
+#endif
+
 }  // namespace __tsan
 
 #endif  // TSAN_RTL_H

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

 volatile int __tsan_resumed = 0;
 
 extern "C" void __tsan_resume() {
   __tsan_resumed = 1;
 }
 
 namespace __tsan {
 
+#if !SANITIZER_GO
+void (*on_initialize)(void);
+int (*on_finalize)(int);
+#endif
+
 #if !SANITIZER_GO && !SANITIZER_MAC
 __attribute__((tls_model("initial-exec")))
 THREADLOCAL char cur_thread_placeholder[sizeof(ThreadState)] ALIGNED(64);
 #endif
 static char ctx_placeholder[sizeof(Context)] ALIGNED(64);
 Context *ctx;
 
 // Can be overriden by a front-end.
 #ifdef TSAN_EXTERNAL_HOOKS
 bool OnFinalize(bool failed);
 void OnInitialize();
 #else
 #include <dlfcn.h>
 SANITIZER_WEAK_CXX_DEFAULT_IMPL
 bool OnFinalize(bool failed) {
 #if !SANITIZER_GO
-  if (auto *ptr = dlsym(RTLD_DEFAULT, "__tsan_on_finalize"))
-    return reinterpret_cast<decltype(&__tsan_on_finalize)>(ptr)(failed);
+  if (on_finalize)
+    return on_finalize(failed);
 #endif
   return failed;
 }
 SANITIZER_WEAK_CXX_DEFAULT_IMPL
 void OnInitialize() {
 #if !SANITIZER_GO
-  if (auto *ptr = dlsym(RTLD_DEFAULT, "__tsan_on_initialize")) {
-    return reinterpret_cast<decltype(&__tsan_on_initialize)>(ptr)();
-  }
+  if (on_initialize)
+    on_initialize();
 #endif
 }
 #endif
 
 static ThreadContextBase *CreateThreadContext(Tid tid) {
   // Map thread trace when context is created.
   char name[50];
   internal_snprintf(name, sizeof(name), "trace %u", tid);

compiler-rt/test/tsan/signal_exit.cpp

+// RUN: %clang_tsan -O1 %s -o %t && %run %t 2>&1 | FileCheck %s
+#include "test.h"
+#include <signal.h>
+#include <sys/types.h>
+
+static void handler(int, siginfo_t *, void *) {
+  write(2, "SIGNAL\n", 7);
+  // CHECK: SIGNAL
+  _exit(0);
+  // CHECK-NOT: ThreadSanitizer: signal-unsafe call
+}
+
+int main() {
+  struct sigaction act = {};
+  act.sa_sigaction = &handler;
+  act.sa_flags = SA_SIGINFO;
+  sigaction(SIGPROF, &act, 0);
+  raise(SIGPROF);
+  fprintf(stderr, "DONE\n");
+  // CHECK-NOT: DONE
+  return 0;
+}