[msan] Deadly signal handler for msan

[vitalybuka]

Summary

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

[eugenis]

compiler-rt/lib/msan/msan_interceptors.cc

1268

Where is this used? Missing file?

[vitalybuka]

compiler-rt/lib/msan/msan_interceptors.cc

1268

sanitizer_common_interceptors.inc

[vitalybuka]

compiler-rt/lib/msan/msan_interceptors.cc

1268

sorry, "sanitizer_common/sanitizer_signal_interceptors.inc"

[vitalybuka]

compiler-rt/lib/msan/msan_interceptors.cc

1268

https://reviews.llvm.org/D39870

1268

I thought I've submitted that one already :-)

[eugenis]

compiler-rt/lib/msan/msan_interceptors.cc

1304

I don't like this casts.Where does the definition of struct sigaction come from? Can we move everything to __sanitizer_sigaction?

compiler-rt/lib/msan/msan.cc

void __msan_warning_noreturn() {
   (void)sp;
   PrintWarning(pc, bp);
   if (__msan::flags()->print_stats)
     ReportStats();
   Printf("Exiting\n");
   Die();
 }
 
+static void OnStackUnwind(const SignalContext &sig, const void *,
+                          BufferedStackTrace *stack) {
+  GetStackTrace(stack, kStackTraceMax, sig.pc, sig.bp, sig.context,
+                common_flags()->fast_unwind_on_fatal);
+}
+
+static void MsanOnDeadlySignal(int signo, void *siginfo, void *context) {
+  HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr);
+}
+
 void __msan_init() {
   CHECK(!msan_init_is_running);
   if (msan_inited) return;
   msan_init_is_running = 1;
   SanitizerToolName = "MemorySanitizer";
 
   AvoidCVE_2016_2143();
   InitTlsSize();
 
   CacheBinaryName();
   InitializeFlags();
 
   __sanitizer_set_report_path(common_flags()->log_path);
 
   InitializeInterceptors();
+  InstallDeadlySignalHandlers(MsanOnDeadlySignal);
   InstallAtExitHandler(); // Needs __cxa_atexit interceptor.
 
   DisableCoreDumperIfNecessary();
   if (StackSizeIsUnlimited()) {
     VPrintf(1, "Unlimited stack, doing reexec\n");
     // A reasonably large stack size. It is bigger than the usual 8Mb, because,
     // well, the program could have been run with unlimited stack for a reason.
     SetStackSizeLimitInBytes(32 * 1024 * 1024);

compiler-rt/lib/msan/msan_interceptors.cc

static void read_sigaction(const __sanitizer_sigaction *act) {
   CHECK_UNPOISONED(&act->sa_flags, sizeof(act->sa_flags));
   if (act->sa_flags & __sanitizer::sa_siginfo)
     CHECK_UNPOISONED(&act->sigaction, sizeof(act->sigaction));
   else
     CHECK_UNPOISONED(&act->handler, sizeof(act->handler));
   CHECK_UNPOISONED(&act->sa_mask, sizeof(act->sa_mask));
 }
 
-static int sigaction_impl(int signo, const __sanitizer_sigaction *act,
-                          __sanitizer_sigaction *oldact);
-static uptr signal_impl(int signo, uptr cb);
-
-INTERCEPTOR(int, sigaction, int signo, const __sanitizer_sigaction *act,
-            __sanitizer_sigaction *oldact) {
-  return sigaction_impl(signo, act, oldact);
-}
-
-INTERCEPTOR(int, signal, int signo, uptr cb) {
-  cb = signal_impl(signo, cb);
-  return REAL(signal)(signo, cb);
-}
-
 extern "C" int pthread_attr_init(void *attr);
 extern "C" int pthread_attr_destroy(void *attr);
 
 static void *MsanThreadStartFunc(void *arg) {
   MsanThread *t = (MsanThread *)arg;
   SetCurrentThread(t);
   return t->ThreadStart();
 }
do {                                                      \
     GET_STORE_STACK_TRACE;                                  \
     CopyShadowAndOrigin(to, from, size, &stack);            \
     __msan_unpoison(to + size, 1);                          \
   } while (false)
 
 #include "sanitizer_common/sanitizer_platform_interceptors.h"
 #include "sanitizer_common/sanitizer_common_interceptors.inc"
 
+static uptr signal_impl(int signo, uptr cb);
+static int sigaction_impl(int signo, const __sanitizer_sigaction *act,
+                          __sanitizer_sigaction *oldact);
+
+#define SIGNAL_INTERCEPTOR_SIGACTION_IMPL(signo, act, oldact)        \
+  {                                                                  \
+    return sigaction_impl(signo, (const __sanitizer_sigaction *)act, \
+                          (__sanitizer_sigaction *)oldact);          \
+  }
+
+#define SIGNAL_INTERCEPTOR_SIGNAL_IMPL(func, signo, handler) \
+  {                                                          \
+    handler = (void *)signal_impl(signo, (uptr)handler);     \
+    return REAL(func)(signo, handler);                       \
+  }
+
+#include "sanitizer_common/sanitizer_signal_interceptors.inc"
 
 static int sigaction_impl(int signo, const __sanitizer_sigaction *act,
                           __sanitizer_sigaction *oldact) {
   ENSURE_MSAN_INITED();
   if (act) read_sigaction(act);
   int res;
   if (flags()->wrap_signals) {
     SpinMutexLock lock(&sigactions_mu);
     CHECK_LT(signo, kMaxSignals);
     uptr old_cb = atomic_load(&sigactions[signo], memory_order_relaxed);
     __sanitizer_sigaction new_act;
     __sanitizer_sigaction *pnew_act = act ? &new_act : nullptr;
     if (act) {
       REAL(memcpy)(pnew_act, act, sizeof(__sanitizer_sigaction));
       uptr cb = (uptr)pnew_act->sigaction;
       uptr new_cb = (pnew_act->sa_flags & __sanitizer::sa_siginfo)
                         ? (uptr)SignalAction
                         : (uptr)SignalHandler;
       if (cb != __sanitizer::sig_ign && cb != __sanitizer::sig_dfl) {
         atomic_store(&sigactions[signo], cb, memory_order_relaxed);
         pnew_act->sigaction = (void (*)(int, void *, void *))new_cb;
       }
     }
-    res = REAL(sigaction)(signo, pnew_act, oldact);
+    res = REAL(sigaction)(signo, (const struct sigaction *)pnew_act,
+                          (struct sigaction *)oldact);
     if (res == 0 && oldact) {
       uptr cb = (uptr)oldact->sigaction;
       if (cb != __sanitizer::sig_ign && cb != __sanitizer::sig_dfl) {
         oldact->sigaction = (void (*)(int, void *, void *))old_cb;
       }
     }
   } else {
-    res = REAL(sigaction)(signo, act, oldact);
+    res = REAL(sigaction)(signo, (const struct sigaction *)act,
+                          (struct sigaction *)oldact);
   }
 
   if (res == 0 && oldact) {
     __msan_unpoison(oldact, sizeof(__sanitizer_sigaction));
   }
   return res;
 }
 

 }
 
 namespace __msan {
 
 void InitializeInterceptors() {
   static int inited = 0;
   CHECK_EQ(inited, 0);
   InitializeCommonInterceptors();
+  InitializeSignalInterceptors();
 
   INTERCEPT_FUNCTION(mmap);
   MSAN_MAYBE_INTERCEPT_MMAP64;
   INTERCEPT_FUNCTION(posix_memalign);
   MSAN_MAYBE_INTERCEPT_MEMALIGN;
   INTERCEPT_FUNCTION(__libc_memalign);
   INTERCEPT_FUNCTION(valloc);
   MSAN_MAYBE_INTERCEPT_PVALLOC;

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: msan
 // XFAIL: tsan
 
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>
 
 void death() {
   fprintf(stderr, "DEATH CALLBACK\n");

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

 // Test the handle_sigill option.
 
 // clang-format off
 // RUN: %clang %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: msan
 // XFAIL: tsan
 // XFAIL: ubsan
 //
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>

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: msan
 // 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: msan
 // 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: %clang %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: msan
 // XFAIL: tsan
 // XFAIL: ubsan
 //
 // FIXME: seems to fail on ARM
 // REQUIRES: x86_64-target-arch
 #include <assert.h>
 #include <stdio.h>
 #include <sanitizer/asan_interface.h>

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: msan
 // 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>