Attempt to make RunCallbackForEachRunningThreadLocked work.

compiler-rt/lib/asan/asan_allocator.cpp

if (!m ||
     return kIgnoreObjectInvalid;
   }
   if (m->lsan_tag == kIgnored)
     return kIgnoreObjectAlreadyIgnored;
   m->lsan_tag = __lsan::kIgnored;
   return kIgnoreObjectSuccess;
 }
 
-void GetAdditionalThreadContextPtrs(ThreadContextBase *tctx, void *ptrs) {
+static inline void GetAdditionalThreadContextPtrs(
+    __asan::AsanThreadContext *atctx, void *ptrs) {
   // Look for the arg pointer of threads that have been created or are running.
   // This is necessary to prevent false positive leaks due to the AsanThread
   // holding the only live reference to a heap object.  This can happen because
   // the `pthread_create()` interceptor doesn't wait for the child thread to
   // start before returning and thus loosing the the only live reference to the
   // heap object on the stack.
 
-  __asan::AsanThreadContext *atctx =
-      reinterpret_cast<__asan::AsanThreadContext *>(tctx);
   __asan::AsanThread *asan_thread = atctx->thread;
 
   // Note ThreadStatusRunning is required because there is a small window where
   // the thread status switches to `ThreadStatusRunning` but the `arg` pointer
   // still isn't on the stack yet.
   if (atctx->status != ThreadStatusCreated &&
       atctx->status != ThreadStatusRunning)
     return;
 
   uptr thread_arg = reinterpret_cast<uptr>(asan_thread->get_arg());
   if (!thread_arg)
     return;
 
   auto ptrsVec = reinterpret_cast<InternalMmapVector<uptr> *>(ptrs);
   ptrsVec->push_back(thread_arg);
 }
 
+void GetAdditionalThreadContextPtrs(void *context, void *arg) {
+  GetAdditionalThreadContextPtrs(
+      static_cast<__asan::AsanThreadContext *>(context), arg);
+}
+
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
 // ASan allocator doesn't reserve extra bytes, so normally we would
 // just return "size". We don't want to expose our redzone sizes, etc here.
 uptr __sanitizer_get_estimated_allocated_size(uptr size) {

compiler-rt/lib/asan/asan_thread.cpp

void ForEachExtraStackRange(tid_t os_id, RangeIteratorCallback callback,
   if (!t)
     return;
   __asan::FakeStack *fake_stack = t->get_fake_stack();
   if (!fake_stack)
     return;
   fake_stack->ForEachFakeFrame(callback, arg);
 }
 
-void RunCallbackForEachThreadLocked(__sanitizer::ThreadRegistry::ThreadCallback cb,
-                                    void *arg) {
+void RunCallbackForEachThreadLocked(LsanThreadCallback cb, void *arg) {
   GetAsanThreadRegistryLocked()->RunCallbackForEachThreadLocked(cb, arg);
 }
 
+static inline void ReportIfNotSuspended(ThreadContextBase *tctx, void *threads) {
+  const InternalMmapVector<tid_t> &suspended_threads =
+      *(const InternalMmapVector<tid_t> *)threads;
+  if (tctx->status == ThreadStatusRunning) {
+    uptr i = InternalLowerBound(suspended_threads, tctx->os_id);
+    if (i >= suspended_threads.size() || suspended_threads[i] != tctx->os_id)
+      Report(
+          "Running thread %llu was not suspended. False leaks are possible.\n",
+          tctx->os_id);
+  }
+}
+
+void ReportIfNotSuspended(void *context, void *arg) {
+  ReportIfNotSuspended(static_cast<ThreadContextBase *>(context), arg);
+}
+
+
 void FinishThreadLocked(u32 tid) {
   GetAsanThreadRegistryLocked()->FinishThread(tid);
 }
 
 } // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;

compiler-rt/lib/hwasan/hwasan_thread.cpp

bool GetThreadRangesLocked(tid_t os_id, uptr *stack_begin, uptr *stack_end,
   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) {}
+void GetAdditionalThreadContextPtrs(void *context, void *arg) {}
+void ReportIfNotSuspended(void *context, void *arg) {}
 
 }  // namespace __lsan

compiler-rt/lib/lsan/lsan_allocator.cpp

if (m->tag == kIgnored)
       return kIgnoreObjectAlreadyIgnored;
     m->tag = kIgnored;
     return kIgnoreObjectSuccess;
   } else {
     return kIgnoreObjectInvalid;
   }
 }
 
-void GetAdditionalThreadContextPtrs(ThreadContextBase *tctx, void *ptrs) {
+void GetAdditionalThreadContextPtrs(void *context, void *args) {
   // This function can be used to treat memory reachable from `tctx` as live.
   // This is useful for threads that have been created but not yet started.
 
   // This is currently a no-op because the LSan `pthread_create()` interceptor
   // blocks until the child thread starts which keeps the thread's `arg` pointer
   // live.
 }
 

compiler-rt/lib/lsan/lsan_common.h

 
 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);
 void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches);
 void ForEachExtraStackRange(tid_t os_id, RangeIteratorCallback callback,
                             void *arg);
 
-void RunCallbackForEachThreadLocked(__sanitizer::ThreadRegistry::ThreadCallback cb,
-                                    void *arg);
+typedef void (*LsanThreadCallback)(void *context, void *arg);
+void RunCallbackForEachThreadLocked(LsanThreadCallback cb, void *arg);
+void GetAdditionalThreadContextPtrs(void *context, void *ptrs);
+void ReportIfNotSuspended(void *context, void *arg);
+
 
 //// --------------------------------------------------------------------------
 //// Allocator prototypes.
 //// --------------------------------------------------------------------------
 
 // Wrappers for allocator's ForceLock()/ForceUnlock().
 void LockAllocator();
 void UnlockAllocator();

 };
 
 // Iterate over all existing chunks. Allocator must be locked.
 void ForEachChunk(ForEachChunkCallback callback, void *arg);
 
 // Helper for __lsan_ignore_object().
 IgnoreObjectResult IgnoreObjectLocked(const void *p);
 
-void GetAdditionalThreadContextPtrs(ThreadContextBase *tctx, void *ptrs);
-
 // The rest of the LSan interface which is implemented by library.
 
 struct ScopedStopTheWorldLock {
   ScopedStopTheWorldLock() {
     LockThreadRegistry();
     LockAllocator();
   }
 

compiler-rt/lib/lsan/lsan_common.cpp

void LeakSuppressionContext::PrintMatchedSuppressions() {
   for (uptr i = 0; i < matched.size(); i++) {
     Printf("%7zu %10zu %s\n",
            static_cast<uptr>(atomic_load_relaxed(&matched[i]->hit_count)),
            matched[i]->weight, matched[i]->templ);
   }
   Printf("%s\n\n", line);
 }
 
-static void ReportIfNotSuspended(ThreadContextBase *tctx, void *arg) {
-  const InternalMmapVector<tid_t> &suspended_threads =
-      *(const InternalMmapVector<tid_t> *)arg;
-  if (tctx->status == ThreadStatusRunning) {
-    uptr i = InternalLowerBound(suspended_threads, tctx->os_id);
-    if (i >= suspended_threads.size() || suspended_threads[i] != tctx->os_id)
-      Report(
-          "Running thread %llu was not suspended. False leaks are possible.\n",
-          tctx->os_id);
-  }
-}
-
 #  if SANITIZER_FUCHSIA
 
 // Fuchsia provides a libc interface that guarantees all threads are
 // covered, and SuspendedThreadList is never really used.
 static void ReportUnsuspendedThreads(const SuspendedThreadsList &) {}
 
 #  else  // !SANITIZER_FUCHSIA
 
 static void ReportUnsuspendedThreads(
     const SuspendedThreadsList &suspended_threads) {
   InternalMmapVector<tid_t> threads(suspended_threads.ThreadCount());
   for (uptr i = 0; i < suspended_threads.ThreadCount(); ++i)
     threads[i] = suspended_threads.GetThreadID(i);
 
   Sort(threads.data(), threads.size());
 
-  RunCallbackForEachThreadLocked(&ReportIfNotSuspended, &threads);
+  RunCallbackForEachThreadLocked(ReportIfNotSuspended, &threads);
 }
 
 #  endif  // !SANITIZER_FUCHSIA
 
 static void CheckForLeaksCallback(const SuspendedThreadsList &suspended_threads,
                                   void *arg) {
   CheckForLeaksParam *param = reinterpret_cast<CheckForLeaksParam *>(arg);
   CHECK(param);

compiler-rt/lib/lsan/lsan_common_fuchsia.cpp

__sanitizer_memory_snapshot(
         auto params = static_cast<const Params *>(data);
 
         // We don't use the thread registry at all for enumerating the threads
         // and their stacks, registers, and TLS regions.  So use it separately
         // just for the allocator cache, and to call ForEachExtraStackRange,
         // which ASan needs.
         if (flags()->use_stacks) {
           RunCallbackForEachThreadLocked(
-              [](ThreadContextBase *tctx, void *arg) {
+              [](ThreadContextBase *context, void *arg) {
+                auto tctx = static_cast<ThreadContext *>(context);
                 ForEachExtraStackRange(tctx->os_id, ForEachExtraStackRangeCb,
                                        arg);
               },
               &params->argument->frontier);
         }
 
         params->callback(SuspendedThreadsListFuchsia(), params->argument);
       },

compiler-rt/lib/lsan/lsan_fuchsia.cpp

__sanitizer::GetThreadStackTopAndBottom(true, &args.stack_end,
                                           &args.stack_begin);
   u32 tid = ThreadCreate(kMainTid, true, &args);
   CHECK_EQ(tid, 0);
   ThreadStart(tid);
 }
 
 void GetAllThreadAllocatorCachesLocked(InternalMmapVector<uptr> *caches) {
   RunCallbackForEachThreadLocked(
-      [](ThreadContextBase *tctx, void *arg) {
+      [](void *tctx, void *arg) {
         auto ctx = static_cast<ThreadContext *>(tctx);
         static_cast<decltype(caches)>(arg)->push_back(ctx->cache_begin());
       },
       caches);
 }
 
 // On Fuchsia, leak detection is done by a special hook after atexit hooks.
 // So this doesn't install any atexit hook like on other platforms.

compiler-rt/lib/lsan/lsan_thread.cpp

ThreadRegistry *GetLsanThreadRegistryLocked() {
   return thread_registry;
 }
 
 void RunCallbackForEachThreadLocked(
     __sanitizer::ThreadRegistry::ThreadCallback cb, void *arg) {
   GetLsanThreadRegistryLocked()->RunCallbackForEachThreadLocked(cb, arg);
 }
 
+void ReportIfNotSuspended(ThreadContextBase *tctx, void *arg) {
+  const InternalMmapVector<tid_t> &suspended_threads =
+      *(const InternalMmapVector<tid_t> *)arg;
+  if (tctx->status == ThreadStatusRunning) {
+    uptr i = InternalLowerBound(suspended_threads, tctx->os_id);
+    if (i >= suspended_threads.size() || suspended_threads[i] != tctx->os_id)
+      Report(
+          "Running thread %llu was not suspended. False leaks are possible.\n",
+          tctx->os_id);
+  }
+}
+
 }  // namespace __lsan