tsan: ignore interceptors coming from specified libraries

[dvyukov]

Summary

LibIgnore allows to ignore all interceptors called from a particular set
of dynamic libraries. LibIgnore remembers all "called_from_lib" suppressions
from the provided SuppressionContext; finds code ranges for the libraries;
and checks whether the provided PC value belongs to the code ranges.

Also make malloc and friends interceptors use SCOPED_INTERCEPTOR_RAW instead of SCOPED_TSAN_INTERCEPTOR, because if they are called from an ignored lib, then must call our internal allocator instead of libc malloc.

[samsonov]

sanitizer_common/sanitizer_libignore.h

42

Consider reusing LoadedModule from sanitizer_common.h

sanitizer_common/sanitizer_suppressions.h

46

Can we do better than return the class internals to the caller?

tsan/lit_tests/ignore_lib0.cc

2

Please use %p and %t wildcards (see asan/lit_tests/TestCases/dlclose-test.cc as an example)

5

TSAN_OPTIONS=$TSAN_OPTIONS:....

tsan/rtl/tsan_interceptors.cc

130–137

• do you need to use ALIGNED(64) here?
• why not static char [sizeof(LibIgnore)]?

169

in_ingored_lib_(false)

tsan/rtl/tsan_rtl.cc

217

Why not put this under a single ifndef?

[kcc]

did a quick scan, more tomorrow

sanitizer_common/sanitizer_libignore.cc

22

I'd prefer to have size() and get(i) methods in supp instead of giving away the guts.

sanitizer_common/sanitizer_libignore.h

28

Will this work on Windows? (Check with Timur)

30

If this is linker-initialized, the empty body should be here. No?

tsan/rtl/tsan_interceptors.cc

130–137

shouldn't this be aligned(64)?

tsan/rtl/tsan_rtl.cc

216–219

Two #ifndef TSAN_GO in a row?

Also, can we start using if (!TSAN_GO) instead ?

[glider]

msan/msan_interceptors.cc

1133

IIUC this file doesn't belong to this CL.
If so, please commit it separately.

sanitizer_common/sanitizer_libignore.h

35

Shouldn't we support dlclose()? Otherwise you may end up having overlapping and/or nesting ranges.

[glider]

sanitizer_common/sanitizer_common_interceptors.inc

1142

Do these interceptors belong to this CL?

sanitizer_common/sanitizer_libignore.cc

26

I don't think we must bail out if the number of suppressions is greater than a predefined constant. Maybe just ignore the rest?

sanitizer_common/sanitizer_libignore.h

10

I suggest 'IgnoreLib' or anything else instead of 'LibIgnore', since 'libignore' associates with 'library named ignore'.

[dvyukov]

addressed the comments

[dvyukov]

PTAL

sanitizer_common/sanitizer_libignore.cc

22

Done

sanitizer_common/sanitizer_libignore.h

28

It's not used on windows.

30

It's in cc file.

42

LoadedModule is too general and slow for this use case.

sanitizer_common/sanitizer_suppressions.h

46

Done

tsan/lit_tests/ignore_lib0.cc

2

I need to know the exact library name to put into suppressions file, I do not see how to handle this.

5

Done

tsan/rtl/tsan_interceptors.cc

130–137

do you need to use ALIGNED(64) here?

The class itself is aligned.

130–137

why not static char [sizeof(LibIgnore)]?

That does not provide necessary storage alignment -> undefined behavior.

130–137

shouldn't this be aligned(64)?

The class itself is aligned.

169

why?

tsan/rtl/tsan_rtl.cc

216–219

Two #ifndef TSAN_GO in a row?

Done

216–219

Also, can we start using if (!TSAN_GO) instead ?

There is no such function when TSAN_GO, so it may not link.

217

Done

[samsonov]

sanitizer_common/sanitizer_libignore.h

28

It is still compiled on Windows.

tsan/lit_tests/ignore_lib0.cc

2

You can use %T wildcard for a temporary directory.

tsan/rtl/tsan_interceptors.cc

130–137

This deserves a careful comment or maybe even compiler check.

169

I like to actually see the default value (and notice that in_ignored_lib_ is a bool). Not sure if it's consistent with conventions you use in TSan code.

[samsonov]

sanitizer_common/sanitizer_libignore.cc

39

Why not InternalScopedBuffer?

45

I think that if you change the order of loops (scan ProcSelfMaps and match its contents against all libs), you can make the code more testable

49

s/Printf/Report

66

Are you sure we want to report it?

tsan/lit_tests/ignore_lib1.cc

30 ↗

(On Diff #4617)

Wait, is this copied from ingore_lib0.cc? I think it's better to put this source under lit_tests/Helpers directory - see the way it's done in ASan.

[dvyukov]

addressed the comments

[dvyukov]

msan/msan_interceptors.cc

1133

this file was removed from this CL

sanitizer_common/sanitizer_common_interceptors.inc

1142

this file was removed from this CL

sanitizer_common/sanitizer_libignore.cc

39

Done

45

how can I make it more testable?

49

Done

66

another library will be ignored in this case, which is bad
I do not want to handle library unloading, so I just check that it does not happen

sanitizer_common/sanitizer_libignore.h

10

IgnoreLib is not much better, it's still Library if you read it this way

28

Done
Added #if SANITIZER_LINUX

35

Done
See OnLibraryUnloaded

tsan/lit_tests/ignore_lib0.cc

2

Done

tsan/lit_tests/ignore_lib1.cc

30 ↗

(On Diff #4617)

Done

tsan/rtl/tsan_interceptors.cc

130–137

Added a comment above the class definition.

169

Done

[dvyukov]

PTAL

[dvyukov]

moved LibIgnore alignment from class definition to variable definition

[kcc]

LGTM

[dvyukov]

Anybody else?

[samsonov]

sanitizer_common/sanitizer_libignore.cc

40

You don't need this array - at i-th iteration you use only loaded[i];

47

s/&fn[0]/fn.data() (here and below)

54

You may use UNREACHABLE macro here and below

tsan/lit_tests/ignore_lib0.cc

5

Why do you need this LD_LIBRARY_PATH and Output here?

[dvyukov]

sanitizer_common/sanitizer_libignore.cc

40

Done

47

Done

54

It is reachable code. Changed CHECK(0) to Die().

tsan/lit_tests/ignore_lib0.cc

5

Otherwise the library won't be loaded, dynamic linker won't be able to find it.

[dvyukov]

addressed the comments

[dvyukov]

PTAL

[samsonov]

tsan/lit_tests/ignore_lib0.cc

5

Alright... can you use %T instead of Output?

[dvyukov]

PTAL

tsan/lit_tests/ignore_lib0.cc

5

Done

[samsonov]

LGTM (with nits).

tsan/lit_tests/ignore_lib0.cc

5

I see one more "Output" here :)

tsan/lit_tests/ignore_lib0.cc.supp

2

FYI: If you prefer, you may add "echo called_from_lib:/libignore_lib0.so > %t.supp" to the RUN: lines in your test cases and avoid these extra files.

[dvyukov]

Added to the description:

Also make malloc and friends interceptors use SCOPED_INTERCEPTOR_RAW instead of SCOPED_TSAN_INTERCEPTOR, because if they are called from an ignored lib, then must call our internal allocator instead of libc malloc.

[dvyukov]

PTAL

[samsonov]

LGTM

[glider]

sanitizer_common/sanitizer_libignore.cc

19

Perhaps move the ctor into the header?

30

This check can be easily triggered by the user if he adds many suppressions to the file.
Can you print a meaningful error report in this case?

49

Shouldn't '&&' be on the previous line?

52

Style nit: the quotes will look much prettier if you align them with the previous line (if you choose to do this, make sure to align the next line similarly). Ditto below.

57

(!lib->loaded) ?

sanitizer_common/sanitizer_libignore.h

16

Need a newline after this comment.

67

I suggest to remove the declarations of non-implemented functions.

tsan/lit_tests/ignore_lib1.cc

22 ↗

(On Diff #4628)

pls add spaces around "|" here and below

tsan/lit_tests/ignore_lib_lib.h

21 ↗

(On Diff #4628)

Please fix the indentation

tsan/rtl/tsan_rtl.h

34

Mind the alphabetical order of includes.

[dvyukov]

sanitizer_common/sanitizer_libignore.cc

19

Why?

30

Done

49

Done

52

Done

57

Done

sanitizer_common/sanitizer_libignore.h

16

Done

67

Then it will be possible to copy objects of this class, something that I want to prevent.

tsan/lit_tests/ignore_lib1.cc

22 ↗

(On Diff #4628)

Done

tsan/lit_tests/ignore_lib_lib.h

21 ↗

(On Diff #4628)

Done

tsan/rtl/tsan_rtl.h

34

Done

[glider]

LGTM with a nit

sanitizer_common/sanitizer_libignore.h

67

Got it now. I just think "not implemented" is a poor comment.
How about "disallow copying LibIgnore objects"?

[Eugene.Zelenko]

Committed in r191897.

msan/msan_interceptors.cc

 #define COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ptr, size) \
   __msan_unpoison(ptr, size)
 #define COMMON_INTERCEPTOR_READ_RANGE(ctx, ptr, size) \
   CHECK_UNPOISONED_CTX(ctx, ptr, size)
 #define COMMON_INTERCEPTOR_ENTER(ctx, func, ...)              \
   if (msan_init_is_running) return REAL(func)(__VA_ARGS__);   \
   MSanInterceptorContext msan_ctx = {IsInInterceptorScope()}; \
   ctx = (void *)&msan_ctx;                                    \
+  (void)ctx;                                                  \
   InterceptorScope interceptor_scope;                         \
   ENSURE_MSAN_INITED();
 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
   do {                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
   do {                                         \
   } while (false)

sanitizer_common/CMakeLists.txt

 # Build system for the common Sanitizer runtime support library components.
 # These components are shared between AddressSanitizer and ThreadSanitizer.
 
 set(SANITIZER_SOURCES
   sanitizer_allocator.cc
   sanitizer_common.cc
   sanitizer_flags.cc
   sanitizer_libc.cc
+  sanitizer_libignore.cc
   sanitizer_linux.cc
   sanitizer_mac.cc
   sanitizer_platform_limits_linux.cc
   sanitizer_platform_limits_posix.cc
   sanitizer_posix.cc
   sanitizer_printf.cc
   sanitizer_stackdepot.cc
   sanitizer_stacktrace.cc

sanitizer_common/sanitizer_common_interceptors.inc

INTERCEPTOR(struct __sanitizer_hostent *, gethostbyaddr, void *addr, int len,
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, gethostbyaddr, addr, len, type);
   COMMON_INTERCEPTOR_READ_RANGE(ctx, addr, len);
   struct __sanitizer_hostent *res = REAL(gethostbyaddr)(addr, len, type);
   if (res) write_hostent(ctx, res);
   return res;
 }
 
-INTERCEPTOR(struct __sanitizer_hostent *, gethostent) {
+INTERCEPTOR(struct __sanitizer_hostent *, gethostent, int fake) {
   void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, gethostent);
-  struct __sanitizer_hostent *res = REAL(gethostent)();
+  COMMON_INTERCEPTOR_ENTER(ctx, gethostent, fake);
+  struct __sanitizer_hostent *res = REAL(gethostent)(fake);
   if (res) write_hostent(ctx, res);
   return res;
 }
 
 INTERCEPTOR(struct __sanitizer_hostent *, gethostbyname2, char *name, int af) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, gethostbyname2, name, af);
   struct __sanitizer_hostent *res = REAL(gethostbyname2)(name, af);

 }
 #define INIT_GETCWD           \
   INTERCEPT_FUNCTION(getcwd);
 #else
 #define INIT_GETCWD
 #endif
 
 #if SANITIZER_INTERCEPT_GET_CURRENT_DIR_NAME
-INTERCEPTOR(char *, get_current_dir_name) {
+INTERCEPTOR(char *, get_current_dir_name, int fake) {
   void *ctx;
-  COMMON_INTERCEPTOR_ENTER(ctx, get_current_dir_name);
-  char *res = REAL(get_current_dir_name)();
+  COMMON_INTERCEPTOR_ENTER(ctx, get_current_dir_name, fake);
+  char *res = REAL(get_current_dir_name)(fake);
   if (res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, res, REAL(strlen)(res) + 1);
   return res;
 }
 
 #define INIT_GET_CURRENT_DIR_NAME           \
   INTERCEPT_FUNCTION(get_current_dir_name);
 #else

sanitizer_common/sanitizer_libignore.h

+//===-- sanitizer_libignore.h -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// LibIgnore allows to ignore all interceptors called from a particular set
+// of dynamic libraries. LibIgnore remembers all "called_from_lib" suppressions
+// from the provided SuppressionContext; finds code ranges for the libraries;
+// and checks whether the provided PC value belongs to the code ranges.
+//
+//===----------------------------------------------------------------------===//
+#ifndef SANITIZER_LIBIGNORE_H
+#define SANITIZER_LIBIGNORE_H
+
+#include "sanitizer_internal_defs.h"
+#include "sanitizer_common.h"
+#include "sanitizer_suppressions.h"
+#include "sanitizer_atomic.h"
+#include "sanitizer_mutex.h"
+
+namespace __sanitizer {
+
+class ALIGNED(64) LibIgnore {
+ public:
+  LibIgnore(LinkerInitialized);
+
+  // Fetches all "called_from_lib" suppressions from the SuppressionContext.
+  void Init(const SuppressionContext &supp);
+
+  // Must be called after a new dynamic library is loaded.
+  void OnLibraryLoaded();
+
+  // Checks whether the provided PC belongs to one of the ignored libraries.
+  bool IsIgnored(uptr pc) const;
+
+ private:
+  struct Lib {
+    char *name;
+    bool loaded;
+  };
+
+  struct LibCodeRange {
+    uptr begin;
+    uptr end;
+  };
+
+  static const uptr kMaxLibs = 128;
+
+  // Hot part:
+  atomic_uintptr_t loaded_count_;
+  LibCodeRange code_ranges_[kMaxLibs];
+
+  // Cold part:
+  BlockingMutex mutex_;
+  uptr count_;
+  Lib libs_[kMaxLibs];
+
+  LibIgnore(const LibIgnore&);  // not implemented
+  void operator = (const LibIgnore&);  // not implemented
+};
+
+inline bool LibIgnore::IsIgnored(uptr pc) const {
+  const uptr n = atomic_load(&loaded_count_, memory_order_acquire);
+  for (uptr i = 0; i < n; i++) {
+    if (pc >= code_ranges_[i].begin && pc < code_ranges_[i].end)
+      return true;
+  }
+  return false;
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_LIBIGNORE_H

sanitizer_common/sanitizer_libignore.cc

+//===-- sanitizer_libignore.cc --------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_libignore.h"
+#include "sanitizer_procmaps.h"
+
+namespace __sanitizer {
+
+LibIgnore::LibIgnore(LinkerInitialized) {
+}
+
+void LibIgnore::Init(const SuppressionContext &supp) {
+  BlockingMutexLock lock(&mutex_);
+  CHECK_EQ(count_, 0);
+  const InternalMmapVector<Suppression> *list = supp.GetSuppressions();
+  for (uptr i = 0; i < list->size(); i++) {
+    const Suppression *s = &(*list)[i];
+    if (s->type != SuppressionLib)
+      continue;
+    CHECK_LT(count_, kMaxLibs);
+    Lib *lib = &libs_[count_++];
+    lib->name = internal_strdup(s->templ);
+    lib->loaded = false;
+  }
+}
+
+void LibIgnore::OnLibraryLoaded() {
+  if (atomic_load(&loaded_count_, memory_order_relaxed) == count_)
+    return;
+  BlockingMutexLock lock(&mutex_);
+  MemoryMappingLayout proc_maps(/*cache_enabled*/false);
+  InternalMmapVector<char> fn(4096);
+  fn.push_back(0);
+  for (uptr i = 0; i < count_; i++) {
+    Lib *lib = &libs_[i];
+    if (lib->loaded)
+      continue;
+    proc_maps.Reset();
+    uptr b, e, off, prot;
+    while (proc_maps.Next(&b, &e, &off, &fn[0], fn.capacity(), &prot)) {
+      if ((prot & MemoryMappingLayout::kProtectionExecute) != 0
+          && TemplateMatch(lib->name, &fn[0])) {
+        lib->loaded = true;
+        const uptr idx = atomic_load(&loaded_count_, memory_order_relaxed);
+        code_ranges_[idx].begin = b;
+        code_ranges_[idx].end = e;
+        atomic_store(&loaded_count_, idx + 1, memory_order_release);
+        break;
+      }
+    }
+  }
+}
+
+}  // namespace __sanitizer

sanitizer_common/sanitizer_suppressions.h

 
 enum SuppressionType {
   SuppressionNone,
   SuppressionRace,
   SuppressionMutex,
   SuppressionThread,
   SuppressionSignal,
   SuppressionLeak,
+  SuppressionLib,
   SuppressionTypeCount
 };
 
 struct Suppression {
   SuppressionType type;
   char *templ;
   unsigned hit_count;
   uptr weight;
 };
 
 class SuppressionContext {
  public:
   SuppressionContext() : suppressions_(1), can_parse_(true) {}
   void Parse(const char *str);
   bool Match(const char* str, SuppressionType type, Suppression **s);
   uptr SuppressionCount();
   void GetMatched(InternalMmapVector<Suppression *> *matched);
+  const InternalMmapVector<Suppression> *GetSuppressions() const;
 
  private:
   InternalMmapVector<Suppression> suppressions_;
   bool can_parse_;
 
   friend class SuppressionContextTest;
 };
 
 const char *SuppressionTypeString(SuppressionType t);
 
-// Exposed for testing.
 bool TemplateMatch(char *templ, const char *str);
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_SUPPRESSIONS_H

sanitizer_common/sanitizer_suppressions.cc

 
 #include "sanitizer_allocator_internal.h"
 #include "sanitizer_common.h"
 #include "sanitizer_libc.h"
 
 namespace __sanitizer {
 
 static const char *const kTypeStrings[SuppressionTypeCount] = {
-  "none", "race", "mutex", "thread", "signal", "leak"
+  "none", "race", "mutex", "thread", "signal", "leak", "called_from_lib"
 };
 
 bool TemplateMatch(char *templ, const char *str) {
   if (str == 0 || str[0] == 0)
     return false;
   bool start = false;
   if (templ && templ[0] == '^') {
     start = true;

 
 void SuppressionContext::GetMatched(
     InternalMmapVector<Suppression *> *matched) {
   for (uptr i = 0; i < suppressions_.size(); i++)
     if (suppressions_[i].hit_count)
       matched->push_back(&suppressions_[i]);
 }
 
+const InternalMmapVector<Suppression> *SuppressionContext::GetSuppressions()
+    const {
+  return &suppressions_;
+}
+
 const char *SuppressionTypeString(SuppressionType t) {
   CHECK(t < SuppressionTypeCount);
   return kTypeStrings[t];
 }
 
 }  // namespace __sanitizer

sanitizer_common/tests/sanitizer_suppressions_test.cc

 
 TEST(Suppressions, TypeStrings) {
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionNone), "none"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionRace), "race"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionMutex), "mutex"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionThread), "thread"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionSignal), "signal"));
   CHECK(!internal_strcmp(SuppressionTypeString(SuppressionLeak), "leak"));
+  CHECK(!internal_strcmp(SuppressionTypeString(SuppressionLib),
+      "called_from_lib"));
   // Ensure this test is up-to-date when suppression types are added.
-  CHECK_EQ(SuppressionTypeCount, 6);
+  CHECK_EQ(SuppressionTypeCount, 7);
 }
 
 class SuppressionContextTest : public ::testing::Test {
  public:
   virtual void SetUp() { ctx_ = new(placeholder_) SuppressionContext; }
   virtual void TearDown() { ctx_->~SuppressionContext(); }
 
  protected:

tsan/lit_tests/ignore_lib0.cc

+// RUN: %clangxx_tsan -O1 %s -DLIB -fPIC -fno-sanitize=thread -shared -o ./Output/libignore_lib0.so
+// RUN: %clangxx_tsan -O1 %s -L./Output/ -lignore_lib0 -o %t
+// RUN: LD_LIBRARY_PATH=./Output/ not %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOSUPP
+// RUN: LD_LIBRARY_PATH=./Output/ TSAN_OPTIONS=suppressions=%s.supp not %t 2>&1 | FileCheck %s --check-prefix=CHECK-WITHSUPP
+
+#ifndef LIB
+
+void libfunc();
+
+int main() {
+  libfunc();
+}
+
+#else  // #ifdef LIB
+
+#include <pthread.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+void *volatile mem;
+volatile int len;
+
+void *Thread(void *p) {
+  while ((p = __atomic_load_n(&mem, __ATOMIC_ACQUIRE)) == 0)
+    usleep(100);
+  memset(p, 0, len);
+  return 0;
+}
+
+void libfunc() {
+  pthread_t t;
+  pthread_create(&t, 0, Thread, 0);
+  len = 10;
+    __atomic_store_n(&mem, malloc(len), __ATOMIC_RELEASE);
+  pthread_join(t, 0);
+  free(mem);
+  fprintf(stderr, "OK\n");
+}
+
+#endif
+
+// CHECK-NOSUPP: WARNING: ThreadSanitizer: data race
+// CHECK-NOSUPP: OK
+
+// CHECK-WITHSUPP-NOT: WARNING: ThreadSanitizer: data race
+// CHECK-WITHSUPP: OK
+

tsan/lit_tests/ignore_lib0.cc.supp

+called_from_lib:/libignore_lib0.so
+

tsan/lit_tests/java_alloc.cc

 
 void *Thread(void *p) {
   stress((jptr)p);
   return 0;
 }
 
 int main() {
   jptr jheap = (jptr)malloc(kHeapSize);
-  __tsan_java_preinit("[vdso]");
   __tsan_java_init(jheap, kHeapSize);
   pthread_t th;
   pthread_create(&th, 0, Thread, (void*)(jheap + kHeapSize / 4));
   stress(jheap);
   pthread_join(th, 0);
   printf("OK\n");
   return __tsan_java_fini();
 }
 
 // CHECK-NOT: WARNING: ThreadSanitizer: data race

tsan/lit_tests/java_lock.cc

void *Thread(void *p) {
   *(int*)varaddr = 42;
   __tsan_java_mutex_unlock(lockaddr);
   return 0;
 }
 
 int main() {
   int const kHeapSize = 1024 * 1024;
   void *jheap = malloc(kHeapSize);
-  __tsan_java_preinit(0);
   __tsan_java_init((jptr)jheap, kHeapSize);
   const int kBlockSize = 16;
   __tsan_java_alloc((jptr)jheap, kBlockSize);
   varaddr = (jptr)jheap;
   lockaddr = (jptr)jheap + 8;
   pthread_t th;
   pthread_create(&th, 0, Thread, 0);
   __tsan_java_mutex_lock(lockaddr);

tsan/rtl/tsan_interceptors.cc

 #include "sanitizer_common/sanitizer_libc.h"
 #include "sanitizer_common/sanitizer_linux.h"
 #include "sanitizer_common/sanitizer_platform_limits_posix.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "interception/interception.h"
 #include "tsan_interface.h"
 #include "tsan_platform.h"
+#include "tsan_suppressions.h"
 #include "tsan_rtl.h"
 #include "tsan_mman.h"
 #include "tsan_fd.h"
 
 using namespace __tsan;  // NOLINT
 
 const int kSigCount = 64;
 

 
 struct SignalContext {
   int in_blocking_func;
   int int_signal_send;
   int pending_signal_count;
   SignalDesc pending_signals[kSigCount];
 };
 
-// Used to ignore interceptors coming directly from libjvm.so.
-atomic_uintptr_t libjvm_begin;
-atomic_uintptr_t libjvm_end;
-
-static bool libjvm_check(uptr pc) {
-  uptr begin = atomic_load(&libjvm_begin, memory_order_relaxed);
-  if (begin != 0 && pc >= begin) {
-    uptr end = atomic_load(&libjvm_end, memory_order_relaxed);
-    if (end != 0 && pc < end)
-      return true;
-  }
-  return false;
+static uptr libignore_placeholder[sizeof(LibIgnore) / sizeof(uptr) + 1];
+static LibIgnore *libignore() {
+  return reinterpret_cast<LibIgnore*>(&libignore_placeholder[0]);
+
+void InitializeLibIgnore() {
+  libignore()->Init(*GetSuppressionContext());
+  libignore()->OnLibraryLoaded();
 }
 
 }  // namespace __tsan
 
 static SignalContext *SigCtx(ThreadState *thr) {
   SignalContext *ctx = (SignalContext*)thr->signal_ctx;
   if (ctx == 0 && thr->is_alive) {
     ScopedInRtl in_rtl;
     ctx = (SignalContext*)MmapOrDie(sizeof(*ctx), "SignalContext");
     MemoryResetRange(thr, (uptr)&SigCtx, (uptr)ctx, sizeof(*ctx));
     thr->signal_ctx = ctx;
   }
   return ctx;
 }
 
 static unsigned g_thread_finalize_key;
 
 class ScopedInterceptor {
  public:
   ScopedInterceptor(ThreadState *thr, const char *fname, uptr pc);
   ~ScopedInterceptor();
  private:
   ThreadState *const thr_;
   const int in_rtl_;
+  bool in_ignored_lib_;
 };
 
 ScopedInterceptor::ScopedInterceptor(ThreadState *thr, const char *fname,
                                      uptr pc)
     : thr_(thr)
-    , in_rtl_(thr->in_rtl) {
+    , in_rtl_(thr->in_rtl)
+    , in_ignored_lib_() {
   if (thr_->in_rtl == 0) {
     Initialize(thr);
     FuncEntry(thr, pc);
     thr_->in_rtl++;
     DPrintf("#%d: intercept %s()\n", thr_->tid, fname);
   } else {
     thr_->in_rtl++;
   }
+  if (!thr_->in_ignored_lib && libignore()->IsIgnored(pc)) {
+    in_ignored_lib_ = true;
+    thr_->in_ignored_lib = true;
+    ThreadIgnoreBegin(thr_);
+  }
 }
 
 ScopedInterceptor::~ScopedInterceptor() {
+  if (in_ignored_lib_) {
+    thr_->in_ignored_lib = false;
+    ThreadIgnoreEnd(thr_);
+  }
   thr_->in_rtl--;
   if (thr_->in_rtl == 0) {
     FuncExit(thr_);
     ProcessPendingSignals(thr_);
   }
   CHECK_EQ(in_rtl_, thr_->in_rtl);
 }
 
 #define SCOPED_INTERCEPTOR_RAW(func, ...) \
     ThreadState *thr = cur_thread(); \
     StatInc(thr, StatInterceptor); \
     StatInc(thr, StatInt_##func); \
     const uptr caller_pc = GET_CALLER_PC(); \
     ScopedInterceptor si(thr, #func, caller_pc); \
     const uptr pc = __sanitizer::StackTrace::GetCurrentPc(); \
     (void)pc; \
 /**/
 
 #define SCOPED_TSAN_INTERCEPTOR(func, ...) \
     SCOPED_INTERCEPTOR_RAW(func, __VA_ARGS__); \
     if (REAL(func) == 0) { \
       Printf("FATAL: ThreadSanitizer: failed to intercept %s\n", #func); \
       Die(); \
     } \
-    if (thr->in_rtl > 1 || libjvm_check(pc)) \
+    if (thr->in_rtl > 1 || thr->in_ignored_lib) \
       return REAL(func)(__VA_ARGS__); \
 /**/
 
 #define TSAN_INTERCEPTOR(ret, func, ...) INTERCEPTOR(ret, func, __VA_ARGS__)
 #define TSAN_INTERCEPT(func) INTERCEPT_FUNCTION(func)
 
 #define BLOCK_REAL(name) (BlockingCall(thr), REAL(name))
 

 
 TSAN_INTERCEPTOR(int, nanosleep, void *req, void *rem) {
   SCOPED_TSAN_INTERCEPTOR(nanosleep, req, rem);
   int res = BLOCK_REAL(nanosleep)(req, rem);
   AfterSleep(thr, pc);
   return res;
 }
 
+TSAN_INTERCEPTOR(void*, dlopen, const char *filename, int flag) {
+  SCOPED_INTERCEPTOR_RAW(dlopen, filename, flag);
+  void *res = REAL(dlopen)(filename, flag);
+  libignore()->OnLibraryLoaded();
+  return res;
+}
+
 class AtExitContext {
  public:
   AtExitContext()
     : mtx_(MutexTypeAtExit, StatMtxAtExit)
     , pos_() {
   }
 
   typedef void(*atexit_t)();
TSAN_INTERCEPTOR(void, siglongjmp, uptr *env, int val) {
   {
     SCOPED_TSAN_INTERCEPTOR(siglongjmp, env, val);
   }
   LongJmp(cur_thread(), env);
   REAL(siglongjmp)(env, val);
 }
 
 TSAN_INTERCEPTOR(void*, malloc, uptr size) {
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC()))
+  if (cur_thread()->in_symbolizer)
     return __libc_malloc(size);
   void *p = 0;
   {
     SCOPED_INTERCEPTOR_RAW(malloc, size);
     p = user_alloc(thr, pc, size);
   }
   invoke_malloc_hook(p, size);
   return p;
 }
 
 TSAN_INTERCEPTOR(void*, __libc_memalign, uptr align, uptr sz) {
   SCOPED_TSAN_INTERCEPTOR(__libc_memalign, align, sz);
   return user_alloc(thr, pc, sz, align);
 }
 
 TSAN_INTERCEPTOR(void*, calloc, uptr size, uptr n) {
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC()))
+  if (cur_thread()->in_symbolizer)
     return __libc_calloc(size, n);
   if (__sanitizer::CallocShouldReturnNullDueToOverflow(size, n))
     return AllocatorReturnNull();
   void *p = 0;
   {
     SCOPED_INTERCEPTOR_RAW(calloc, size, n);
     p = user_alloc(thr, pc, n * size);
     if (p)
       internal_memset(p, 0, n * size);
   }
   invoke_malloc_hook(p, n * size);
   return p;
 }
 
 TSAN_INTERCEPTOR(void*, realloc, void *p, uptr size) {
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC()))
+  if (cur_thread()->in_symbolizer)
     return __libc_realloc(p, size);
   if (p)
     invoke_free_hook(p);
   {
     SCOPED_INTERCEPTOR_RAW(realloc, p, size);
     p = user_realloc(thr, pc, p, size);
   }
   invoke_malloc_hook(p, size);
   return p;
 }
 
 TSAN_INTERCEPTOR(void, free, void *p) {
   if (p == 0)
     return;
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC()))
+  if (cur_thread()->in_symbolizer)
     return __libc_free(p);
   invoke_free_hook(p);
   SCOPED_INTERCEPTOR_RAW(free, p);
   user_free(thr, pc, p);
 }
 
 TSAN_INTERCEPTOR(void, cfree, void *p) {
   if (p == 0)
     return;
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC()))
+  if (cur_thread()->in_symbolizer)
     return __libc_free(p);
   invoke_free_hook(p);
   SCOPED_INTERCEPTOR_RAW(cfree, p);
   user_free(thr, pc, p);
 }
 
 TSAN_INTERCEPTOR(uptr, malloc_usable_size, void *p) {
   SCOPED_INTERCEPTOR_RAW(malloc_usable_size, p);
-  if (libjvm_check(pc))
-    return malloc_usable_size(p);
   return user_alloc_usable_size(thr, pc, p);
 }
 
 #define OPERATOR_NEW_BODY(mangled_name) \
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC())) \
+  if (cur_thread()->in_symbolizer) \
     return __libc_malloc(size); \
   void *p = 0; \
   {  \
     SCOPED_INTERCEPTOR_RAW(mangled_name, size); \
     p = user_alloc(thr, pc, size); \
   }  \
   invoke_malloc_hook(p, size);  \
   return p;

 SANITIZER_INTERFACE_ATTRIBUTE
 void *operator new[](__sanitizer::uptr size, std::nothrow_t const&);
 void *operator new[](__sanitizer::uptr size, std::nothrow_t const&) {
   OPERATOR_NEW_BODY(_ZnamRKSt9nothrow_t);
 }
 
 #define OPERATOR_DELETE_BODY(mangled_name) \
   if (ptr == 0) return;  \
-  if (cur_thread()->in_symbolizer || libjvm_check(GET_CALLER_PC())) \
+  if (cur_thread()->in_symbolizer) \
     return __libc_free(ptr); \
   invoke_free_hook(ptr);  \
   SCOPED_INTERCEPTOR_RAW(mangled_name, ptr);  \
   user_free(thr, pc, ptr);
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void operator delete(void *ptr);
 void operator delete(void *ptr) {
TSAN_INTERCEPTOR(const char*, strstr, const char *s1, const char *s2) {
   uptr len2 = internal_strlen(s2);
   MemoryAccessRange(thr, pc, (uptr)s1, len1 + 1, false);
   MemoryAccessRange(thr, pc, (uptr)s2, len2 + 1, false);
   return res;
 }
 
 TSAN_INTERCEPTOR(char*, strdup, const char *str) {
   SCOPED_TSAN_INTERCEPTOR(strdup, str);
-  if (libjvm_check(pc)) {
-    // The memory must come from libc malloc,
-    // and we must not instrument accesses in this case.
-    uptr n = internal_strlen(str) + 1;
-    void *p = __libc_malloc(n);
-    if (p == 0)
-      return 0;
-    return (char*)internal_memcpy(p, str, n);
-  }
   // strdup will call malloc, so no instrumentation is required here.
   return REAL(strdup)(str);
 }
 
 static bool fix_mmap_addr(void **addr, long_t sz, int flags) {
   if (*addr) {
     if (!IsAppMem((uptr)*addr) || !IsAppMem((uptr)*addr + sz - 1)) {
       if (flags & MAP_FIXED) {

 TSAN_INTERCEPTOR(int, munmap, void *addr, long_t sz) {
   SCOPED_TSAN_INTERCEPTOR(munmap, addr, sz);
   DontNeedShadowFor((uptr)addr, sz);
   int res = REAL(munmap)(addr, sz);
   return res;
 }
 
 TSAN_INTERCEPTOR(void*, memalign, uptr align, uptr sz) {
-  SCOPED_TSAN_INTERCEPTOR(memalign, align, sz);
+  SCOPED_INTERCEPTOR_RAW(memalign, align, sz);
   return user_alloc(thr, pc, sz, align);
 }
 
 TSAN_INTERCEPTOR(void*, valloc, uptr sz) {
-  SCOPED_TSAN_INTERCEPTOR(valloc, sz);
+  SCOPED_INTERCEPTOR_RAW(valloc, sz);
   return user_alloc(thr, pc, sz, GetPageSizeCached());
 }
 
 TSAN_INTERCEPTOR(void*, pvalloc, uptr sz) {
-  SCOPED_TSAN_INTERCEPTOR(pvalloc, sz);
+  SCOPED_INTERCEPTOR_RAW(pvalloc, sz);
   sz = RoundUp(sz, GetPageSizeCached());
   return user_alloc(thr, pc, sz, GetPageSizeCached());
 }
 
 TSAN_INTERCEPTOR(int, posix_memalign, void **memptr, uptr align, uptr sz) {
-  SCOPED_TSAN_INTERCEPTOR(posix_memalign, memptr, align, sz);
+  SCOPED_INTERCEPTOR_RAW(posix_memalign, memptr, align, sz);
   *memptr = user_alloc(thr, pc, sz, align);
   return 0;
 }
 
 // Used in thread-safe function static initialization.
 extern "C" int INTERFACE_ATTRIBUTE __cxa_guard_acquire(atomic_uint32_t *g) {
   SCOPED_INTERCEPTOR_RAW(__cxa_guard_acquire, g);
   for (;;) {
extern "C" void *__tsan_thread_start_func(void *arg) {
   // it mixes up stack traces.
   volatile int foo = 42;
   foo++;
   return res;
 }
 
 TSAN_INTERCEPTOR(int, pthread_create,
     void *th, void *attr, void *(*callback)(void*), void * param) {
-  SCOPED_TSAN_INTERCEPTOR(pthread_create, th, attr, callback, param);
+  SCOPED_INTERCEPTOR_RAW(pthread_create, th, attr, callback, param);
   __sanitizer_pthread_attr_t myattr;
   if (attr == 0) {
     pthread_attr_init(&myattr);
     attr = &myattr;
   }
   int detached = 0;
   pthread_attr_getdetachstate(attr, &detached);
 

 }
 
 TSAN_INTERCEPTOR(int, munlockall, void) {
   MlockIsUnsupported();
   return 0;
 }
 
 TSAN_INTERCEPTOR(int, fork, int fake) {
-  SCOPED_TSAN_INTERCEPTOR(fork, fake);
+  SCOPED_INTERCEPTOR_RAW(fork, fake);
   int pid = REAL(fork)(fake);
   if (pid == 0) {
     // child
     FdOnFork(thr, pc);
   } else if (pid > 0) {
     // parent
   }
   return pid;
void InitializeInterceptors() {
   TSAN_INTERCEPT(getaddrinfo);
 
   TSAN_INTERCEPT(mlock);
   TSAN_INTERCEPT(munlock);
   TSAN_INTERCEPT(mlockall);
   TSAN_INTERCEPT(munlockall);
 
   TSAN_INTERCEPT(fork);
+  TSAN_INTERCEPT(dlopen);
   TSAN_INTERCEPT(on_exit);
   TSAN_INTERCEPT(__cxa_atexit);
 
   // Need to setup it, because interceptors check that the function is resolved.
   // But atexit is emitted directly into the module, so can't be resolved.
   REAL(atexit) = (int(*)(void(*)()))unreachable;
   atexit_ctx = new(internal_alloc(MBlockAtExit, sizeof(AtExitContext)))
       AtExitContext();

tsan/rtl/tsan_interface_java.h

 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef unsigned long jptr;  // NOLINT
 
-// Must be called before any other callback from Java, right after dlopen
-// of JVM shared lib. If libjvm_path is specified, then all interceptors
-// coming directly from JVM will be ignored.
-void __tsan_java_preinit(const char *libjvm_path) INTERFACE_ATTRIBUTE;
-// Must be called after __tsan_java_preinit but before any other callback.
+// Must be called before any other callback from Java.
 void __tsan_java_init(jptr heap_begin, jptr heap_size) INTERFACE_ATTRIBUTE;
 // Must be called when the application exits.
 // Not necessary the last callback (concurrently running threads are OK).
 // Returns exit status or 0 if tsan does not want to override it.
 int  __tsan_java_fini() INTERFACE_ATTRIBUTE;
 
 // Callback for memory allocations.
 // May be omitted for allocations that are not subject to data races

tsan/rtl/tsan_interface_java.cc

public:
   }
 
  private:
   ThreadState *thr_;
 };
 
 static u64 jctx_buf[sizeof(JavaContext) / sizeof(u64) + 1];
 static JavaContext *jctx;
-extern atomic_uintptr_t libjvm_begin;
-extern atomic_uintptr_t libjvm_end;
 
 static BlockDesc *getblock(uptr addr) {
   uptr i = (addr - jctx->heap_begin) / kHeapAlignment;
   return &jctx->heap_shadow[i];
 }
 
 static uptr USED getmem(BlockDesc *b) {
   uptr i = b - jctx->heap_shadow;

 #define SCOPED_JAVA_FUNC(func) \
   ThreadState *thr = cur_thread(); \
   const uptr caller_pc = GET_CALLER_PC(); \
   const uptr pc = __sanitizer::StackTrace::GetCurrentPc(); \
   (void)pc; \
   ScopedJavaFunc scoped(thr, caller_pc); \
 /**/
 
-void __tsan_java_preinit(const char *libjvm_path) {
-  SCOPED_JAVA_FUNC(__tsan_java_preinit);
-  if (libjvm_path) {
-    uptr begin, end;
-    if (GetCodeRangeForFile(libjvm_path, &begin, &end)) {
-      atomic_store(&libjvm_begin, begin, memory_order_relaxed);
-      atomic_store(&libjvm_end, end, memory_order_relaxed);
-    }
-  }
-}
-
 void __tsan_java_init(jptr heap_begin, jptr heap_size) {
   SCOPED_JAVA_FUNC(__tsan_java_init);
   DPrintf("#%d: java_init(%p, %p)\n", thr->tid, heap_begin, heap_size);
   CHECK_EQ(jctx, 0);
   CHECK_GT(heap_begin, 0);
   CHECK_GT(heap_size, 0);
   CHECK_EQ(heap_begin % kHeapAlignment, 0);
   CHECK_EQ(heap_size % kHeapAlignment, 0);

tsan/rtl/tsan_rtl.h

 #ifndef TSAN_RTL_H
 #define TSAN_RTL_H
 
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
+#include "sanitizer_common/sanitizer_libignore.h"
 #include "tsan_clock.h"
 #include "tsan_defs.h"
 #include "tsan_flags.h"
 #include "tsan_sync.h"
 #include "tsan_trace.h"
 #include "tsan_vector.h"
 #include "tsan_report.h"
 #include "tsan_platform.h"
#ifndef TSAN_GO
   InternalAllocatorCache internal_alloc_cache;
   Vector<JmpBuf> jmp_bufs;
 #endif
   u64 stat[StatCnt];
   const int tid;
   const int unique_id;
   int in_rtl;
   bool in_symbolizer;
+  bool in_ignored_lib;
   bool is_alive;
   bool is_freeing;
   bool is_vptr_access;
   const uptr stk_addr;
   const uptr stk_size;
   const uptr tls_addr;
   const uptr tls_size;
 
if (kCollectStats)
     thr->stat[typ] = n;
 }
 
 void MapShadow(uptr addr, uptr size);
 void MapThreadTrace(uptr addr, uptr size);
 void DontNeedShadowFor(uptr addr, uptr size);
 void InitializeShadowMemory();
 void InitializeInterceptors();
+void InitializeLibIgnore();
 void InitializeDynamicAnnotations();
 
 void ReportRace(ThreadState *thr);
 bool OutputReport(Context *ctx,
                   const ScopedReport &srep,
                   const ReportStack *suppress_stack1 = 0,
                   const ReportStack *suppress_stack2 = 0,
                   const ReportLocation *suppress_loc = 0);

tsan/rtl/tsan_rtl.cc

#endif
   // Setup correct file descriptor for error reports.
   if (internal_strcmp(flags()->log_path, "stdout") == 0)
     __sanitizer_set_report_fd(kStdoutFd);
   else if (internal_strcmp(flags()->log_path, "stderr") == 0)
     __sanitizer_set_report_fd(kStderrFd);
   else
     __sanitizer_set_report_path(flags()->log_path);
   InitializeSuppressions();
 #ifndef TSAN_GO
+  InitializeLibIgnore();
+#endif
+#ifndef TSAN_GO
   // Initialize external symbolizer before internal threads are started.
   const char *external_symbolizer = flags()->external_symbolizer_path;
   if (external_symbolizer != 0 && external_symbolizer[0] != '\0') {
     if (!getSymbolizer()->InitializeExternal(external_symbolizer)) {
       Printf("Failed to start external symbolizer: '%s'\n",
              external_symbolizer);
       Die();
     }

tsan/rtl/tsan_stat.h

enum StatType {
   StatInt_sigwaitinfo,
   StatInt_sigtimedwait,
   StatInt_sigemptyset,
   StatInt_sigfillset,
   StatInt_sigpending,
   StatInt_sigprocmask,
   StatInt_backtrace,
   StatInt_backtrace_symbols,
+  StatInt_dlopen,
 
   // Dynamic annotations.
   StatAnnotation,
   StatAnnotateHappensBefore,
   StatAnnotateHappensAfter,
   StatAnnotateCondVarSignal,
   StatAnnotateCondVarSignalAll,
   StatAnnotateMutexIsNotPHB,

tsan/rtl/tsan_stat.cc

void StatOutput(u64 *stat) {
   name[StatInt_sigwaitinfo]              = "  sigwaitinfo                     ";
   name[StatInt_sigtimedwait]             = "  sigtimedwait                    ";
   name[StatInt_sigemptyset]              = "  sigemptyset                     ";
   name[StatInt_sigfillset]               = "  sigfillset                      ";
   name[StatInt_sigpending]               = "  sigpending                      ";
   name[StatInt_sigprocmask]              = "  sigprocmask                     ";
   name[StatInt_backtrace]                = "  backtrace                       ";
   name[StatInt_backtrace_symbols]        = "  backtrace_symbols               ";
+  name[StatInt_dlopen]                   = "  dlopen                          ";
 
   name[StatAnnotation]                   = "Dynamic annotations               ";
   name[StatAnnotateHappensBefore]        = "  HappensBefore                   ";
   name[StatAnnotateHappensAfter]         = "  HappensAfter                    ";
   name[StatAnnotateCondVarSignal]        = "  CondVarSignal                   ";
   name[StatAnnotateCondVarSignalAll]     = "  CondVarSignalAll                ";
   name[StatAnnotateMutexIsNotPHB]        = "  MutexIsNotPHB                   ";
   name[StatAnnotateCondVarWait]          = "  CondVarWait                     ";

tsan/rtl/tsan_suppressions.h

 #include "tsan_report.h"
 
 namespace __tsan {
 
 void InitializeSuppressions();
 void PrintMatchedSuppressions();
 uptr IsSuppressed(ReportType typ, const ReportStack *stack, Suppression **sp);
 uptr IsSuppressed(ReportType typ, const ReportLocation *loc, Suppression **sp);
+SuppressionContext *GetSuppressionContext();
 
 }  // namespace __tsan
 
 #endif  // TSAN_SUPPRESSIONS_H

tsan/rtl/tsan_suppressions.cc

void InitializeSuppressions() {
   g_ctx->Parse(supp);
 #ifndef TSAN_GO
   supp = __tsan_default_suppressions();
   g_ctx->Parse(supp);
   g_ctx->Parse(std_suppressions);
 #endif
 }
 
+SuppressionContext *GetSuppressionContext() {
+  CHECK_NE(g_ctx, 0);
+  return g_ctx;
+}
+
 SuppressionType conv(ReportType typ) {
   if (typ == ReportTypeRace)
     return SuppressionRace;
   else if (typ == ReportTypeVptrRace)
     return SuppressionRace;
   else if (typ == ReportTypeUseAfterFree)
     return SuppressionRace;
   else if (typ == ReportTypeThreadLeak)