[tsan] Deadly signal handler for tsan

[vitalybuka]

Summary

https://github.com/google/sanitizers/issues/637

[vitalybuka]

Rebase

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

 static void rtl_sighandler(int sig) {
   rtl_generic_sighandler(false, sig, 0, 0);
 }
 
 static void rtl_sigaction(int sig, __sanitizer_siginfo *info, void *ctx) {
   rtl_generic_sighandler(true, sig, info, ctx);
 }
 
-static int sigaction_impl(int sig, __sanitizer_sigaction *act,
-                          __sanitizer_sigaction *old);
-static __sanitizer_sighandler_ptr signal_impl(int sig,
-                                              __sanitizer_sighandler_ptr h);
-
-TSAN_INTERCEPTOR(int, sigaction, int sig, __sanitizer_sigaction *act,
-                 __sanitizer_sigaction *old) {
-  return sigaction_impl(sig, act, old);
-}
-
-TSAN_INTERCEPTOR(__sanitizer_sighandler_ptr, signal, int sig,
-                 __sanitizer_sighandler_ptr h) {
-  return signal_impl(sig, h);
-}
-
 TSAN_INTERCEPTOR(int, raise, int sig) {
   SCOPED_TSAN_INTERCEPTOR(raise, sig);
   ThreadSignalContext *sctx = SigCtx(thr);
   CHECK_NE(sctx, 0);
   int prev = sctx->int_signal_send;
   sctx->int_signal_send = sig;
   int res = REAL(raise)(sig);
   CHECK_EQ(sctx->int_signal_send, sig);

 #define COMMON_INTERCEPTOR_USER_CALLBACK_START() \
   SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_START()
 
 #define COMMON_INTERCEPTOR_USER_CALLBACK_END() \
   SCOPED_TSAN_INTERCEPTOR_USER_CALLBACK_END()
 
 #include "sanitizer_common/sanitizer_common_interceptors.inc"
 
-// TODO(vitalybuka): use sanitizer_signal_interceptors.inc here.
+static int sigaction_impl(int sig, const __sanitizer_sigaction *act,
+                          __sanitizer_sigaction *old);
+static __sanitizer_sighandler_ptr signal_impl(int sig,
+                                              __sanitizer_sighandler_ptr h);
+
+#define SIGNAL_INTERCEPTOR_SIGACTION_IMPL(signo, act, oldact) \
+  { return sigaction_impl(signo, act, oldact); }
+
+#define SIGNAL_INTERCEPTOR_SIGNAL_IMPL(func, signo, handler) \
+  { return (uptr)signal_impl(signo, (__sanitizer_sighandler_ptr)handler); }
+
+#include "sanitizer_common/sanitizer_signal_interceptors.inc"
 
-int sigaction_impl(int sig, __sanitizer_sigaction *act,
+int sigaction_impl(int sig, const __sanitizer_sigaction *act,
                    __sanitizer_sigaction *old) {
   // Note: if we call REAL(sigaction) directly for any reason without proxying
   // the signal handler through rtl_sigaction, very bad things will happen.
   // The handler will run synchronously and corrupt tsan per-thread state.
   SCOPED_INTERCEPTOR_RAW(sigaction, sig, act, old);
   __sanitizer_sigaction *sigactions = interceptor_ctx()->sigactions;
   if (old) internal_memcpy(old, &sigactions[sig], sizeof(*old));
   if (act == 0) return 0;
   // Copy act into sigactions[sig].
   // Can't use struct copy, because compiler can emit call to memcpy.
   // Can't use internal_memcpy, because it copies byte-by-byte,
   // and signal handler reads the handler concurrently. It it can read
   // some bytes from old value and some bytes from new value.
   // Use volatile to prevent insertion of memcpy.
   sigactions[sig].handler =
-      *(volatile __sanitizer_sighandler_ptr *)&act->handler;
-  sigactions[sig].sa_flags = *(volatile int *)&act->sa_flags;
+      *(volatile __sanitizer_sighandler_ptr const *)&act->handler;
+  sigactions[sig].sa_flags = *(volatile int const *)&act->sa_flags;
   internal_memcpy(&sigactions[sig].sa_mask, &act->sa_mask,
                   sizeof(sigactions[sig].sa_mask));
 #if !SANITIZER_FREEBSD && !SANITIZER_MAC && !SANITIZER_NETBSD
   sigactions[sig].sa_restorer = act->sa_restorer;
 #endif
   __sanitizer_sigaction newact;
   internal_memcpy(&newact, act, sizeof(newact));
   internal_sigfillset(&newact.sa_mask);

 #if SANITIZER_LINUX
   mallopt(1, 0);  // M_MXFAST
   mallopt(-3, 32*1024);  // M_MMAP_THRESHOLD
 #endif
 
   new(interceptor_ctx()) InterceptorContext();
 
   InitializeCommonInterceptors();
+  InitializeSignalInterceptors();
 
 #if !SANITIZER_MAC
   // We can not use TSAN_INTERCEPT to get setjmp addr,
   // because it does &setjmp and setjmp is not present in some versions of libc.
   using __interception::GetRealFunctionAddress;
   GetRealFunctionAddress("setjmp", (uptr*)&REAL(setjmp), 0, 0);
   GetRealFunctionAddress("_setjmp", (uptr*)&REAL(_setjmp), 0, 0);
   GetRealFunctionAddress("sigsetjmp", (uptr*)&REAL(sigsetjmp), 0, 0);
#endif
   TSAN_MAYBE_INTERCEPT_TMPFILE64;
   TSAN_INTERCEPT(fread);
   TSAN_INTERCEPT(fwrite);
   TSAN_INTERCEPT(abort);
   TSAN_INTERCEPT(puts);
   TSAN_INTERCEPT(rmdir);
   TSAN_INTERCEPT(closedir);
 
-  TSAN_INTERCEPT(sigaction);
-  TSAN_INTERCEPT(signal);
   TSAN_INTERCEPT(sigsuspend);
   TSAN_INTERCEPT(sigblock);
   TSAN_INTERCEPT(sigsetmask);
   TSAN_INTERCEPT(pthread_sigmask);
   TSAN_INTERCEPT(raise);
   TSAN_INTERCEPT(kill);
   TSAN_INTERCEPT(pthread_kill);
   TSAN_INTERCEPT(sleep);

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

for (uptr p0 = beg; p0 <= end; p0 += (end - beg) / 4) {
                    (p - prev) / kMetaShadowCell);
         }
         prev = p;
       }
     }
   }
 }
 
+#if !SANITIZER_GO
+static void OnStackUnwind(const SignalContext &sig, const void *,
+                          BufferedStackTrace *stack) {
+  uptr top = 0;
+  uptr bottom = 0;
+  bool fast = common_flags()->fast_unwind_on_fatal;
+  if (fast) GetThreadStackTopAndBottom(false, &top, &bottom);
+  stack->Unwind(kStackTraceMax, sig.pc, sig.bp, sig.context, top, bottom, fast);
+}
+
+static void TsanOnDeadlySignal(int signo, void *siginfo, void *context) {
+  HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr);
+}
+#endif
+
 void Initialize(ThreadState *thr) {
   // Thread safe because done before all threads exist.
   static bool is_initialized = false;
   if (is_initialized)
     return;
   is_initialized = true;
   // We are not ready to handle interceptors yet.
   ScopedIgnoreInterceptors ignore;
#endif
   InitializeInterceptors();
   CheckShadowMapping();
   InitializePlatform();
   InitializeMutex();
   InitializeDynamicAnnotations();
 #if !SANITIZER_GO
   InitializeShadowMemory();
   InitializeAllocatorLate();
+  InstallDeadlySignalHandlers(TsanOnDeadlySignal);
 #endif
   // Setup correct file descriptor for error reports.
   __sanitizer_set_report_path(common_flags()->log_path);
   InitializeSuppressions();
 #if !SANITIZER_GO
   InitializeLibIgnore();
   Symbolizer::GetOrInit()->AddHooks(EnterSymbolizer, ExitSymbolizer);
   // On MIPS, TSan initialization is run before

compiler-rt/test/sanitizer_common/TestCases/Linux/assert.cc

 // Test the handle_abort option.
 
 // clang-format off
 // RUN: %clangxx %s -o %t
 // RUN:                              not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_abort=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_abort=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // clang-format on
 
-// FIXME: implement in other sanitizers.
-// XFAIL: tsan
-
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {
   fprintf(stderr, "DEATH CALLBACK\n");
 }
 
 int main(int argc, char **argv) {
   __sanitizer_set_death_callback(death);
   assert(argc == 100);
 }
 // CHECK1: ERROR: {{.*}}Sanitizer:
 // CHECK1: DEATH CALLBACK
 // CHECK0-NOT: Sanitizer

compiler-rt/test/sanitizer_common/TestCases/Linux/ill.cc

 // Test the handle_sigill option.
 
 // clang-format off
 // RUN: %clangxx %s -o %t -O1
 // RUN:                                not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigill=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigill=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // clang-format on
 
-// FIXME: implement in other sanitizers.
-// XFAIL: tsan
-
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {
   fprintf(stderr, "DEATH CALLBACK\n");

compiler-rt/test/sanitizer_common/TestCases/Posix/dedup_token_length_test.cc

 // Test dedup_token_length
 // RUN: %clangxx -O0 %s -o %t
 // RUN: env %tool_options='abort_on_error=0'                       not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=0' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK0 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=1' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK1 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=2' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK2 --match-full-lines
 // RUN: env %tool_options='abort_on_error=0, dedup_token_length=3' not %run %t 2>&1   | FileCheck %s --check-prefix=CHECK3 --match-full-lines
 
 // REQUIRES: stable-runtime
-// FIXME: implement SEGV handler in other sanitizers.
-// XFAIL: tsan
 
 volatile int *null = 0;
 
 namespace Xyz {
   template<class A, class B> void Abc() {
     *null = 0;
   }
 }

compiler-rt/test/sanitizer_common/TestCases/Posix/dump_instruction_bytes.cc

 // Check that sanitizer prints the faulting instruction bytes on
 // dump_instruction_bytes=1
 
 // clang-format off
 // RUN: %clangxx  %s -o %t
 // RUN: %env_tool_opts=dump_instruction_bytes=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-DUMP
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NODUMP
 // clang-format on
 
 // REQUIRES: x86-target-arch
-// FIXME: implement in other sanitizers.
-// XFAIL: tsan
 
 int main() {
 #if defined(__x86_64__)
   asm("movq $0, %rax");
   asm("movl $0xcafebabe, 0x0(%rax)");
 #elif defined(i386)
   asm("movl $0, %eax");
   asm("movl $0xcafebabe, 0x0(%eax)");
 #endif
   // CHECK-DUMP: First 16 instruction bytes at pc: c7 00 be ba fe ca
   // CHECK-NODUMP-NOT: First 16 instruction bytes
   return 0;
 }

compiler-rt/test/sanitizer_common/TestCases/Posix/fpe.cc

 // Test the handle_sigfpe option.
 // RUN: %clangxx %s -o %t
 // RUN:                               not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 // RUN: %env_tool_opts=handle_sigfpe=0 not --crash %run %t 2>&1 | FileCheck --check-prefix=CHECK0 %s
 // RUN: %env_tool_opts=handle_sigfpe=1 not         %run %t 2>&1 | FileCheck --check-prefix=CHECK1 %s
 
-// FIXME: implement in other sanitizers, not just asan.
-// XFAIL: tsan
-
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {
   fprintf(stderr, "DEATH CALLBACK\n");

compiler-rt/test/sanitizer_common/TestCases/Posix/sanitizer_set_report_fd_test.cc

 // Test __sanitizer_set_report_fd:
 // RUN: %clangxx -O2 %s -o %t
 // RUN: not %run %t 2>&1   | FileCheck %s
 // RUN: not %run %t stdout | FileCheck %s
 // RUN: not %run %t %t-out && FileCheck < %t-out %s
 
 // REQUIRES: stable-runtime
 // XFAIL: android && asan
-// FIXME: implement SEGV handler in other sanitizers, not just asan.
-// XFAIL: tsan
 
 #include <sanitizer/common_interface_defs.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>