Add NetBSD LSan support

[krytarowski]

Summary

Combine few relatively small changes into one:

• implement internal_ptrace() and internal_clone() for NetBSD
• add support for stoptheworld based on the ptrace(2) API
• define COMPILER_RT_HAS_LSAN for NetBSD
• enable tests for NetBSD/amd64

Inspired by the original implementation by Christos Zoulas in netbsd/src for GCC.

The implementation is in theory CPU independent through well defined macros
across all NetBSD ports, however only the x86_64 version was tested.

[krytarowski]

• Fixup style.

[krytarowski]

This code in general works.. however the tests are not compatible with NetBSD.

Please see:

$ env LSAN_OPTIONS=report_objects=1:use_stacks=1:use_registers=1 /public/llvm-build/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_unaligned.cc.tmp
Test alloc: 0x61a000000000 

=================================================================
==6705==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 1337 byte(s) in 1 object(s) allocated from:
    #0 0x4048f5 in malloc /public/llvm/projects/compiler-rt/lib/lsan/lsan_interceptors.cc:54:3
    #1 0x41e308 in main /public/compiler-rt/test/lsan/TestCases/use_unaligned.cc:15:13
    #2 0x4032bc in ___start (/public/llvm-build/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_unaligned.cc.tmp+0x4032bc)

Objects leaked above:
0x61a000000000 (1337 bytes)

SUMMARY: LeakSanitizer: 1337 byte(s) leaked in 1 allocation(s).

$ env LSAN_OPTIONS=report_objects=1:use_stacks=0:use_registers=1 /public/llvm-build/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_unaligned.cc.tmp
Test alloc: 0x61a000000000 

=================================================================
==6026==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 1337 byte(s) in 1 object(s) allocated from:
    #0 0x4048f5 in malloc /public/llvm/projects/compiler-rt/lib/lsan/lsan_interceptors.cc:54:3
    #1 0x41e308 in main /public/compiler-rt/test/lsan/TestCases/use_unaligned.cc:15:13
    #2 0x4032bc in ___start (/public/llvm-build/projects/compiler-rt/test/lsan/X86_64LsanConfig/TestCases/Output/use_unaligned.cc.tmp+0x4032bc)

Objects leaked above:
0x61a000000000 (1337 bytes)

Direct leak of 32 byte(s) in 1 object(s) allocated from:
    #0 0x4048f5 in malloc /public/llvm/projects/compiler-rt/lib/lsan/lsan_interceptors.cc:54:3
    #1 0x7f7ff6160e67 in atexit_handler_alloc /usr/src/lib/libc/stdlib/atexit.c:112
    #2 0x7f7ff6160e67 in __cxa_atexit_internal /usr/src/lib/libc/stdlib/atexit.c:158

Objects leaked above:
0x602000000000 (32 bytes)

Indirect leak of 128 byte(s) in 4 object(s) allocated from:
    #0 0x4048f5 in malloc /public/llvm/projects/compiler-rt/lib/lsan/lsan_interceptors.cc:54:3
    #1 0x7f7ff6160e67 in atexit_handler_alloc /usr/src/lib/libc/stdlib/atexit.c:112
    #2 0x7f7ff6160e67 in __cxa_atexit_internal /usr/src/lib/libc/stdlib/atexit.c:158

Objects leaked above:
0x602000000020 (32 bytes)
0x602000000040 (32 bytes)
0x602000000060 (32 bytes)
0x602000000080 (32 bytes)

SUMMARY: LeakSanitizer: 1497 byte(s) leaked in 6 allocation(s).

This causes breakage in all LSan tests. What should we do with this? Is there need to fix something in LSan? Tune the tests?

[krytarowski]

Testing notification e-mails from phabricator.

[krytarowski]

Ping? There is planned LLVM branching soon and I would like to see this in LLVM 9.0.

Actually after a longer thought I would like to enable LSan for all NetBSD CPUs, but keep the tests for amd64 for now.

[vitalybuka]

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

614 ↗

(On Diff #207467)

can you put this and other forked function into sanitizer_linux.cc/sanitizer_netbst.cc/sanitizer_linux_libcdep.cc ?

[krytarowski]

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

614 ↗

(On Diff #207467)

Do you mean to split sanitizer_stoptheworld_linux_libcdep.cc into ptrace-generic and linux and NetBSD?

I think it is not a good idea:

• this cannot work on other ptrace(2) fueled systems (at least NetBSD is the only one having enough batteries to do it in a similar way to Linux)
• duplicating or splitting stoptheworld implementation that is a hack is not a good idea, better to keep it in a single file - I don't want to see it spread to multiple files
• the amount of ifdefs is not that large and they are only for essential operation
• I plan to write an alternative implementation with a dedicated syscall for StopTheWorld(), but that would happen not sooner than in NetBSD 10.0 and we want to keep this ptrace(2) version here for the time being

[vitalybuka]

lib/sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc

423 ↗

(On Diff #207467)

now it will silently compile if we remove include <sys/prctl.h>

it should be internal_set_dumpable with noop on NETBSD
or better two StopTheWorldScope for Linux and NETBSD

512 ↗

(On Diff #207467)

internal_set_ptracer

585 ↗

(On Diff #207467)

SuspendedThreadsListLinux is also can be forked

614 ↗

(On Diff #207467)

Sanitizers are full of hack.
Also it looks like you just need to fork completely entire classes like: SuspendedThreadsListLinux, StopTheWorldScope, ThreadSuspender...

[krytarowski]

• switch the protype of internal_ptrace() to the one matching NetBSD
• move the stop-the-world implementation for NetBSD into a separate file
• minor changes

[vitalybuka]

LGTM, Thank you!

lib/sanitizer_common/sanitizer_netbsd.cc

325 ↗

(On Diff #208896)

Looks like you completely forked sanitizer_stoptheworld_netbsd_libcdep
in this case you don't new internal_
up to you if you like to keep them

[krytarowski]

I've landed this version as it is good enough to land LLVM-9.

Unfortunately many tests fail as they seem to be tuned for Linux/Darwin.

Please see:

https://reviews.llvm.org/D64057#1565937

@vitalybuka how to address these problems?

[lebedev.ri]

In D64057#1579961, @krytarowski wrote:

I've landed this version as it is good enough to land LLVM-9.

Unfortunately many tests fail as they seem to be tuned for Linux/Darwin.

Please see:

https://reviews.llvm.org/D64057#1565937

@vitalybuka how to address these problems?

Can you show how the tests *fail*>
I.e. what is the diff between expected and actual output?

[krytarowski]

In D64057#1579974, @lebedev.ri wrote:

In D64057#1579961, @krytarowski wrote:

I've landed this version as it is good enough to land LLVM-9.

Unfortunately many tests fail as they seem to be tuned for Linux/Darwin.

Please see:

https://reviews.llvm.org/D64057#1565937

@vitalybuka how to address these problems?

Can you show how the tests *fail*>
I.e. what is the diff between expected and actual output?

For start most of the problems come from this:

1. LSan registers check in AtExit(). There are other callbacks registered out there.
2. In __cxa_finalize() we first call the callbacks and at the end of the procedure we free() the memory

https://nxr.netbsd.org/xref/src/lib/libc/stdlib/atexit.c#191

247 
248 	/*
249 	 * Now free any dead handlers.  Do this even if we're about to
250 	 * exit, in case a leak-detecting malloc is being used.
251 	 */
252 	while ((ah = dead_handlers) != NULL) {
253 		dead_handlers = ah->ah_next;
254 		free(ah);
255 	}
256 }

3. In the tests there is enforced option use_stacks=0. This leads to false positives that struct atexit_handler *ah; is leaked. This is not true as its reference is still kept and it will be released soon after finishing execution of the callbacks.

compiler-rt/trunk/cmake/config-ix.cmake

 if (COMPILER_RT_HAS_SANITIZER_COMMON AND DFSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_DFSAN TRUE)
 else()
   set(COMPILER_RT_HAS_DFSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND LSAN_SUPPORTED_ARCH AND
-    OS_NAME MATCHES "Darwin|Linux")
+    OS_NAME MATCHES "Darwin|Linux|NetBSD")
   set(COMPILER_RT_HAS_LSAN TRUE)
 else()
   set(COMPILER_RT_HAS_LSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND MSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD|NetBSD")
   set(COMPILER_RT_HAS_MSAN TRUE)

compiler-rt/trunk/lib/lsan/lsan_common.h

 
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_platform.h"
 #include "sanitizer_common/sanitizer_stoptheworld.h"
 #include "sanitizer_common/sanitizer_symbolizer.h"
 
-// LeakSanitizer relies on some Glibc's internals (e.g. TLS machinery) thus
-// supported for Linux only. Also, LSan doesn't like 32 bit architectures
+// LeakSanitizer relies on some Glibc's internals (e.g. TLS machinery) on Linux.
+// Also, LSan doesn't like 32 bit architectures
 // because of "small" (4 bytes) pointer size that leads to high false negative
 // ratio on large leaks. But we still want to have it for some 32 bit arches
 // (e.g. x86), see https://github.com/google/sanitizers/issues/403.
 // To enable LeakSanitizer on a new architecture, one needs to implement the
 // internal_clone function as well as (probably) adjust the TLS machinery for
 // the new architecture inside the sanitizer library.
 #if (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC) && \
     (SANITIZER_WORDSIZE == 64) &&                               \
     (defined(__x86_64__) || defined(__mips64) || defined(__aarch64__) || \
      defined(__powerpc64__))
 #define CAN_SANITIZE_LEAKS 1
 #elif defined(__i386__) && \
     (SANITIZER_LINUX && !SANITIZER_ANDROID || SANITIZER_MAC)
 #define CAN_SANITIZE_LEAKS 1
 #elif defined(__arm__) && \
     SANITIZER_LINUX && !SANITIZER_ANDROID
 #define CAN_SANITIZE_LEAKS 1
+#elif SANITIZER_NETBSD
+#define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __sanitizer {
 class FlagParser;
 class ThreadRegistry;
 struct DTLS;

compiler-rt/trunk/lib/lsan/lsan_common_linux.cc

 //=-- lsan_common_linux.cc ------------------------------------------------===//
 //
 // 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 LeakSanitizer.
-// Implementation of common leak checking functionality. Linux-specific code.
+// Implementation of common leak checking functionality. Linux/NetBSD-specific
+// code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #include "lsan_common.h"
 
-#if CAN_SANITIZE_LEAKS && SANITIZER_LINUX
+#if CAN_SANITIZE_LEAKS && (SANITIZER_LINUX || SANITIZER_NETBSD)
 #include <link.h>
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_getauxval.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 

 // callback in the parent thread.
 void DoStopTheWorld(StopTheWorldCallback callback, void *argument) {
   DoStopTheWorldParam param = {callback, argument};
   dl_iterate_phdr(DoStopTheWorldCallback, &param);
 }
 
 } // namespace __lsan
 
-#endif // CAN_SANITIZE_LEAKS && SANITIZER_LINUX
+#endif

compiler-rt/trunk/lib/lsan/lsan_linux.cc

 //=-- lsan_linux.cc -------------------------------------------------------===//
 //
 // 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 LeakSanitizer. Linux-specific code.
+// This file is a part of LeakSanitizer. Linux/NetBSD-specific code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX || SANITIZER_NETBSD
 
 #include "lsan_allocator.h"
 
 namespace __lsan {
 
 static THREADLOCAL u32 current_thread_tid = kInvalidTid;
 u32 GetCurrentThread() { return current_thread_tid; }
 void SetCurrentThread(u32 tid) { current_thread_tid = tid; }
 
 static THREADLOCAL AllocatorCache allocator_cache;
 AllocatorCache *GetAllocatorCache() { return &allocator_cache; }
 
 void ReplaceSystemMalloc() {}
 
 } // namespace __lsan
 
-#endif // SANITIZER_LINUX
+#endif  // SANITIZER_LINUX || SANITIZER_NETBSD

compiler-rt/trunk/lib/sanitizer_common/CMakeLists.txt

 
 set(SANITIZER_LIBCDEP_SOURCES
   sanitizer_common_libcdep.cc
   sanitizer_allocator_checks.cc
   sanitizer_linux_libcdep.cc
   sanitizer_mac_libcdep.cc
   sanitizer_posix_libcdep.cc
   sanitizer_stoptheworld_linux_libcdep.cc
+  sanitizer_stoptheworld_netbsd_libcdep.cc
   )
 
 set(SANITIZER_COVERAGE_SOURCES
   sancov_flags.cc
   sanitizer_coverage_fuchsia.cc
   sanitizer_coverage_libcdep_new.cc
   sanitizer_coverage_win_sections.cc
   )

compiler-rt/trunk/lib/sanitizer_common/sanitizer_linux.h

 #if defined(__x86_64__) || defined(__mips__) || defined(__aarch64__) \
   || defined(__powerpc64__) || defined(__s390__) || defined(__i386__) \
   || defined(__arm__)
 uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
                     int *parent_tidptr, void *newtls, int *child_tidptr);
 #endif
 #elif SANITIZER_FREEBSD
 void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
+#elif SANITIZER_NETBSD
+void internal_sigdelset(__sanitizer_sigset_t *set, int signum);
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg);
 #endif  // SANITIZER_LINUX
 
 // This class reads thread IDs from /proc/<pid>/task using only syscalls.
 class ThreadLister {
  public:
   explicit ThreadLister(pid_t pid);
   ~ThreadLister();
   enum Result {

compiler-rt/trunk/lib/sanitizer_common/sanitizer_netbsd.cc

u64 NanoTime() {
   return (u64)tv.tv_sec * 1000 * 1000 * 1000 + tv.tv_usec * 1000;
 }
 
 uptr internal_clock_gettime(__sanitizer_clockid_t clk_id, void *tp) {
   DEFINE__REAL(int, __clock_gettime50, __sanitizer_clockid_t a, void *b);
   return _REAL(__clock_gettime50, clk_id, tp);
 }
 
-uptr internal_ptrace(int request, int pid, void *addr, void *data) {
-  Printf("internal_ptrace not implemented for NetBSD");
-  Die();
-  return 0;
+uptr internal_ptrace(int request, int pid, void *addr, int data) {
+  DEFINE__REAL(int, ptrace, int a, int b, void *c, int d);
+  return _REAL(ptrace, request, pid, addr, data);
 }
 
 uptr internal_waitpid(int pid, int *status, int options) {
   CHECK(&_sys___wait450);
   return _sys___wait450(pid, status, options, 0 /* rusage */);
 }
 
 uptr internal_getpid() {
void internal_sigfillset(__sanitizer_sigset_t *set) {
   (void)_REAL(__sigfillset14, set);
 }
 
 void internal_sigemptyset(__sanitizer_sigset_t *set) {
   DEFINE__REAL(int, __sigemptyset14, const void *a);
   (void)_REAL(__sigemptyset14, set);
 }
 
-uptr intrnal_clone(int (*fn)(void *), void *child_stack, int flags, void *arg,
-                   int *parent_tidptr, void *newtls, int *child_tidptr) {
-  Printf("internal_clone not implemented for NetBSD");
-  Die();
-  return 0;
+void internal_sigdelset(__sanitizer_sigset_t *set, int signo) {
+  DEFINE__REAL(int, __sigdelset14, const void *a, int b);
+  (void)_REAL(__sigdelset14, set, signo);
+}
+
+uptr internal_clone(int (*fn)(void *), void *child_stack, int flags,
+                    void *arg) {
+  DEFINE__REAL(int, clone, int (*a)(void *b), void *c, int d, void *e);
+
+  return _REAL(clone, fn, child_stack, flags, arg);
 }
 
 }  // namespace __sanitizer
 
 #endif

compiler-rt/trunk/lib/sanitizer_common/sanitizer_posix.h

 uptr internal_fstat(fd_t fd, void *buf);
 uptr internal_dup(int oldfd);
 uptr internal_dup2(int oldfd, int newfd);
 uptr internal_readlink(const char *path, char *buf, uptr bufsize);
 uptr internal_unlink(const char *path);
 uptr internal_rename(const char *oldpath, const char *newpath);
 uptr internal_lseek(fd_t fd, OFF_T offset, int whence);
 
+#if SANITIZER_NETBSD
+uptr internal_ptrace(int request, int pid, void *addr, int data);
+#else
 uptr internal_ptrace(int request, int pid, void *addr, void *data);
+#endif
 uptr internal_waitpid(int pid, int *status, int options);
 
 int internal_fork();
 int internal_forkpty(int *amaster);
 
 int internal_sysctl(const int *name, unsigned int namelen, void *oldp,
                     uptr *oldlenp, const void *newp, uptr newlen);
 int internal_sysctlbyname(const char *sname, void *oldp, uptr *oldlenp,

compiler-rt/trunk/lib/sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cc

+//===-- sanitizer_stoptheworld_netbsd_libcdep.cc --------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// See sanitizer_stoptheworld.h for details.
+// This implementation was inspired by Markus Gutschke's linuxthreads.cc.
+//
+// This is a NetBSD variation of Linux stoptheworld implementation
+// See sanitizer_stoptheworld_linux_libcdep.cc for code comments.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_platform.h"
+
+#if SANITIZER_NETBSD
+
+#include "sanitizer_stoptheworld.h"
+
+#include "sanitizer_atomic.h"
+#include "sanitizer_platform_limits_posix.h"
+
+#include <sys/types.h>
+
+#include <sys/ptrace.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+
+#include <machine/reg.h>
+
+#include <elf.h>
+#include <errno.h>
+#include <sched.h>
+#include <signal.h>
+#include <stddef.h>
+
+#define internal_sigaction_norestorer internal_sigaction
+
+#include "sanitizer_common.h"
+#include "sanitizer_flags.h"
+#include "sanitizer_libc.h"
+#include "sanitizer_linux.h"
+#include "sanitizer_mutex.h"
+#include "sanitizer_placement_new.h"
+
+namespace __sanitizer {
+
+class SuspendedThreadsListNetBSD : public SuspendedThreadsList {
+ public:
+  SuspendedThreadsListNetBSD() { thread_ids_.reserve(1024); }
+
+  tid_t GetThreadID(uptr index) const;
+  uptr ThreadCount() const;
+  bool ContainsTid(tid_t thread_id) const;
+  void Append(tid_t tid);
+
+  PtraceRegistersStatus GetRegistersAndSP(uptr index, uptr *buffer,
+                                          uptr *sp) const;
+  uptr RegisterCount() const;
+
+ private:
+  InternalMmapVector<tid_t> thread_ids_;
+};
+
+struct TracerThreadArgument {
+  StopTheWorldCallback callback;
+  void *callback_argument;
+  BlockingMutex mutex;
+  atomic_uintptr_t done;
+  uptr parent_pid;
+};
+
+class ThreadSuspender {
+ public:
+  explicit ThreadSuspender(pid_t pid, TracerThreadArgument *arg)
+      : arg(arg), pid_(pid) {
+    CHECK_GE(pid, 0);
+  }
+  bool SuspendAllThreads();
+  void ResumeAllThreads();
+  void KillAllThreads();
+  SuspendedThreadsListNetBSD &suspended_threads_list() {
+    return suspended_threads_list_;
+  }
+  TracerThreadArgument *arg;
+
+ private:
+  SuspendedThreadsListNetBSD suspended_threads_list_;
+  pid_t pid_;
+};
+
+void ThreadSuspender::ResumeAllThreads() {
+  int pterrno;
+  if (!internal_iserror(internal_ptrace(PT_DETACH, pid_, (void *)(uptr)1, 0),
+                        &pterrno)) {
+    VReport(2, "Detached from process %d.\n", pid_);
+  } else {
+    VReport(1, "Could not detach from process %d (errno %d).\n", pid_, pterrno);
+  }
+}
+
+void ThreadSuspender::KillAllThreads() {
+  internal_ptrace(PT_KILL, pid_, nullptr, 0);
+}
+
+bool ThreadSuspender::SuspendAllThreads() {
+  int pterrno;
+  if (internal_iserror(internal_ptrace(PT_ATTACH, pid_, nullptr, 0),
+                       &pterrno)) {
+    Printf("Could not attach to process %d (errno %d).\n", pid_, pterrno);
+    return false;
+  }
+
+  int status;
+  uptr waitpid_status;
+  HANDLE_EINTR(waitpid_status, internal_waitpid(pid_, &status, 0));
+
+  VReport(2, "Attached to process %d.\n", pid_);
+
+  struct ptrace_lwpinfo pl;
+  int val;
+  pl.pl_lwpid = 0;
+  while ((val = ptrace(PT_LWPINFO, pid_, (void *)&pl, sizeof(pl))) != -1 &&
+         pl.pl_lwpid != 0) {
+    suspended_threads_list_.Append(pl.pl_lwpid);
+    VReport(2, "Appended thread %d in process %d.\n", pl.pl_lwpid, pid_);
+  }
+  return true;
+}
+
+// Pointer to the ThreadSuspender instance for use in signal handler.
+static ThreadSuspender *thread_suspender_instance = nullptr;
+
+// Synchronous signals that should not be blocked.
+static const int kSyncSignals[] = {SIGABRT, SIGILL,  SIGFPE, SIGSEGV,
+                                   SIGBUS,  SIGXCPU, SIGXFSZ};
+
+static void TracerThreadDieCallback() {
+  ThreadSuspender *inst = thread_suspender_instance;
+  if (inst && stoptheworld_tracer_pid == internal_getpid()) {
+    inst->KillAllThreads();
+    thread_suspender_instance = nullptr;
+  }
+}
+
+// Signal handler to wake up suspended threads when the tracer thread dies.
+static void TracerThreadSignalHandler(int signum, __sanitizer_siginfo *siginfo,
+                                      void *uctx) {
+  SignalContext ctx(siginfo, uctx);
+  Printf("Tracer caught signal %d: addr=0x%zx pc=0x%zx sp=0x%zx\n", signum,
+         ctx.addr, ctx.pc, ctx.sp);
+  ThreadSuspender *inst = thread_suspender_instance;
+  if (inst) {
+    if (signum == SIGABRT)
+      inst->KillAllThreads();
+    else
+      inst->ResumeAllThreads();
+    RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
+    thread_suspender_instance = nullptr;
+    atomic_store(&inst->arg->done, 1, memory_order_relaxed);
+  }
+  internal__exit((signum == SIGABRT) ? 1 : 2);
+}
+
+// Size of alternative stack for signal handlers in the tracer thread.
+static const int kHandlerStackSize = 8192;
+
+// This function will be run as a cloned task.
+static int TracerThread(void *argument) {
+  TracerThreadArgument *tracer_thread_argument =
+      (TracerThreadArgument *)argument;
+
+  // Check if parent is already dead.
+  if (internal_getppid() != tracer_thread_argument->parent_pid)
+    internal__exit(4);
+
+  // Wait for the parent thread to finish preparations.
+  tracer_thread_argument->mutex.Lock();
+  tracer_thread_argument->mutex.Unlock();
+
+  RAW_CHECK(AddDieCallback(TracerThreadDieCallback));
+
+  ThreadSuspender thread_suspender(internal_getppid(), tracer_thread_argument);
+  // Global pointer for the signal handler.
+  thread_suspender_instance = &thread_suspender;
+
+  // Alternate stack for signal handling.
+  InternalMmapVector<char> handler_stack_memory(kHandlerStackSize);
+  stack_t handler_stack;
+  internal_memset(&handler_stack, 0, sizeof(handler_stack));
+  handler_stack.ss_sp = handler_stack_memory.data();
+  handler_stack.ss_size = kHandlerStackSize;
+  internal_sigaltstack(&handler_stack, nullptr);
+
+  // Install our handler for synchronous signals. Other signals should be
+  // blocked by the mask we inherited from the parent thread.
+  for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++) {
+    __sanitizer_sigaction act;
+    internal_memset(&act, 0, sizeof(act));
+    act.sigaction = TracerThreadSignalHandler;
+    act.sa_flags = SA_ONSTACK | SA_SIGINFO;
+    internal_sigaction_norestorer(kSyncSignals[i], &act, 0);
+  }
+
+  int exit_code = 0;
+  if (!thread_suspender.SuspendAllThreads()) {
+    VReport(1, "Failed suspending threads.\n");
+    exit_code = 3;
+  } else {
+    tracer_thread_argument->callback(thread_suspender.suspended_threads_list(),
+                                     tracer_thread_argument->callback_argument);
+    thread_suspender.ResumeAllThreads();
+    exit_code = 0;
+  }
+  RAW_CHECK(RemoveDieCallback(TracerThreadDieCallback));
+  thread_suspender_instance = nullptr;
+  atomic_store(&tracer_thread_argument->done, 1, memory_order_relaxed);
+  return exit_code;
+}
+
+class ScopedStackSpaceWithGuard {
+ public:
+  explicit ScopedStackSpaceWithGuard(uptr stack_size) {
+    stack_size_ = stack_size;
+    guard_size_ = GetPageSizeCached();
+    // FIXME: Omitting MAP_STACK here works in current kernels but might break
+    // in the future.
+    guard_start_ =
+        (uptr)MmapOrDie(stack_size_ + guard_size_, "ScopedStackWithGuard");
+    CHECK(MprotectNoAccess((uptr)guard_start_, guard_size_));
+  }
+  ~ScopedStackSpaceWithGuard() {
+    UnmapOrDie((void *)guard_start_, stack_size_ + guard_size_);
+  }
+  void *Bottom() const {
+    return (void *)(guard_start_ + stack_size_ + guard_size_);
+  }
+
+ private:
+  uptr stack_size_;
+  uptr guard_size_;
+  uptr guard_start_;
+};
+
+static __sanitizer_sigset_t blocked_sigset;
+static __sanitizer_sigset_t old_sigset;
+
+struct ScopedSetTracerPID {
+  explicit ScopedSetTracerPID(uptr tracer_pid) {
+    stoptheworld_tracer_pid = tracer_pid;
+    stoptheworld_tracer_ppid = internal_getpid();
+  }
+  ~ScopedSetTracerPID() {
+    stoptheworld_tracer_pid = 0;
+    stoptheworld_tracer_ppid = 0;
+  }
+};
+
+void StopTheWorld(StopTheWorldCallback callback, void *argument) {
+  // Prepare the arguments for TracerThread.
+  struct TracerThreadArgument tracer_thread_argument;
+  tracer_thread_argument.callback = callback;
+  tracer_thread_argument.callback_argument = argument;
+  tracer_thread_argument.parent_pid = internal_getpid();
+  atomic_store(&tracer_thread_argument.done, 0, memory_order_relaxed);
+  const uptr kTracerStackSize = 2 * 1024 * 1024;
+  ScopedStackSpaceWithGuard tracer_stack(kTracerStackSize);
+
+  tracer_thread_argument.mutex.Lock();
+
+  internal_sigfillset(&blocked_sigset);
+  for (uptr i = 0; i < ARRAY_SIZE(kSyncSignals); i++)
+    internal_sigdelset(&blocked_sigset, kSyncSignals[i]);
+  int rv = internal_sigprocmask(SIG_BLOCK, &blocked_sigset, &old_sigset);
+  CHECK_EQ(rv, 0);
+  uptr tracer_pid = internal_clone(TracerThread, tracer_stack.Bottom(),
+                                   CLONE_VM | CLONE_FS | CLONE_FILES,
+                                   &tracer_thread_argument);
+  internal_sigprocmask(SIG_SETMASK, &old_sigset, 0);
+  int local_errno = 0;
+  if (internal_iserror(tracer_pid, &local_errno)) {
+    VReport(1, "Failed spawning a tracer thread (errno %d).\n", local_errno);
+    tracer_thread_argument.mutex.Unlock();
+  } else {
+    ScopedSetTracerPID scoped_set_tracer_pid(tracer_pid);
+
+    tracer_thread_argument.mutex.Unlock();
+
+    while (atomic_load(&tracer_thread_argument.done, memory_order_relaxed) == 0)
+      sched_yield();
+
+    for (;;) {
+      uptr waitpid_status = internal_waitpid(tracer_pid, nullptr, __WALL);
+      if (!internal_iserror(waitpid_status, &local_errno))
+        break;
+      if (local_errno == EINTR)
+        continue;
+      VReport(1, "Waiting on the tracer thread failed (errno %d).\n",
+              local_errno);
+      break;
+    }
+  }
+}
+
+tid_t SuspendedThreadsListNetBSD::GetThreadID(uptr index) const {
+  CHECK_LT(index, thread_ids_.size());
+  return thread_ids_[index];
+}
+
+uptr SuspendedThreadsListNetBSD::ThreadCount() const {
+  return thread_ids_.size();
+}
+
+bool SuspendedThreadsListNetBSD::ContainsTid(tid_t thread_id) const {
+  for (uptr i = 0; i < thread_ids_.size(); i++) {
+    if (thread_ids_[i] == thread_id)
+      return true;
+  }
+  return false;
+}
+
+void SuspendedThreadsListNetBSD::Append(tid_t tid) {
+  thread_ids_.push_back(tid);
+}
+
+PtraceRegistersStatus SuspendedThreadsListNetBSD::GetRegistersAndSP(
+    uptr index, uptr *buffer, uptr *sp) const {
+  lwpid_t tid = GetThreadID(index);
+  pid_t ppid = internal_getppid();
+  struct reg regs;
+  int pterrno;
+  bool isErr =
+      internal_iserror(internal_ptrace(PT_GETREGS, ppid, &regs, tid), &pterrno);
+  if (isErr) {
+    VReport(1,
+            "Could not get registers from process %d thread %d (errno %d).\n",
+            ppid, tid, pterrno);
+    return pterrno == ESRCH ? REGISTERS_UNAVAILABLE_FATAL
+                            : REGISTERS_UNAVAILABLE;
+  }
+
+  *sp = PTRACE_REG_SP(&regs);
+  internal_memcpy(buffer, &regs, sizeof(regs));
+
+  return REGISTERS_AVAILABLE;
+}
+
+uptr SuspendedThreadsListNetBSD::RegisterCount() const {
+  return sizeof(struct reg) / sizeof(uptr);
+}
+}  // namespace __sanitizer
+
+#endif

compiler-rt/trunk/lib/tsan/go/buildgo.sh

SRCS="
     ../rtl/tsan_platform_linux.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_procmaps_linux.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
+    ../../sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cc
     "
   if [ "`uname -a | grep ppc64le`" != "" ]; then
     SUFFIX="linux_ppc64le"
     ARCHCFLAGS="-m64"
   elif [ "`uname -a | grep x86_64`" != "" ]; then
     SUFFIX="linux_amd64"
     ARCHCFLAGS="-m64"
     OSCFLAGS="$OSCFLAGS -ffreestanding -Wno-unused-const-variable -Werror -Wno-unknown-warning-option"
SRCS="
     ../rtl/tsan_platform_linux.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_bsd.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
+    ../../sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cc
   "
 elif [ "`uname -a | grep NetBSD`" != "" ]; then
   SUFFIX="netbsd_amd64"
   OSCFLAGS="-fno-strict-aliasing -fPIC -Werror"
   ARCHCFLAGS="-m64"
   OSLDFLAGS="-lpthread -fPIC -fpie"
   SRCS="
     $SRCS
     ../rtl/tsan_platform_linux.cc
     ../../sanitizer_common/sanitizer_posix.cc
     ../../sanitizer_common/sanitizer_posix_libcdep.cc
     ../../sanitizer_common/sanitizer_procmaps_bsd.cc
     ../../sanitizer_common/sanitizer_procmaps_common.cc
     ../../sanitizer_common/sanitizer_linux.cc
     ../../sanitizer_common/sanitizer_linux_libcdep.cc
     ../../sanitizer_common/sanitizer_netbsd.cc
     ../../sanitizer_common/sanitizer_stoptheworld_linux_libcdep.cc
+    ../../sanitizer_common/sanitizer_stoptheworld_netbsd_libcdep.cc
   "
 elif [ "`uname -a | grep Darwin`" != "" ]; then
   SUFFIX="darwin_amd64"
   OSCFLAGS="-fPIC -Wno-unused-const-variable -Wno-unknown-warning-option -mmacosx-version-min=10.7"
   ARCHCFLAGS="-m64"
   OSLDFLAGS="-lpthread -fPIC -fpie -mmacosx-version-min=10.7"
   SRCS="
     $SRCS

compiler-rt/trunk/test/lsan/lit.common.cfg.py

 config.substitutions.append( ("%clang ", build_invocation(clang_cflags)) )
 config.substitutions.append( ("%clangxx ", build_invocation(clang_cxxflags)) )
 config.substitutions.append( ("%clang_lsan ", build_invocation(clang_lsan_cflags)) )
 config.substitutions.append( ("%clangxx_lsan ", build_invocation(clang_lsan_cxxflags)) )
 
 # LeakSanitizer tests are currently supported on x86-64 Linux, PowerPC64 Linux, arm Linux, mips64 Linux, and x86_64 Darwin.
 supported_linux = config.host_os is 'Linux' and config.host_arch in ['x86_64', 'ppc64', 'ppc64le', 'mips64', 'arm', 'armhf', 'armv7l']
 supported_darwin = config.host_os is 'Darwin' and config.target_arch is 'x86_64'
-if not (supported_linux or supported_darwin):
+supported_netbsd = config.host_os is 'NetBSD' and config.target_arch is 'x86_64'
+if not (supported_linux or supported_darwin or supported_netbsd):
   config.unsupported = True
 
 # Don't support Thumb due to broken fast unwinder
 if re.search('mthumb', config.target_cflags) is not None:
   config.unsupported = True
 
 config.suffixes = ['.c', '.cc', '.cpp', '.mm']