Implement StopTheWorld for Darwin

[kubamracek]

lib/sanitizer_common/sanitizer_stoptheworld_mac.cc

74–78

Do you expect any performance issues from this O(n^2) behavior? What is the maximum reasonable thread count? Why do we even need to check for ContainsThread? Do you expect that threads contains duplicates?

87–89

Can we iterate over suspended_thread_list instead and skip the check for mach_thread_self?

91–94

clang-format please

[fjricci]

lib/sanitizer_common/sanitizer_stoptheworld_mac.cc

74–78

I expect to be running this on programs with up to 250 threads or so, not sure what a normal maximum use case would be.

I based this on the Linux implementation, which does have the nested loop. That implementation is more complex, so it may be necessary there, but it should be fine to remove it here.

[fjricci]

Address comments

lib/lsan/lsan_common_mac.cc

if (info.user_tag == VM_MEMORY_OS_ALLOC_ONCE) {
                            "GLOBAL", kReachable);
       return;
     }
     address += size;
   }
 }
 
 void DoStopTheWorld(StopTheWorldCallback callback, void *argument) {
-  CHECK(0 && "unimplemented");
+  StopTheWorld(callback, argument);
 }
 
 } // namespace __lsan
 
 #endif // CAN_SANITIZE_LEAKS && SANITIZER_MAC

lib/sanitizer_common/sanitizer_stoptheworld_mac.cc

 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
 #if SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__) || \
                       defined(__i386))
 
 #include <mach/mach.h>
+#include <mach/thread_info.h>
+#include <pthread.h>
 
 #include "sanitizer_stoptheworld.h"
 
 namespace __sanitizer {
 typedef struct {
   tid_t tid;
   thread_t thread;
 } SuspendedThreadInfo;
public:
   PtraceRegistersStatus GetRegistersAndSP(uptr index, uptr *buffer,
                                           uptr *sp) const;
   uptr RegisterCount() const;
 
  private:
   InternalMmapVector<SuspendedThreadInfo> threads_;
 };
 
+struct RunThreadArgs {
+  StopTheWorldCallback callback;
+  void *argument;
+};
+
+void RunThread(void *arg) {
+  struct RunThreadArgs *run_args = (struct RunThreadArgs *)arg;
+  SuspendedThreadsListMac suspended_threads_list;
+
+  mach_port_t task;
+  kern_return_t err = task_for_pid(mach_task_self(), internal_getpid(), &task);
+  if (err != KERN_SUCCESS) {
+    VReport(1, "Getting task from pid failed (errno %d).\n", err);
+    return;
+  }
+
+  thread_array_t threads;
+  mach_msg_type_number_t num_threads;
+
+  err = task_threads(task, &threads, &num_threads);
+  if (err != KERN_SUCCESS) {
+    VReport(1, "Failed to get threads for task (errno %d).\n", err);
+    return;
+  }
+
+  thread_t thread_self = mach_thread_self();
+  for (unsigned int i = 0; i < num_threads; ++i) {
+    if (threads[i] == thread_self) continue;
+
+    thread_suspend(threads[i]);
+    suspended_threads_list.Append(threads[i]);
+  }
+
+  run_args->callback(suspended_threads_list, run_args->argument);
+
+  uptr num_suspended = suspended_threads_list.ThreadCount();
+  for (unsigned int i = 0; i < num_suspended; ++i) {
+    thread_resume(suspended_threads_list.GetThread(i));
+  }
+}
+
 void StopTheWorld(StopTheWorldCallback callback, void *argument) {
-  CHECK(0 && "unimplemented");
+  struct RunThreadArgs arg = {callback, argument};
+  pthread_t run_thread = (pthread_t)internal_start_thread(RunThread, &arg);
+  internal_join_thread(run_thread);
 }
 
 #if defined(__x86_64__)
 typedef x86_thread_state64_t regs_struct;
 
 #define SP_REG __rsp
 
 #elif defined(__aarch64__)
 typedef arm_thread_state64_t regs_struct;