[HWASAN] Implmented LSAN specifc thread support.

[kstoimenov]

Summary

Implemented LSAN interface on HwasanThreadList and added os_id to __hwasan::Thread.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread.cpp

12

why do you need sanitizer_thread_registry?

[kstoimenov]

Removed include.

[kstoimenov]

compiler-rt/lib/hwasan/hwasan_thread.cpp

12

It was from my previous attempts to make it work with it. Nice catch. Removed.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

221

why do we need another mutex?

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

206

In a separate patch, can you put thread-safety annotations for all fields?

[kstoimenov]

After rebase.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

187

I guess we care about live_list_mutex_

[kstoimenov]

After rebase.

compiler-rt/lib/hwasan/hwasan_thread.h

public:
 
   u32 unique_id() const { return unique_id_; }
   void Announce() {
     if (announced_) return;
     announced_ = true;
     Print("Thread: ");
   }
 
+  tid_t os_id() const { return os_id_; }
+  void set_os_id(tid_t os_id) { os_id_ = os_id; }
+
   uptr &vfork_spill() { return vfork_spill_; }
 
  private:
   // NOTE: There is no Thread constructor. It is allocated
   // via mmap() and *must* be valid in zero-initialized state.
   void ClearShadowForThreadStackAndTLS();
   void Print(const char *prefix);
   void InitRandomState();
   uptr vfork_spill_;
   uptr stack_top_;
   uptr stack_bottom_;
   uptr tls_begin_;
   uptr tls_end_;
   DTLS *dtls_;
 
   u32 random_state_;
   u32 random_buffer_;
 
   AllocatorCache allocator_cache_;
   HeapAllocationsRingBuffer *heap_allocations_;
   StackAllocationsRingBuffer *stack_allocations_;
 
   u32 unique_id_;  // counting from zero.
 
+  tid_t os_id_;
+
   u32 tagging_disabled_;  // if non-zero, malloc uses zero tag in this thread.
 
   bool announced_;
 
   bool random_state_inited_;  // Whether InitRandomState() has been called.
 
   friend struct ThreadListHead;
 };

compiler-rt/lib/hwasan/hwasan_thread.cpp

 
 #include "hwasan_thread.h"
 
 #include "hwasan.h"
 #include "hwasan_interface_internal.h"
 #include "hwasan_mapping.h"
 #include "hwasan_poisoning.h"
+#include "hwasan_thread_list.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "sanitizer_common/sanitizer_placement_new.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 
 namespace __hwasan {
 
 static u32 RandomSeed() {
   u32 seed;
   do {
     if (UNLIKELY(!GetRandom(reinterpret_cast<void *>(&seed), sizeof(seed),
                             /*blocking=*/false))) {
if (flags()->random_tags) {
       random_state_ += 1;
       tag = random_state_ & tag_mask;
     }
   } while (!tag);
   return tag;
 }
 
 } // namespace __hwasan
+
+// --- Implementation of LSan-specific functions --- {{{1
+namespace __lsan {
+
+static __hwasan::HwasanThreadList *GetHwasanThreadListLocked() {
+  auto &tl = __hwasan::hwasanThreadList();
+  tl.CheckLocked();
+  return &tl;
+}
+
+static __hwasan::Thread *GetThreadByOsIDLocked(tid_t os_id) {
+  return GetHwasanThreadListLocked()->FindThreadLocked(
+      [os_id](__hwasan::Thread *t) { return t->os_id() == os_id; });
+}
+
+void LockThreadRegistry() { __hwasan::hwasanThreadList().Lock(); }
+
+void UnlockThreadRegistry() { __hwasan::hwasanThreadList().Unlock(); }
+
+void EnsureMainThreadIDIsCorrect() {
+  auto *t = __hwasan::GetCurrentThread();
+  if (t && (t->IsMainThread()))
+    t->set_os_id(GetTid());
+}
+
+bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end,
+                           uptr *tls_begin, uptr *tls_end, uptr *cache_begin,
+                           uptr *cache_end, DTLS **dtls) {
+  auto *t = GetThreadByOsIDLocked(os_id);
+  if (!t)
+    return false;
+  *stack_begin = t->stack_bottom();
+  *stack_end = t->stack_top();
+  *tls_begin = t->tls_begin();
+  *tls_end = t->tls_end();
+  // Fixme: is this correct for HWASan.
+  *cache_begin = 0;
+  *cache_end = 0;
+  *dtls = t->dtls();
+  return true;
+}
+
+void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches) {}
+
+void ForEachExtraStackRange(tid_t os_id, RangeIteratorCallback callback,
+                            void *arg) {}
+
+void GetAdditionalThreadContextPtrsLocked(InternalMmapVector<uptr> *ptrs) {}
+void ReportUnsuspendedThreadsLocked(InternalMmapVector<tid_t> *threads) {}
+
+}  // namespace __lsan

compiler-rt/lib/hwasan/hwasan_thread_list.h

static uptr RingBufferSize() {
   return 0;
 }
 
 struct ThreadStats {
   uptr n_live_threads;
   uptr total_stack_size;
 };
 
-class HwasanThreadList {
+class SANITIZER_MUTEX HwasanThreadList {
  public:
   HwasanThreadList(uptr storage, uptr size)
       : free_space_(storage), free_space_end_(storage + size) {
     // [storage, storage + size) is used as a vector of
     // thread_alloc_size_-sized, ring_buffer_size_*2-aligned elements.
     // Each element contains
     // * a ring buffer at offset 0,
     // * a Thread object at offset ring_buffer_size_.
public:
   }
 
   template <class CB>
   void VisitAllLiveThreads(CB cb) SANITIZER_EXCLUDES(live_list_mutex_) {
     SpinMutexLock l(&live_list_mutex_);
     for (Thread *t : live_list_) cb(t);
   }
 
+  template <class CB>
+  Thread *FindThreadLocked(CB cb) SANITIZER_CHECK_LOCKED(stats_mutex_) {
+    CheckLocked();
+    for (Thread *t : live_list_)
+      if (cb(t))
+        return t;
+    return nullptr;
+  }
+
   void AddThreadStats(Thread *t) SANITIZER_EXCLUDES(stats_mutex_) {
     SpinMutexLock l(&stats_mutex_);
     stats_.n_live_threads++;
     stats_.total_stack_size += t->stack_size();
   }
 
   void RemoveThreadStats(Thread *t) SANITIZER_EXCLUDES(stats_mutex_) {
     SpinMutexLock l(&stats_mutex_);
     stats_.n_live_threads--;
     stats_.total_stack_size -= t->stack_size();
   }
 
   ThreadStats GetThreadStats() SANITIZER_EXCLUDES(stats_mutex_) {
     SpinMutexLock l(&stats_mutex_);
     return stats_;
   }
 
   uptr GetRingBufferSize() const { return ring_buffer_size_; }
 
+  void Lock() SANITIZER_ACQUIRE(live_list_mutex_) { live_list_mutex_.Lock(); }
+  void CheckLocked() const SANITIZER_CHECK_LOCKED(live_list_mutex_) {
+    live_list_mutex_.CheckLocked();
+  }
+  void Unlock() SANITIZER_RELEASE(live_list_mutex_) {
+    live_list_mutex_.Unlock();
+  }
+
  private:
   Thread *AllocThread() {
     SpinMutexLock l(&free_space_mutex_);
     uptr align = ring_buffer_size_ * 2;
     CHECK(IsAligned(free_space_, align));
     Thread *t = (Thread *)(free_space_ + ring_buffer_size_);
     free_space_ += thread_alloc_size_;
     CHECK(free_space_ <= free_space_end_ && "out of thread memory");
     return t;
   }
 
   SpinMutex free_space_mutex_;
   uptr free_space_;
   uptr free_space_end_;
   uptr ring_buffer_size_;
   uptr thread_alloc_size_;
 
   SpinMutex free_list_mutex_;
   InternalMmapVector<Thread *> free_list_
       SANITIZER_GUARDED_BY(free_list_mutex_);
   SpinMutex live_list_mutex_;
   InternalMmapVector<Thread *> live_list_
       SANITIZER_GUARDED_BY(live_list_mutex_);
 
   SpinMutex stats_mutex_;
   ThreadStats stats_ SANITIZER_GUARDED_BY(stats_mutex_);
 };
 
 void InitThreadList(uptr storage, uptr size);
 HwasanThreadList &hwasanThreadList();
 
 } // namespace __hwasan