compiler-rt/lib/sanitizer_common/sanitizer_stoptheworld_win.cpp

   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
  24 namespace __sanitizer {
  25
  26 namespace {
  27
  28 struct 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
  56 PtraceRegistersStatus 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
  69 tid_t SuspendedThreadsListWindows::GetThreadID(uptr index) const {
  70   CHECK_LT(index, threadIds.size());
  71   return threadIds[index];
  72 }
  73
  74 uptr SuspendedThreadsListWindows::ThreadCount() const {
  75   return threadIds.size();
  76 }
  77
  78 struct RunThreadArgs {
  79   StopTheWorldCallback callback;
  80   void *argument;
  81 };
  82
  83 DWORD 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
 161 void 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