[lsan] Deadly signal handler for lsan

[vitalybuka]

Summary

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

[vitalybuka]

Thread id

[vitalybuka]

Windows

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

296

This is mainly a copy of signal handling code from ASan. Are you going to remove the original?

[vitalybuka]

Rebase

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

296

This is almost copy and i'd like to use it for other sanitizes.
Asan report includes scariness score and other asan specific info. So for now I am going to keep asan copy as is and reconsider code reuse later.

[eugenis]

That's a lot of duplicated code. I'd prefer if you factored out common parts first.

[vitalybuka]

lock

[eugenis]

compiler-rt/lib/lsan/lsan.cc

77

What if we are already holding this lock?

[vitalybuka]

Added nested signal protection.

[vitalybuka]

Rebase

compiler-rt/lib/asan/asan_errors.cc

static void MaybeDumpInstructionBytes(uptr pc) {
   Report("%s", str.data());
 }
 
 static void MaybeDumpRegisters(void *context) {
   if (!flags()->dump_registers) return;
   SignalContext::DumpAllRegisters(context);
 }
 
-static void MaybeReportNonExecRegion(uptr pc) {
-#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
-  MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
-  MemoryMappedSegment segment;
-  while (proc_maps.Next(&segment)) {
-    if (pc >= segment.start && pc < segment.end && !segment.IsExecutable())
-      Report("Hint: PC is at a non-executable region. Maybe a wild jump?\n");
-  }
-#endif
-}
-
 void ErrorDeadlySignal::Print() {
   Decorator d;
   Printf("%s", d.Warning());
   const char *description = __sanitizer::DescribeSignalOrException(signo);
   Report(
       "ERROR: AddressSanitizer: %s on unknown address %p (pc %p bp %p sp %p "
       "T%d)\n",
       description, (void *)addr, (void *)pc, (void *)bp, (void *)sp, tid);

compiler-rt/lib/lsan/lsan.cc

static void InitializeFlags() {
 
   SetVerbosity(common_flags()->verbosity);
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 
+void LsanOnDeadlySignal(int signo, void *siginfo, void *context) {
+  BufferedStackTrace stack;
+  ReportDeadlySignalAndDie(signo, siginfo, context, GetCurrentThread(), &stack);
+}
+
 extern "C" void __lsan_init() {
   CHECK(!lsan_init_is_running);
   if (lsan_inited)
     return;
   lsan_init_is_running = true;
   SanitizerToolName = "LeakSanitizer";
   CacheBinaryName();
   AvoidCVE_2016_2143();
   InitializeFlags();
   InitCommonLsan();
   InitializeAllocator();
   ReplaceSystemMalloc();
   InitTlsSize();
   InitializeInterceptors();
   InitializeThreadRegistry();
+  InstallDeadlySignalHandlers(LsanOnDeadlySignal);
   u32 tid = ThreadCreate(0, 0, true);
   CHECK_EQ(tid, 0);
   ThreadStart(tid, GetTid());
   SetCurrentThread(tid);
 
   if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
     Atexit(DoLeakCheck);
 

compiler-rt/lib/lsan/lsan_interceptors.cc

INTERCEPTOR(int, pthread_join, void *th, void **ret) {
   return res;
 }
 
 INTERCEPTOR(void, _exit, int status) {
   if (status == 0 && HasReportedLeaks()) status = common_flags()->exitcode;
   REAL(_exit)(status);
 }
 
+INTERCEPTOR(void *, signal, int signum, void *handler) {
+  if (GetHandleSignalMode(signum) != kHandleSignalExclusive)
+    return REAL(signal)(signum, handler);
+  return nullptr;
+}
+
+INTERCEPTOR(int, sigaction, int signum, const struct sigaction *act,
+            struct sigaction *oldact) {
+  if (GetHandleSignalMode(signum) != kHandleSignalExclusive)
+    return REAL(sigaction)(signum, act, oldact);
+  return 0;
+}
+
+namespace __sanitizer {
+int real_sigaction(int signum, const void *act, void *oldact) {
+  return REAL(sigaction)(signum, (const struct sigaction *)act,
+                         (struct sigaction *)oldact);
+}
+}  // namespace __sanitizer
+
 namespace __lsan {
 
 void InitializeInterceptors() {
   INTERCEPT_FUNCTION(malloc);
   INTERCEPT_FUNCTION(free);
   LSAN_MAYBE_INTERCEPT_CFREE;
   INTERCEPT_FUNCTION(calloc);
   INTERCEPT_FUNCTION(realloc);
   LSAN_MAYBE_INTERCEPT_MEMALIGN;
   LSAN_MAYBE_INTERCEPT___LIBC_MEMALIGN;
   LSAN_MAYBE_INTERCEPT_ALIGNED_ALLOC;
   INTERCEPT_FUNCTION(posix_memalign);
   INTERCEPT_FUNCTION(valloc);
   LSAN_MAYBE_INTERCEPT_PVALLOC;
   LSAN_MAYBE_INTERCEPT_MALLOC_USABLE_SIZE;
   LSAN_MAYBE_INTERCEPT_MALLINFO;
   LSAN_MAYBE_INTERCEPT_MALLOPT;
   INTERCEPT_FUNCTION(pthread_create);
   INTERCEPT_FUNCTION(pthread_join);
   INTERCEPT_FUNCTION(_exit);
+  INTERCEPT_FUNCTION(signal);
+  INTERCEPT_FUNCTION(sigaction);
 
   if (pthread_key_create(&g_thread_finalize_key, &thread_finalize)) {
     Report("LeakSanitizer: failed to create thread key.\n");
     Die();
   }
 }
 
 } // namespace __lsan

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 // (exceeded==false).
 // The callback should be registered once at the tool init time.
 void SetSoftRssLimitExceededCallback(void (*Callback)(bool exceeded));
 
 // Functions related to signal handling.
 typedef void (*SignalHandlerType)(int, void *, void *);
 HandleSignalMode GetHandleSignalMode(int signum);
 bool IsStackOverflow(int code, const struct SignalContext &sig);
+void MaybeReportNonExecRegion(uptr pc);
+void ReportDeadlySignalAndDie(int signo, void *siginfo, void *context, u32 tid,
+                              struct BufferedStackTrace *stack);
 void InstallDeadlySignalHandlers(SignalHandlerType handler);
 const char *DescribeSignalOrException(int signo);
 // Alternative signal stack (POSIX-only).
 void SetAlternateSignalStack();
 void UnsetAlternateSignalStack();
 
 // We don't want a summary too long.
 const int kMaxSummaryLength = 1024;

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cc

void GetThreadStackTopAndBottom(bool, uptr *stack_top, uptr *stack_bottom) {
   *stack_bottom = reinterpret_cast<uptr>(base);
   *stack_top = *stack_bottom + size;
 }
 
 void MaybeReexec() {}
 void PrepareForSandboxing(__sanitizer_sandbox_arguments *args) {}
 void DisableCoreDumperIfNecessary() {}
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {}
+void ReportDeadlySignalAndDie(int signo, void *siginfo, void *context, u32 tid,
+                              struct BufferedStackTrace *stack) {}
 void SetAlternateSignalStack() {}
 void UnsetAlternateSignalStack() {}
 void InitTlsSize() {}
 
 void PrintModuleMap() {}
 
 void SignalContext::DumpAllRegisters(void *context) { UNIMPLEMENTED(); }
 const char *DescribeSignalOrException(int signo) { UNIMPLEMENTED(); }

compiler-rt/lib/sanitizer_common/sanitizer_posix_libcdep.cc

 
 #include "sanitizer_common.h"
 #include "sanitizer_flags.h"
 #include "sanitizer_platform_limits_netbsd.h"
 #include "sanitizer_platform_limits_posix.h"
 
 #include "sanitizer_posix.h"
 #include "sanitizer_procmaps.h"
+#include "sanitizer_report_decorator.h"
 #include "sanitizer_stacktrace.h"
 #include "sanitizer_symbolizer.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <signal.h>
 #include <stdlib.h>
void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   if (common_flags()->use_sigaltstack) SetAlternateSignalStack();
   MaybeInstallSigaction(SIGSEGV, handler);
   MaybeInstallSigaction(SIGBUS, handler);
   MaybeInstallSigaction(SIGABRT, handler);
   MaybeInstallSigaction(SIGFPE, handler);
   MaybeInstallSigaction(SIGILL, handler);
 }
 
+static void UnwindSignalStackTrace(const SignalContext &sig,
+                                   BufferedStackTrace *stack) {
+  uptr top = 0;
+  uptr bottom = 0;
+  bool request_fast_unwind = common_flags()->fast_unwind_on_fatal;
+  if (request_fast_unwind) GetThreadStackTopAndBottom(false, &top, &bottom);
+  stack->Unwind(kStackTraceMax, sig.pc, sig.bp, sig.context, top, bottom,
+                request_fast_unwind);
+}
+
+static void ReportStackOverflow(const SignalContext &sig, u32 tid,
+                                const BufferedStackTrace &stack) {
+  SanitizerCommonDecorator d;
+  Printf("%s", d.Warning());
+  static const char kDescription[] = "stack-overflow";
+  Report("ERROR: %s: %s on address %p (pc %p bp %p sp %p T%d)\n",
+         SanitizerToolName, kDescription, (void *)sig.addr, (void *)sig.pc,
+         (void *)sig.bp, (void *)sig.sp, tid);
+  Printf("%s", d.End());
+  stack.Print();
+  ReportErrorSummary(kDescription, &stack);
+}
+
+void MaybeReportNonExecRegion(uptr pc) {
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD
+  MemoryMappingLayout proc_maps(/*cache_enabled*/ true);
+  MemoryMappedSegment segment;
+  while (proc_maps.Next(&segment)) {
+    if (pc >= segment.start && pc < segment.end && !segment.IsExecutable())
+      Report("Hint: PC is at a non-executable region. Maybe a wild jump?\n");
+  }
+#endif
+}
+
+static void ReportNonStackOverflow(int signo, const SignalContext &sig, u32 tid,
+                                   const BufferedStackTrace &stack) {
+  SanitizerCommonDecorator d;
+  Printf("%s", d.Warning());
+  const char *description = __sanitizer::DescribeSignalOrException(signo);
+  Report("ERROR: %s: %s on unknown address %p (pc %p bp %p sp %p T%d)\n",
+         SanitizerToolName, description, (void *)sig.addr, (void *)sig.pc,
+         (void *)sig.bp, (void *)sig.sp, tid);
+  Printf("%s", d.End());
+  if (sig.pc < GetPageSizeCached())
+    Report("Hint: pc points to the zero page.\n");
+  if (sig.is_memory_access) {
+    const char *access_type =
+        sig.write_flag == SignalContext::WRITE
+            ? "WRITE"
+            : (sig.write_flag == SignalContext::READ ? "READ" : "UNKNOWN");
+    Report("The signal is caused by a %s memory access.\n", access_type);
+    if (sig.addr < GetPageSizeCached())
+      Report("Hint: address points to the zero page.\n");
+  }
+  MaybeReportNonExecRegion(sig.pc);
+  stack.Print();
+  Printf("%s can not provide additional info.\n", SanitizerToolName);
+  ReportErrorSummary(description, &stack);
+}
+
+void ReportDeadlySignalAndDie(int signo, void *siginfo, void *context, u32 tid,
+                              BufferedStackTrace *stack) {
+  // Write the first message using fd=2, just in case.
+  // It may actually fail to write in case stderr is closed.
+  internal_write(2, SanitizerToolName, internal_strlen(SanitizerToolName));
+  static const char kDeadlySignal[] = ":DEADLYSIGNAL\n";
+  internal_write(2, kDeadlySignal, sizeof(kDeadlySignal) - 1);
+
+  SignalContext sig = SignalContext::Create(siginfo, context);
+  UnwindSignalStackTrace(sig, stack);
+  if (IsStackOverflow(((siginfo_t *)siginfo)->si_code, sig))
+    ReportStackOverflow(sig, tid, *stack);
+  else
+    ReportNonStackOverflow(signo, sig, tid, *stack);
+  Report("ABORTING\n");
+  Die();
+}
+
 #endif  // SANITIZER_GO
 
 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   uptr page_size = GetPageSizeCached();
   // Checking too large memory ranges is slow.
   CHECK_LT(size, page_size * 10);
   int sock_pair[2];
   if (pipe(sock_pair))

compiler-rt/lib/sanitizer_common/sanitizer_win.cc

void UnsetAlternateSignalStack() {
   // FIXME: Decide what to do on Windows.
 }
 
 void InstallDeadlySignalHandlers(SignalHandlerType handler) {
   (void)handler;
   // FIXME: Decide what to do on Windows.
 }
 
+void ReportDeadlySignalAndDie(int signo, void *siginfo, void *context, u32 tid,
+                              struct BufferedStackTrace *stack) {
+  // FIXME: Decide what to do on Windows.
+}
+
 HandleSignalMode GetHandleSignalMode(int signum) {
   // FIXME: Decide what to do on Windows.
   return kHandleSignalNo;
 }
 
 // Check based on flags if we should handle this exception.
 bool IsHandledDeadlyException(DWORD exceptionCode) {
   switch (exceptionCode) {

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

 // RUN: %env_tool_opts=handle_segv=2:allow_user_segv_handler=0 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
 
 // RUN: %env_tool_opts=handle_segv=0:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK0
 // RUN: %env_tool_opts=handle_segv=1:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK1
 // RUN: %env_tool_opts=handle_segv=2:allow_user_segv_handler=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK2
 // clang-format on
 
 // Remove when fixed: https://github.com/google/sanitizers/issues/637
-// UNSUPPORTED: lsan
 // UNSUPPORTED: msan
 // UNSUPPORTED: tsan
 
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 struct sigaction original_sigaction_sigbus;
int main() {
   // 32-bit Darwin triggers SIGBUS instead.
   if (InstallHandler(SIGSEGV, &original_sigaction_sigsegv) &&
       InstallHandler(SIGBUS, &original_sigaction_sigbus)) {
     fprintf(stderr, "User sigaction installed\n");
   }
   return DoSEGV();
 }
 
-// CHECK0-NOT: ASAN:DEADLYSIGNAL
-// CHECK0-NOT: AddressSanitizer: SEGV on unknown address
+// CHECK0-NOT: Sanitizer:DEADLYSIGNAL
+// CHECK0-NOT: Sanitizer: SEGV on unknown address
 // CHECK0: User sigaction installed
 // CHECK0-NEXT: User sigaction called
 
 // CHECK1: User sigaction installed
 // CHECK1-NEXT: User sigaction called
-// CHECK1-NEXT: ASAN:DEADLYSIGNAL
-// CHECK1: AddressSanitizer: SEGV on unknown address
+// CHECK1-NEXT: {{Leak|Address}}Sanitizer:DEADLYSIGNAL
+// CHECK1: {{Leak|Address}}Sanitizer: SEGV on unknown address
 
 // CHECK2-NOT: User sigaction called
 // CHECK2: User sigaction installed
-// CHECK2-NEXT: ASAN:DEADLYSIGNAL
-// CHECK2: AddressSanitizer: SEGV on unknown address
+// CHECK2-NEXT: {{Leak|Address}}Sanitizer:DEADLYSIGNAL
+// CHECK2: {{Leak|Address}}Sanitizer: SEGV on unknown address

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

 // Test the handle_abort option.
 // RUN: %clang %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
 // FIXME: implement in other sanitizers, not just asan.
 // XFAIL: msan
-// XFAIL: lsan
 // 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.
 // 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
 // FIXME: implement in other sanitizers, not just asan.
 // XFAIL: msan
-// XFAIL: lsan
 // XFAIL: tsan
 //
 // 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, not just asan.
 // XFAIL: msan
-// XFAIL: lsan
 // XFAIL: tsan
 
 volatile int *null = 0;
 
 namespace Xyz {
   template<class A, class B> void Abc() {
     *null = 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: lsan
 // XFAIL: tsan
 //
 // 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
 // FIXME: implement SEGV handler in other sanitizers, not just asan.
 // XFAIL: msan
-// XFAIL: lsan
 // 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>