Port stand-alone lsan to Android (revised)

[thurston]

Summary

Revised as per the feedback to D22549: this abstracts cache/disable_counter/current_thread_tid (stored in TLS_SLOT_TSAN on Android, THREADLOCAL variables otherwise) into GetCurrentThread().

[eugenis]

lsan_allocator.cc

31 ↗

(On Diff #64913)

Get rid of this; always go though LsanThread. See how ASan does it (AsanThread, AsanThreadLocalMallocStorage).

49 ↗

(On Diff #64913)

remove the printf, or make it a vprintf

55 ↗

(On Diff #64913)

why??

lsan_allocator.h

27 ↗

(On Diff #64913)

Move this to sanitizer_common.h, smth like void **AndroidGetTls() { return &__get_tls()[TLS_SLOT_TSAN];}

36 ↗

(On Diff #64913)

function, not a macro

73 ↗

(On Diff #64913)

Call this LsanThread, use it on all platforms.

lsan_common.cc

38 ↗

(On Diff #64913)

get rid of this; always go through LsanThread

54 ↗

(On Diff #64913)

replace with getCurrentThread()->disable_counter

lsan_thread.cc

29 ↗

(On Diff #64913)

LsanThread

[thurston]

There's now an LsanThread struct containing all the thread-local variables. A pointer to the struct is returned from lsan_thread.cc::getCurrentTLS(), which is the single point where we distinguish between Android (use AndroidGetTls()) and non-Android (use THREADLOCAL).

[eugenis]

lsan/lsan_allocator.h

20 ↗

(On Diff #65178)

looks unnecessary

lsan/lsan_common.h

130

unnecessary

132

Please move this to lsan_thread.h

135

just "tid"

lsan/lsan_flags.inc

34 ↗

(On Diff #65178)

this could be written as

LSAN_FLAG(bool, use_tls, !SANITIZER_ANDROID,

but on the second thought, don't we need to handle pthread_setspecific storage on android? did you test that it works?

I think this flag still makes sense for android, and instead of defaulting to false we should modify the code to do the right thing for the platform, i.e. scan TSD and not DTLS.

lsan/lsan_thread.cc

15

no system headers here
why is this needed?

43

merge this into #if SANITIZER_ANDROID .. #else below (line 70).

49

rename this to GetCurrentThread for consistency with asan;
replace existing calls to u32 GetCurrentThread() with GetCurrentThread()->id.

sanitizer_common/sanitizer_common.cc

494 ↗

(On Diff #65178)

move this to the header so it can be inlined

sanitizer_common/sanitizer_common.h

845

this will break asan on arm

[thurston]

This addresses all the previous comments
(use_tls is not overridden for Android, GetTls() updated instead to return the bionic TLS slots;
GetCurrentThread() changed to GetCurrentThread()->id, getCurrentTLS() changed to GetCurrentThread();
SIG_SETMASK copied from signal.h;
removed some unnecessary code and moved some code around)

[eugenis]

lsan/lsan_allocator.cc

37

() unnecessary

lsan/lsan_common.cc

248

Is the special case for android needed because allocator cache is not inside tls limits?
Could you check that condition here instead?
cache_begin == cache_end || cache_begin >= tls_end || cache_end <= tls_begin

lsan/lsan_thread.cc

26

this should be moved to sanitizer_platform_limits_posix, see __sanitizer::sig_dfl

sanitizer_common/sanitizer_common.h

848

Are you sure this does not break asan on arm still?
__get_tls is undefined.
Please test that asan on arm at least compiles.

[eugenis]

sanitizer_common/sanitizer_linux_libcdep.cc

373 ↗

(On Diff #65610)

this is super scary btw, but I don't see a better way.
BIONIC_TLS_SLOTS may change at any time (and it has, quite recently)

[thurston]

lsan/lsan_allocator.cc

37

In the next revision, I've removed these and some other similar parentheses

sanitizer_common/sanitizer_common.h

848

In the next revision, I've defined __get_tls and tested that asan on arm builds within the Android source tree.

[thurston]

Addresses previous comments

N.B. Some changes in sanitizer_common overlap with changes proposed for msan

[eugenis]

sanitizer_common/sanitizer_common.h

848

By next revision, do you mean something that's not yet uploaded?
I don't see this code anywhere.

[thurston]

sanitizer_common/sanitizer_common.h

848

My comment is wrong. I ended up taking an alternative approach: if __get_tls is not defined, then define AndroidGetTls to return nullptr (line 850). This lets sanitizer_common compile on 32-bit with SANITIZER_ANDROID, even though AndroidGetTls won't actually be used (since it is only called by lsan or msan, which won't run on 32-bit).

[thurston]

Add back the sanitizer_common/sanitizer_linux_libcdep.cc TLS changes from diff 3 - I accidentally omitted them.
All other files are the same as per diff 4.

[thurston]

sanitizer_common/sanitizer_common.h

848

Oops - in revision 3 I'd been missing sanitizer_common/sanitizer_linux_libcdep.cc TLS changes so this compiled, but having added them back, since GetTls in that file directly uses get_tls (not AndroidGetTls), I still need to define get_tls.

[thurston]

On 32-bit Android, GetTls() won't use __get_tls() (which is undefined)
Defines sig_setmask

lsan/lsan.cc

extern "C" void __lsan_init() {
   InitCommonLsan();
   InitializeAllocator();
   InitTlsSize();
   InitializeInterceptors();
   InitializeThreadRegistry();
   u32 tid = ThreadCreate(0, 0, true);
   CHECK_EQ(tid, 0);
   ThreadStart(tid, GetTid());
-  SetCurrentThread(tid);
+  GetCurrentThread()->tid = tid;
 
   if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit)
     Atexit(DoLeakCheck);
 
   InitializeCoverage(common_flags()->coverage, common_flags()->coverage_dir);
 
+  AndroidLogInit();
+
   lsan_inited = true;
   lsan_init_is_running = false;
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE
 void __sanitizer_print_stack_trace() {
   GET_STACK_TRACE_FATAL;
   stack.Print();
 }

lsan/lsan_allocator.cc

 #include "lsan_allocator.h"
 
 #include "sanitizer_common/sanitizer_allocator.h"
 #include "sanitizer_common/sanitizer_allocator_interface.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "lsan_common.h"
+#include "lsan_thread.h"
 
 extern "C" void *memset(void *ptr, int value, uptr num);
 
 namespace __lsan {
 
-struct ChunkMetadata {
-  u8 allocated : 8;  // Must be first.
-  ChunkTag tag : 2;
-  uptr requested_size : 54;
-  u32 stack_trace_id;
-};
-
-#if defined(__mips64) || defined(__aarch64__)
-static const uptr kMaxAllowedMallocSize = 4UL << 30;
-static const uptr kRegionSizeLog = 20;
-static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
-typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
-typedef CompactSizeClassMap SizeClassMap;
-typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
-    sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog, ByteMap>
-    PrimaryAllocator;
-#else
-static const uptr kMaxAllowedMallocSize = 8UL << 30;
-static const uptr kAllocatorSpace = 0x600000000000ULL;
-static const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
-typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
-        sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
-#endif
-typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
-typedef LargeMmapAllocator<> SecondaryAllocator;
-typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
-          SecondaryAllocator> Allocator;
 
 static Allocator allocator;
-static THREADLOCAL AllocatorCache cache;
 
 void InitializeAllocator() {
   allocator.InitLinkerInitialized(common_flags()->allocator_may_return_null);
 }
 
 void AllocatorThreadFinish() {
-  allocator.SwallowCache(&cache);
+  allocator.SwallowCache(&GetCurrentThread()->cache);
 }
 
 static ChunkMetadata *Metadata(const void *p) {
   return reinterpret_cast<ChunkMetadata *>(allocator.GetMetaData(p));
 }
 
 static void RegisterAllocation(const StackTrace &stack, void *p, uptr size) {
   if (!p) return;

 void *Allocate(const StackTrace &stack, uptr size, uptr alignment,
                bool cleared) {
   if (size == 0)
     size = 1;
   if (size > kMaxAllowedMallocSize) {
     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", size);
     return nullptr;
   }
-  void *p = allocator.Allocate(&cache, size, alignment, false);
+  void *p = allocator.Allocate(&GetCurrentThread()->cache, size, alignment, false);
   // Do not rely on the allocator to clear the memory (it's slow).
   if (cleared && allocator.FromPrimary(p))
     memset(p, 0, size);
   RegisterAllocation(stack, p, size);
   if (&__sanitizer_malloc_hook) __sanitizer_malloc_hook(p, size);
   RunMallocHooks(p, size);
   return p;
 }
 
 void Deallocate(void *p) {
   if (&__sanitizer_free_hook) __sanitizer_free_hook(p);
   RunFreeHooks(p);
   RegisterDeallocation(p);
-  allocator.Deallocate(&cache, p);
+  allocator.Deallocate(&GetCurrentThread()->cache, p);
 }
 
 void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
                  uptr alignment) {
   RegisterDeallocation(p);
   if (new_size > kMaxAllowedMallocSize) {
     Report("WARNING: LeakSanitizer failed to allocate %zu bytes\n", new_size);
-    allocator.Deallocate(&cache, p);
+    allocator.Deallocate(&GetCurrentThread()->cache, p);
     return nullptr;
   }
-  p = allocator.Reallocate(&cache, p, new_size, alignment);
+  p = allocator.Reallocate(&GetCurrentThread()->cache, p, new_size, alignment);
   RegisterAllocation(stack, p, new_size);
   return p;
 }
 
 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
-  *begin = (uptr)&cache;
-  *end = *begin + sizeof(cache);
+  *begin = (uptr)&GetCurrentThread()->cache;
+  *end = *begin + sizeof(GetCurrentThread()->cache);
 }
 
 uptr GetMallocUsableSize(const void *p) {
   ChunkMetadata *m = Metadata(p);
   if (!m) return 0;
   return m->requested_size;
 }
 

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"
 
-#if (SANITIZER_LINUX && !SANITIZER_ANDROID) && (SANITIZER_WORDSIZE == 64) \
+#if (SANITIZER_LINUX) && (SANITIZER_WORDSIZE == 64) \
      && (defined(__x86_64__) ||  defined(__mips64) ||  defined(__aarch64__))
 #define CAN_SANITIZE_LEAKS 1
 #else
 #define CAN_SANITIZE_LEAKS 0
 #endif
 
 namespace __sanitizer {
 class FlagParser;
private:
 
   u32 next_id_;
   InternalMmapVector<Leak> leaks_;
   InternalMmapVector<LeakedObject> leaked_objects_;
 };
 
 typedef InternalMmapVector<uptr> Frontier;
 
+#if CAN_SANITIZE_LEAKS
+struct ChunkMetadata {
+  u8 allocated : 8;  // Must be first.
+  ChunkTag tag : 2;
+  uptr requested_size : 54;
+  u32 stack_trace_id;
+};
+
+#if defined(__mips64) || defined(__aarch64__)
+static const uptr kMaxAllowedMallocSize = 4UL << 30;
+static const uptr kRegionSizeLog = 20;
+static const uptr kNumRegions = SANITIZER_MMAP_RANGE_SIZE >> kRegionSizeLog;
+typedef TwoLevelByteMap<(kNumRegions >> 12), 1 << 12> ByteMap;
+typedef CompactSizeClassMap SizeClassMap;
+typedef SizeClassAllocator32<0, SANITIZER_MMAP_RANGE_SIZE,
+    sizeof(ChunkMetadata), SizeClassMap, kRegionSizeLog, ByteMap>
+    PrimaryAllocator;
+#else
+static const uptr kMaxAllowedMallocSize = 8UL << 30;
+static const uptr kAllocatorSpace = 0x600000000000ULL;
+static const uptr kAllocatorSize = 0x40000000000ULL; // 4T.
+typedef SizeClassAllocator64<kAllocatorSpace, kAllocatorSize,
+        sizeof(ChunkMetadata), DefaultSizeClassMap> PrimaryAllocator;
+#endif
+
+typedef SizeClassAllocatorLocalCache<PrimaryAllocator> AllocatorCache;
+typedef LargeMmapAllocator<> SecondaryAllocator;
+typedef CombinedAllocator<PrimaryAllocator, AllocatorCache,
+          SecondaryAllocator> Allocator;
+#else
+typedef int AllocatorCache;
+#endif // CAN_SANITIZE_LEAKS
+
+const u32 kInvalidTid = (u32) -1;
+
+struct LsanThread {
+  int init;
+  int disable_counter;
+  u32 tid;
+  AllocatorCache cache;
+};
+
 // Platform-specific functions.
 void InitializePlatformSpecificModules();
 void ProcessGlobalRegions(Frontier *frontier);
 void ProcessPlatformSpecificAllocations(Frontier *frontier);
 // Run stoptheworld while holding any platform-specific locks.
 void DoStopTheWorld(StopTheWorldCallback callback, void* argument);
 
 void ScanRangeForPointers(uptr begin, uptr end,

lsan/lsan_common.cc

 //=-- lsan_common.cc ------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of LeakSanitizer.
 // Implementation of common leak checking functionality.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lsan_common.h"
+#include "lsan_allocator.h"
+#include "lsan_thread.h"
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_flags.h"
 #include "sanitizer_common/sanitizer_flag_parser.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_procmaps.h"
 #include "sanitizer_common/sanitizer_stackdepot.h"
 #include "sanitizer_common/sanitizer_stacktrace.h"
 #include "sanitizer_common/sanitizer_suppressions.h"
 #include "sanitizer_common/sanitizer_report_decorator.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 
 #if CAN_SANITIZE_LEAKS
 namespace __lsan {
 
 // This mutex is used to prevent races between DoLeakCheck and IgnoreObject, and
 // also to protect the global list of root regions.
 BlockingMutex global_mutex(LINKER_INITIALIZED);
 
-THREADLOCAL int disable_counter;
-bool DisabledInThisThread() { return disable_counter > 0; }
-void DisableInThisThread() { disable_counter++; }
+bool DisabledInThisThread() { return GetCurrentThread()->disable_counter > 0; }
+void DisableInThisThread() { GetCurrentThread()->disable_counter++; }
 void EnableInThisThread() {
-  if (!disable_counter && common_flags()->detect_leaks) {
+  if (!(GetCurrentThread()->disable_counter) && common_flags()->detect_leaks) {
     Report("Unmatched call to __lsan_enable().\n");
     Die();
   }
-  disable_counter--;
+  GetCurrentThread()->disable_counter--;
 }
 
 Flags lsan_flags;
 
 void Flags::SetDefaults() {
 #define LSAN_FLAG(Type, Name, DefaultValue, Description) Name = DefaultValue;
 #include "lsan_flags.inc"
 #undef LSAN_FLAG
if (flags()->use_stacks) {
       }
       ScanRangeForPointers(stack_begin, stack_end, frontier, "STACK",
                            kReachable);
       ForEachExtraStackRange(os_id, ForEachExtraStackRangeCb, frontier);
     }
 
     if (flags()->use_tls) {
       LOG_THREADS("TLS at %p-%p.\n", tls_begin, tls_end);
-      if (cache_begin == cache_end) {
+      if (cache_begin == cache_end || cache_begin >= tls_end || cache_end <= tls_begin) {
         ScanRangeForPointers(tls_begin, tls_end, frontier, "TLS", kReachable);
       } else {
         // Because LSan should not be loaded with dlopen(), we can assume
         // that allocator cache will be part of static TLS image.
         CHECK_LE(tls_begin, cache_begin);
         CHECK_GE(tls_end, cache_end);
         if (tls_begin < cache_begin)
           ScanRangeForPointers(tls_begin, cache_begin, frontier, "TLS",

lsan/lsan_interceptors.cc

extern "C" void *__lsan_thread_start_func(void *arg) {
   if (pthread_setspecific(g_thread_finalize_key,
                           (void*)GetPthreadDestructorIterations())) {
     Report("LeakSanitizer: failed to set thread key.\n");
     Die();
   }
   int tid = 0;
   while ((tid = atomic_load(&p->tid, memory_order_acquire)) == 0)
     internal_sched_yield();
-  SetCurrentThread(tid);
+  GetCurrentThread()->tid = tid;
   ThreadStart(tid, GetTid());
   atomic_store(&p->tid, 0, memory_order_release);
   return callback(param);
 }
 
 INTERCEPTOR(int, pthread_create, void *th, void *attr,
             void *(*callback)(void *), void *param) {
   ENSURE_LSAN_INITED;
int res;
     // Ignore all allocations made by pthread_create: thread stack/TLS may be
     // stored by pthread for future reuse even after thread destruction, and
     // the linked list it's stored in doesn't even hold valid pointers to the
     // objects, the latter are calculated by obscure pointer arithmetic.
     ScopedInterceptorDisabler disabler;
     res = REAL(pthread_create)(th, attr, __lsan_thread_start_func, &p);
   }
   if (res == 0) {
-    int tid = ThreadCreate(GetCurrentThread(), *(uptr *)th, detached);
+    int tid = ThreadCreate(GetCurrentThread()->tid, *(uptr *)th, detached);
     CHECK_NE(tid, 0);
     atomic_store(&p.tid, tid, memory_order_release);
     while (atomic_load(&p.tid, memory_order_acquire) != 0)
       internal_sched_yield();
   }
   if (attr == &myattr)
     pthread_attr_destroy(&myattr);
   return res;

lsan/lsan_thread.h

 // Thread registry for standalone LSan.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LSAN_THREAD_H
 #define LSAN_THREAD_H
 
 #include "sanitizer_common/sanitizer_thread_registry.h"
+#include "lsan_common.h"
 
 namespace __sanitizer {
 struct DTLS;
 }
 
 namespace __lsan {
 
 class ThreadContext : public ThreadContextBase {

 void InitializeThreadRegistry();
 
 void ThreadStart(u32 tid, uptr os_id);
 void ThreadFinish();
 u32 ThreadCreate(u32 tid, uptr uid, bool detached);
 void ThreadJoin(u32 tid);
 u32 ThreadTid(uptr uid);
 
-u32 GetCurrentThread();
-void SetCurrentThread(u32 tid);
+LsanThread* GetCurrentThread(void);
 ThreadContext *CurrentThreadContext();
 void EnsureMainThreadIDIsCorrect();
 }  // namespace __lsan
 
 #endif  // LSAN_THREAD_H

lsan/lsan_thread.cc

 //=-- lsan_thread.cc ------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of LeakSanitizer.
 // See lsan_thread.h for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lsan_thread.h"
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_thread_registry.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
+#include "sanitizer_common/sanitizer_linux.h"
 #include "lsan_allocator.h"
 
 namespace __lsan {
-
-const u32 kInvalidTid = (u32) -1;
-
 static ThreadRegistry *thread_registry;
-static THREADLOCAL u32 current_thread_tid = kInvalidTid;
 
 static ThreadContextBase *CreateThreadContext(u32 tid) {
   void *mem = MmapOrDie(sizeof(ThreadContext), "ThreadContext");
   return new(mem) ThreadContext(tid);
 }
 
 static const uptr kMaxThreads = 1 << 13;
 static const uptr kThreadQuarantineSize = 64;
 
 void InitializeThreadRegistry() {
   static char thread_registry_placeholder[sizeof(ThreadRegistry)] ALIGNED(64);
   thread_registry = new(thread_registry_placeholder)
     ThreadRegistry(CreateThreadContext, kMaxThreads, kThreadQuarantineSize);
 }
 
-u32 GetCurrentThread() {
-  return current_thread_tid;
+
+#if SANITIZER_ANDROID
+// Based on tsan_platform_linux.cc::cur_thread
+LsanThread* GetCurrentThread(void) {
+  LsanThread* tls = (LsanThread*)(*AndroidGetTls());
+  if (tls == nullptr) {
+    __sanitizer_sigset_t emptyset;
+    internal_sigfillset(&emptyset);
+    __sanitizer_sigset_t oldset;
+    CHECK_EQ(0, internal_sigprocmask(sig_setmask, &emptyset, &oldset));
+    tls = reinterpret_cast<LsanThread*>(*AndroidGetTls());
+    if (tls == nullptr) {
+      tls = reinterpret_cast<LsanThread*>(MmapOrDie(sizeof(LsanThread),
+                                                    "LsanThread"));
+      tls->tid = kInvalidTid;
+      *(AndroidGetTls()) = tls;
+    }
+    CHECK_EQ(0, internal_sigprocmask(sig_setmask, &oldset, nullptr));
+  }
+  return tls;
+}
+#else
+static THREADLOCAL LsanThread tls;
+
+LsanThread* GetCurrentThread(void) {
+  if (!tls.init) {
+      tls.tid = kInvalidTid;
+      tls.init = 1;
   }
 
-void SetCurrentThread(u32 tid) {
-  current_thread_tid = tid;
+  return &tls;
 }
+#endif // SANITIZER_ANDROID
+
 
 ThreadContext::ThreadContext(int tid)
     : ThreadContextBase(tid),
       stack_begin_(0),
       stack_end_(0),
       cache_begin_(0),
       cache_end_(0),
       tls_begin_(0),
void ThreadStart(u32 tid, uptr os_id) {
   args.stack_end = args.stack_begin + stack_size;
   args.tls_end = args.tls_begin + tls_size;
   GetAllocatorCacheRange(&args.cache_begin, &args.cache_end);
   args.dtls = DTLS_Get();
   thread_registry->StartThread(tid, os_id, &args);
 }
 
 void ThreadFinish() {
-  thread_registry->FinishThread(GetCurrentThread());
+  thread_registry->FinishThread(GetCurrentThread()->tid);
 }
 
 ThreadContext *CurrentThreadContext() {
   if (!thread_registry) return nullptr;
-  if (GetCurrentThread() == kInvalidTid)
+  if (GetCurrentThread()->tid == kInvalidTid)
     return nullptr;
   // No lock needed when getting current thread.
-  return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread());
+  return (ThreadContext *)thread_registry->GetThreadLocked(GetCurrentThread()->tid);
 }
 
 static bool FindThreadByUid(ThreadContextBase *tctx, void *arg) {
   uptr uid = (uptr)arg;
   if (tctx->user_id == uid && tctx->status != ThreadStatusInvalid) {
     return true;
   }
   return false;
 }
 
 u32 ThreadTid(uptr uid) {
   return thread_registry->FindThread(FindThreadByUid, (void*)uid);
 }
 
 void ThreadJoin(u32 tid) {
   CHECK_NE(tid, kInvalidTid);
   thread_registry->JoinThread(tid, /* arg */nullptr);
 }
 
 void EnsureMainThreadIDIsCorrect() {
-  if (GetCurrentThread() == 0)
+  if (GetCurrentThread()->tid == 0)
     CurrentThreadContext()->os_id = GetTid();
 }
 
 ///// Interface to the common LSan module. /////
 
 bool GetThreadRangesLocked(uptr os_id, uptr *stack_begin, uptr *stack_end,
                            uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
                            uptr *cache_end, DTLS **dtls) {

sanitizer_common/sanitizer_common.h

inline void *operator new(__sanitizer::operator_new_size_type size,
   return alloc.Allocate(size);
 }
 
 struct StackDepotStats {
   uptr n_uniq_ids;
   uptr allocated;
 };
 
+#if SANITIZER_ANDROID
+// Voodoo from tsan
+#if defined(__aarch64__)
+# define __get_tls() ({ void** __val; __asm__("mrs %0, tpidr_el0" : "=r"(__val)); __val; })
+#elif defined(__x86_64__)
+# define __get_tls() ({ void** __val; __asm__("mov %%fs:0, %0" : "=r"(__val)); __val; })
+#endif
+
+static const int TLS_SLOT_TSAN = 8;
+
+#if defined(__get_tls)
+INLINE void **AndroidGetTls() { return &__get_tls()[TLS_SLOT_TSAN];}
+#else
+INLINE void **AndroidGetTls() { return nullptr;}
+#endif
+
+#endif // SANITIZER_ANDROID
+
 #endif  // SANITIZER_COMMON_H

sanitizer_common/sanitizer_platform_limits_posix.h

#endif
   extern unsigned struct_itimerspec_sz;
   extern unsigned struct_sigevent_sz;
   extern unsigned struct_sched_param_sz;
   extern unsigned struct_statfs64_sz;
 
 #if !SANITIZER_ANDROID
   extern unsigned struct_statfs_sz;
   extern unsigned struct_sockaddr_sz;
-  extern unsigned ucontext_t_sz;
 #endif // !SANITIZER_ANDROID
 
+  extern unsigned ucontext_t_sz;
+
 #if SANITIZER_LINUX
 
 #if defined(__x86_64__)
   const unsigned struct_kernel_stat_sz = 144;
   const unsigned struct_kernel_stat64_sz = 0;
 #elif defined(__i386__)
   const unsigned struct_kernel_stat_sz = 64;
   const unsigned struct_kernel_stat64_sz = 96;

 #endif // SANITIZER_LINUX || SANITIZER_FREEBSD
 
 #if SANITIZER_ANDROID
   struct __sanitizer_mallinfo {
     uptr v[10];
   };
 #endif
 
+#if SANITIZER_LINUX
+  extern unsigned struct_rlimit64_sz;
+#endif
+
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   struct __sanitizer_mallinfo {
     int v[10];
   };
 
   extern unsigned struct_ustat_sz;
-  extern unsigned struct_rlimit64_sz;
   extern unsigned struct_statvfs64_sz;
 
   struct __sanitizer_ipc_perm {
     int __key;
     int uid;
     int gid;
     int cuid;
     int cgid;

sanitizer_common/sanitizer_platform_limits_posix.cc

 
 #if SANITIZER_MAC && !SANITIZER_IOS
   unsigned struct_statfs64_sz = sizeof(struct statfs64);
 #endif // SANITIZER_MAC && !SANITIZER_IOS
 
 #if !SANITIZER_ANDROID
   unsigned struct_statfs_sz = sizeof(struct statfs);
   unsigned struct_sockaddr_sz = sizeof(struct sockaddr);
-  unsigned ucontext_t_sz = sizeof(ucontext_t);
 #endif // !SANITIZER_ANDROID
 
+unsigned ucontext_t_sz = sizeof(ucontext_t);
+
 #if SANITIZER_LINUX
   unsigned struct_epoll_event_sz = sizeof(struct epoll_event);
   unsigned struct_sysinfo_sz = sizeof(struct sysinfo);
   unsigned __user_cap_header_struct_sz =
       sizeof(struct __user_cap_header_struct);
   unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct);
   unsigned struct_new_utsname_sz = sizeof(struct new_utsname);
   unsigned struct_old_utsname_sz = sizeof(struct old_utsname);
   unsigned struct_oldold_utsname_sz = sizeof(struct oldold_utsname);
 #endif // SANITIZER_LINUX
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
   unsigned struct_rlimit_sz = sizeof(struct rlimit);
   unsigned struct_timespec_sz = sizeof(struct timespec);
   unsigned struct_utimbuf_sz = sizeof(struct utimbuf);
   unsigned struct_itimerspec_sz = sizeof(struct itimerspec);
 #endif // SANITIZER_LINUX || SANITIZER_FREEBSD
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_ustat_sz = sizeof(struct ustat);
-  unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
   unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
+#if SANITIZER_LINUX
+  unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
+#endif // SANITIZER_LINUX
+
 #if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
   unsigned struct_timex_sz = sizeof(struct timex);
   unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
   unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
   unsigned struct_statvfs_sz = sizeof(struct statvfs);
 #endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
 
   uptr sig_ign = (uptr)SIG_IGN;