[HWASAN] Added thread annotations to HwasanThreadList.

[kstoimenov]

Removed helper functions.

[vitalybuka]

compiler-rt/lib/hwasan/hwasan_thread_list.h

159

Why SANITIZER_EXCLUDES is inconsistent?

[kstoimenov]

Added stats_mutex_.

[kstoimenov]

compiler-rt/lib/hwasan/hwasan_thread_list.h

159

I missed stats_mutex_. Nice catch. Done.

compiler-rt/lib/hwasan/hwasan_thread_list.h

HwasanThreadList(uptr storage, uptr size)
     // Each element contains
     // * a ring buffer at offset 0,
     // * a Thread object at offset ring_buffer_size_.
     ring_buffer_size_ = RingBufferSize();
     thread_alloc_size_ =
         RoundUpTo(ring_buffer_size_ + sizeof(Thread), ring_buffer_size_ * 2);
   }
 
-  Thread *CreateCurrentThread(const Thread::InitState *state = nullptr) {
+  Thread *CreateCurrentThread(const Thread::InitState *state = nullptr)
+      SANITIZER_EXCLUDES(free_list_mutex_, live_list_mutex_) {
     Thread *t = nullptr;
     {
       SpinMutexLock l(&free_list_mutex_);
       if (!free_list_.empty()) {
         t = free_list_.back();
         free_list_.pop_back();
       }
     }
Thread *CreateCurrentThread(const Thread::InitState *state = nullptr)
     return t;
   }
 
   void DontNeedThread(Thread *t) {
     uptr start = (uptr)t - ring_buffer_size_;
     ReleaseMemoryPagesToOS(start, start + thread_alloc_size_);
   }
 
-  void RemoveThreadFromLiveList(Thread *t) {
+  void RemoveThreadFromLiveList(Thread *t)
+      SANITIZER_EXCLUDES(live_list_mutex_) {
     SpinMutexLock l(&live_list_mutex_);
     for (Thread *&t2 : live_list_)
       if (t2 == t) {
         // To remove t2, copy the last element of the list in t2's position, and
         // pop_back(). This works even if t2 is itself the last element.
         t2 = live_list_.back();
         live_list_.pop_back();
         return;
       }
     CHECK(0 && "thread not found in live list");
   }
 
-  void ReleaseThread(Thread *t) {
+  void ReleaseThread(Thread *t) SANITIZER_EXCLUDES(free_list_mutex_) {
     RemoveThreadStats(t);
     t->Destroy();
     DontNeedThread(t);
     RemoveThreadFromLiveList(t);
     SpinMutexLock l(&free_list_mutex_);
     free_list_.push_back(t);
   }
 
   Thread *GetThreadByBufferAddress(uptr p) {
     return (Thread *)(RoundDownTo(p, ring_buffer_size_ * 2) +
                       ring_buffer_size_);
   }
 
   uptr MemoryUsedPerThread() {
     uptr res = sizeof(Thread) + ring_buffer_size_;
     if (auto sz = flags()->heap_history_size)
       res += HeapAllocationsRingBuffer::SizeInBytes(sz);
     return res;
   }
 
   template <class CB>
-  void VisitAllLiveThreads(CB cb) {
+  void VisitAllLiveThreads(CB cb) SANITIZER_EXCLUDES(live_list_mutex_) {
     SpinMutexLock l(&live_list_mutex_);
     for (Thread *t : live_list_) cb(t);
   }
 
-  void AddThreadStats(Thread *t) {
+  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) {
+  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() {
+  ThreadStats GetThreadStats() SANITIZER_EXCLUDES(stats_mutex_) {
     SpinMutexLock l(&stats_mutex_);
     return stats_;
   }
 
   uptr GetRingBufferSize() const { return ring_buffer_size_; }
 
  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_;
+  InternalMmapVector<Thread *> free_list_
+      SANITIZER_GUARDED_BY(free_list_mutex_);
   SpinMutex live_list_mutex_;
-  InternalMmapVector<Thread *> live_list_;
+  InternalMmapVector<Thread *> live_list_
+      SANITIZER_GUARDED_BY(live_list_mutex_);
 
-  ThreadStats stats_;
   SpinMutex stats_mutex_;
+  ThreadStats stats_ SANITIZER_GUARDED_BY(stats_mutex_);
 };
 
 void InitThreadList(uptr storage, uptr size);
 HwasanThreadList &hwasanThreadList();
 
 } // namespace __hwasan