1//===-- sanitizer_stoptheworld_mac.cpp ------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// See sanitizer_stoptheworld.h for details.
10//
11//===----------------------------------------------------------------------===//
12
13#include "sanitizer_platform.h"
14
15#if SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__) || \
16                      defined(__i386))
17
18#include <mach/mach.h>
19#include <mach/thread_info.h>
20#include <pthread.h>
21
22#include "sanitizer_stoptheworld.h"
23
24namespace __sanitizer {
25typedef struct {
26  tid_t tid;
27  thread_t thread;
28} SuspendedThreadInfo;
29
30class SuspendedThreadsListMac : public SuspendedThreadsList {
31 public:
32  SuspendedThreadsListMac() : threads_(1024) {}
33
34  tid_t GetThreadID(uptr index) const;
35  thread_t GetThread(uptr index) const;
36  uptr ThreadCount() const;
37  bool ContainsThread(thread_t thread) const;
38  void Append(thread_t thread);
39
40  PtraceRegistersStatus GetRegistersAndSP(uptr index, uptr *buffer,
41                                          uptr *sp) const;
42  uptr RegisterCount() const;
43
44 private:
45  InternalMmapVector<SuspendedThreadInfo> threads_;
46};
47
48struct RunThreadArgs {
49  StopTheWorldCallback callback;
50  void *argument;
51};
52
53void RunThread(void *arg) {
54  struct RunThreadArgs *run_args = (struct RunThreadArgs *)arg;
55  SuspendedThreadsListMac suspended_threads_list;
56
57  thread_array_t threads;
58  mach_msg_type_number_t num_threads;
59  kern_return_t err = task_threads(mach_task_self(), &threads, &num_threads);
60  if (err != KERN_SUCCESS) {
61    VReport(1, "Failed to get threads for task (errno %d).\n", err);
62    return;
63  }
64
65  thread_t thread_self = mach_thread_self();
66  for (unsigned int i = 0; i < num_threads; ++i) {
67    if (threads[i] == thread_self) continue;
68
69    thread_suspend(threads[i]);
70    suspended_threads_list.Append(threads[i]);
71  }
72
73  run_args->callback(suspended_threads_list, run_args->argument);
74
75  uptr num_suspended = suspended_threads_list.ThreadCount();
76  for (unsigned int i = 0; i < num_suspended; ++i) {
77    thread_resume(suspended_threads_list.GetThread(i));
78  }
79}
80
81void StopTheWorld(StopTheWorldCallback callback, void *argument) {
82  struct RunThreadArgs arg = {callback, argument};
83  pthread_t run_thread = (pthread_t)internal_start_thread(RunThread, &arg);
84  internal_join_thread(run_thread);
85}
86
87#if defined(__x86_64__)
88typedef x86_thread_state64_t regs_struct;
89
90#define SP_REG __rsp
91
92#elif defined(__aarch64__)
93typedef arm_thread_state64_t regs_struct;
94
95# if __DARWIN_UNIX03
96#  define SP_REG __sp
97# else
98#  define SP_REG sp
99# endif
100
101#elif defined(__i386)
102typedef x86_thread_state32_t regs_struct;
103
104#define SP_REG __esp
105
106#else
107#error "Unsupported architecture"
108#endif
109
110tid_t SuspendedThreadsListMac::GetThreadID(uptr index) const {
111  CHECK_LT(index, threads_.size());
112  return threads_[index].tid;
113}
114
115thread_t SuspendedThreadsListMac::GetThread(uptr index) const {
116  CHECK_LT(index, threads_.size());
117  return threads_[index].thread;
118}
119
120uptr SuspendedThreadsListMac::ThreadCount() const {
121  return threads_.size();
122}
123
124bool SuspendedThreadsListMac::ContainsThread(thread_t thread) const {
125  for (uptr i = 0; i < threads_.size(); i++) {
126    if (threads_[i].thread == thread) return true;
127  }
128  return false;
129}
130
131void SuspendedThreadsListMac::Append(thread_t thread) {
132  thread_identifier_info_data_t info;
133  mach_msg_type_number_t info_count = THREAD_IDENTIFIER_INFO_COUNT;
134  kern_return_t err = thread_info(thread, THREAD_IDENTIFIER_INFO,
135                                  (thread_info_t)&info, &info_count);
136  if (err != KERN_SUCCESS) {
137    VReport(1, "Error - unable to get thread ident for a thread\n");
138    return;
139  }
140  threads_.push_back({info.thread_id, thread});
141}
142
143PtraceRegistersStatus SuspendedThreadsListMac::GetRegistersAndSP(
144    uptr index, uptr *buffer, uptr *sp) const {
145  thread_t thread = GetThread(index);
146  regs_struct regs;
147  int err;
148  mach_msg_type_number_t reg_count = MACHINE_THREAD_STATE_COUNT;
149  err = thread_get_state(thread, MACHINE_THREAD_STATE, (thread_state_t)&regs,
150                         &reg_count);
151  if (err != KERN_SUCCESS) {
152    VReport(1, "Error - unable to get registers for a thread\n");
153    // KERN_INVALID_ARGUMENT indicates that either the flavor is invalid,
154    // or the thread does not exist. The other possible error case,
155    // MIG_ARRAY_TOO_LARGE, means that the state is too large, but it's
156    // still safe to proceed.
157    return err == KERN_INVALID_ARGUMENT ? REGISTERS_UNAVAILABLE_FATAL
158                                        : REGISTERS_UNAVAILABLE;
159  }
160
161  internal_memcpy(buffer, &regs, sizeof(regs));
162  *sp = regs.SP_REG;
163
164  // On x86_64 and aarch64, we must account for the stack redzone, which is 128
165  // bytes.
166  if (SANITIZER_WORDSIZE == 64) *sp -= 128;
167
168  return REGISTERS_AVAILABLE;
169}
170
171uptr SuspendedThreadsListMac::RegisterCount() const {
172  return MACHINE_THREAD_STATE_COUNT;
173}
174} // namespace __sanitizer
175
176#endif  // SANITIZER_MAC && (defined(__x86_64__) || defined(__aarch64__)) ||
177        //                   defined(__i386))
178