Update from https://crrev.com/328418

sandbox/linux/services/syscall_wrappers.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sandbox/linux/services/syscall_wrappers.h"
 
 #include <pthread.h>
 #include <sched.h>
 #include <setjmp.h>
 #include <sys/resource.h>
@@ skipping 130 matching lines @@
 
 int sys_sigprocmask(int how, const sigset_t* set, decltype(nullptr) oldset) {
   // In some toolchain (in particular Android and PNaCl toolchain),
   // sigset_t is 32 bits, but Linux ABI requires 64 bits.
   uint64_t linux_value = 0;
   std::memcpy(&linux_value, set, std::min(sizeof(sigset_t), sizeof(uint64_t)));
   return syscall(__NR_rt_sigprocmask, how, &linux_value, nullptr,
                  sizeof(linux_value));
 }
 
-#if defined(MEMORY_SANITIZER) || \
-    (defined(ARCH_CPU_X86_64) && defined(__GNUC__) && !defined(__clang__))
-// If MEMORY_SANITIZER is enabled, it is necessary to call sigaction() here,
-// rather than the direct syscall (sys_sigaction() defined by ourselves).
-// It is because, if MEMORY_SANITIZER is enabled, sigaction is wrapped, and
-// |act->sa_handler| is injected in order to unpoisonize the memory passed via
-// callback's arguments. Please see msan_interceptors.cc for more details.
-// So, if the direct syscall is used, as MEMORY_SANITIZER does not know about
-// it, sigaction() invocation in other places would be broken (in more precise,
-// returned |oldact| would have a broken |sa_handler| callback).
+#if (defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) ||  \
+     (defined(ARCH_CPU_X86_64) && !defined(__clang__))) && \
+    !defined(OS_NACL_NONSFI)
+// If MEMORY_SANITIZER or THREAD_SANITIZER is enabled, it is necessary to call
+// sigaction() here, rather than the direct syscall (sys_sigaction() defined
+// by ourselves).
+// It is because, if MEMORY_SANITIZER or THREAD_SANITIZER is enabled, sigaction
+// is wrapped, and |act->sa_handler| is injected in order to unpoisonize the
+// memory passed via callback's arguments for MEMORY_SANITIZER, or handle
+// signals to check thread consistency for THREAD_SANITIZER. Please see
+// msan_interceptors.cc and tsan_interceptors.cc for more details.
+// So, specifically, if MEMORY_SANITIZER is enabled while the direct syscall is
+// used, as MEMORY_SANITIZER does not know about it, sigaction() invocation in
+// other places would be broken (in more precise, returned |oldact| would have
+// a broken |sa_handler| callback).
 // Practically, it would break NaCl's signal handler installation.
 // cf) native_client/src/trusted/service_runtime/linux/nacl_signal.c.
+// As for THREAD_SANITIZER, the intercepted signal handlers are processed more
+// in other libc functions' interceptors (such as for raise()), so that it
+// would not work properly.
 //
 // Also on x86_64 architecture, we need naked function for rt_sigreturn.
 // However, there is no simple way to define it with GCC. Note that the body
 // of function is actually very small (only two instructions), but we need to
 // define much debug information in addition, otherwise backtrace() used by
 // base::StackTrace would not work so that some tests would fail.
+//
+// When this is built with PNaCl toolchain, we should always use sys_sigaction
+// below, because sigaction() provided by the toolchain is incompatible with
+// Linux's ABI. So, otherwise, it would just fail. Note that it is not
+// necessary to think about sigaction() invocation in other places even with
+// MEMORY_SANITIZER or THREAD_SANITIZER, because it would just fail there.
 int sys_sigaction(int signum,
                   const struct sigaction* act,
                   struct sigaction* oldact) {
   return sigaction(signum, act, oldact);
 }
 #else
 // struct sigaction is different ABI from the Linux's.
 struct KernelSigAction {
   void (*kernel_handler)(int);
   uint32_t sa_flags;
@@ skipping 44 matching lines @@
     std::memcpy(&oldact->sa_mask, &kernel_oldact.sa_mask,
                 std::min(sizeof(kernel_act.sa_mask), sizeof(act->sa_mask)));
     oldact->sa_flags = kernel_oldact.sa_flags;
   }
   return result;
 }
 
 #endif  // defined(MEMORY_SANITIZER)
 
 }  // namespace sandbox