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 24 namespace __sanitizer { 25 typedef struct { 26 tid_t tid; 27 thread_t thread; 28 } SuspendedThreadInfo; 29 30 class 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 48 struct RunThreadArgs { 49 StopTheWorldCallback callback; 50 void *argument; 51 }; 52 53 void 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 81 void 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__) 88 typedef x86_thread_state64_t regs_struct; 89 90 #define SP_REG __rsp 91 92 #elif defined(__aarch64__) 93 typedef 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) 102 typedef x86_thread_state32_t regs_struct; 103 104 #define SP_REG __esp 105 106 #else 107 #error "Unsupported architecture" 108 #endif 109 110 tid_t SuspendedThreadsListMac::GetThreadID(uptr index) const { 111 CHECK_LT(index, threads_.size()); 112 return threads_[index].tid; 113 } 114 115 thread_t SuspendedThreadsListMac::GetThread(uptr index) const { 116 CHECK_LT(index, threads_.size()); 117 return threads_[index].thread; 118 } 119 120 uptr SuspendedThreadsListMac::ThreadCount() const { 121 return threads_.size(); 122 } 123 124 bool 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 131 void 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 143 PtraceRegistersStatus 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)®s, 150 ®_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, ®s, 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 171 uptr 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