sanitizer_stoptheworld_win.cpp revision 1.1.1.1
1//===-- sanitizer_stoptheworld_win.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_WINDOWS 16 17# define WIN32_LEAN_AND_MEAN 18# include <windows.h> 19// windows.h needs to be included before tlhelp32.h 20# include <tlhelp32.h> 21 22# include "sanitizer_stoptheworld.h" 23 24namespace __sanitizer { 25 26namespace { 27 28struct SuspendedThreadsListWindows final : public SuspendedThreadsList { 29 InternalMmapVector<HANDLE> threadHandles; 30 InternalMmapVector<DWORD> threadIds; 31 32 SuspendedThreadsListWindows() { 33 threadIds.reserve(1024); 34 threadHandles.reserve(1024); 35 } 36 37 PtraceRegistersStatus GetRegistersAndSP(uptr index, 38 InternalMmapVector<uptr> *buffer, 39 uptr *sp) const override; 40 41 tid_t GetThreadID(uptr index) const override; 42 uptr ThreadCount() const override; 43}; 44 45// Stack Pointer register names on different architectures 46# if SANITIZER_X64 47# define SP_REG Rsp 48# elif SANITIZER_I386 49# define SP_REG Esp 50# elif SANITIZER_ARM | SANITIZER_ARM64 51# define SP_REG Sp 52# else 53# error Architecture not supported! 54# endif 55 56PtraceRegistersStatus SuspendedThreadsListWindows::GetRegistersAndSP( 57 uptr index, InternalMmapVector<uptr> *buffer, uptr *sp) const { 58 CHECK_LT(index, threadHandles.size()); 59 60 buffer->resize(RoundUpTo(sizeof(CONTEXT), sizeof(uptr)) / sizeof(uptr)); 61 CONTEXT *thread_context = reinterpret_cast<CONTEXT *>(buffer->data()); 62 thread_context->ContextFlags = CONTEXT_ALL; 63 CHECK(GetThreadContext(threadHandles[index], thread_context)); 64 *sp = thread_context->SP_REG; 65 66 return REGISTERS_AVAILABLE; 67} 68 69tid_t SuspendedThreadsListWindows::GetThreadID(uptr index) const { 70 CHECK_LT(index, threadIds.size()); 71 return threadIds[index]; 72} 73 74uptr SuspendedThreadsListWindows::ThreadCount() const { 75 return threadIds.size(); 76} 77 78struct RunThreadArgs { 79 StopTheWorldCallback callback; 80 void *argument; 81}; 82 83DWORD WINAPI RunThread(void *argument) { 84 RunThreadArgs *run_args = (RunThreadArgs *)argument; 85 86 const DWORD this_thread = GetCurrentThreadId(); 87 const DWORD this_process = GetCurrentProcessId(); 88 89 SuspendedThreadsListWindows suspended_threads_list; 90 bool new_thread_found; 91 92 do { 93 // Take a snapshot of all Threads 94 const HANDLE threads = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); 95 CHECK(threads != INVALID_HANDLE_VALUE); 96 97 THREADENTRY32 thread_entry; 98 thread_entry.dwSize = sizeof(thread_entry); 99 new_thread_found = false; 100 101 if (!Thread32First(threads, &thread_entry)) 102 break; 103 104 do { 105 if (thread_entry.th32ThreadID == this_thread || 106 thread_entry.th32OwnerProcessID != this_process) 107 continue; 108 109 bool suspended_thread = false; 110 for (const auto thread_id : suspended_threads_list.threadIds) { 111 if (thread_id == thread_entry.th32ThreadID) { 112 suspended_thread = true; 113 break; 114 } 115 } 116 117 // Skip the Thread if it was already suspended 118 if (suspended_thread) 119 continue; 120 121 const HANDLE thread = 122 OpenThread(THREAD_ALL_ACCESS, FALSE, thread_entry.th32ThreadID); 123 CHECK(thread); 124 125 if (SuspendThread(thread) == (DWORD)-1) { 126 DWORD last_error = GetLastError(); 127 128 VPrintf(1, "Could not suspend thread %lu (error %lu)", 129 thread_entry.th32ThreadID, last_error); 130 continue; 131 } 132 133 suspended_threads_list.threadIds.push_back(thread_entry.th32ThreadID); 134 suspended_threads_list.threadHandles.push_back(thread); 135 new_thread_found = true; 136 } while (Thread32Next(threads, &thread_entry)); 137 138 CloseHandle(threads); 139 140 // Between the call to `CreateToolhelp32Snapshot` and suspending the 141 // relevant Threads, new Threads could have potentially been created. So 142 // continue to find and suspend new Threads until we don't find any. 143 } while (new_thread_found); 144 145 // Now all Threads of this Process except of this Thread should be suspended. 146 // Execute the callback function. 147 run_args->callback(suspended_threads_list, run_args->argument); 148 149 // Resume all Threads 150 for (const auto suspended_thread_handle : 151 suspended_threads_list.threadHandles) { 152 CHECK_NE(ResumeThread(suspended_thread_handle), -1); 153 CloseHandle(suspended_thread_handle); 154 } 155 156 return 0; 157} 158 159} // namespace 160 161void StopTheWorld(StopTheWorldCallback callback, void *argument) { 162 struct RunThreadArgs arg = {callback, argument}; 163 DWORD trace_thread_id; 164 165 auto trace_thread = 166 CreateThread(nullptr, 0, RunThread, &arg, 0, &trace_thread_id); 167 CHECK(trace_thread); 168 169 WaitForSingleObject(trace_thread, INFINITE); 170 CloseHandle(trace_thread); 171} 172 173} // namespace __sanitizer 174 175#endif // SANITIZER_WINDOWS 176