utils/KillTheDoctor/KillTheDoctor.cpp

   1 //===- KillTheDoctor - Prevent Dr. Watson from stopping tests ---*- C++ -*-===//
   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 // This program provides an extremely hacky way to stop Dr. Watson from starting
  10 // due to unhandled exceptions in child processes.
  11 //
  12 // This simply starts the program named in the first positional argument with
  13 // the arguments following it under a debugger. All this debugger does is catch
  14 // any unhandled exceptions thrown in the child process and close the program
  15 // (and hopefully tells someone about it).
  16 //
  17 // This also provides another really hacky method to prevent assert dialog boxes
  18 // from popping up. When --no-user32 is passed, if any process loads user32.dll,
  19 // we assume it is trying to call MessageBoxEx and terminate it. The proper way
  20 // to do this would be to actually set a break point, but there's quite a bit
  21 // of code involved to get the address of MessageBoxEx in the remote process's
  22 // address space due to Address space layout randomization (ASLR). This can be
  23 // added if it's ever actually needed.
  24 //
  25 // If the subprocess exits for any reason other than successful termination, -1
  26 // is returned. If the process exits normally the value it returned is returned.
  27 //
  28 // I hate Windows.
  29 //
  30 //===----------------------------------------------------------------------===//
  31
  32 #include "llvm/ADT/STLExtras.h"
  33 #include "llvm/ADT/SmallString.h"
  34 #include "llvm/ADT/SmallVector.h"
  35 #include "llvm/ADT/StringExtras.h"
  36 #include "llvm/ADT/StringRef.h"
  37 #include "llvm/ADT/Twine.h"
  38 #include "llvm/Support/CommandLine.h"
  39 #include "llvm/Support/ManagedStatic.h"
  40 #include "llvm/Support/Path.h"
  41 #include "llvm/Support/PrettyStackTrace.h"
  42 #include "llvm/Support/Signals.h"
  43 #include "llvm/Support/WindowsError.h"
  44 #include "llvm/Support/raw_ostream.h"
  45 #include "llvm/Support/type_traits.h"
  46 #include <algorithm>
  47 #include <cerrno>
  48 #include <cstdlib>
  49 #include <map>
  50 #include <string>
  51 #include <system_error>
  52
  53 // These includes must be last.
  54 #include <windows.h>
  55 #include <winerror.h>
  56 #include <dbghelp.h>
  57 #include <psapi.h>
  58
  59 using namespace llvm;
  60
  61 #undef max
  62
  63 namespace {
  64   cl::opt<std::string> ProgramToRun(cl::Positional,
  65     cl::desc("<program to run>"));
  66   cl::list<std::string>  Argv(cl::ConsumeAfter,
  67     cl::desc("<program arguments>..."));
  68   cl::opt<bool> TraceExecution("x",
  69     cl::desc("Print detailed output about what is being run to stderr."));
  70   cl::opt<unsigned> Timeout("t", cl::init(0),
  71     cl::desc("Set maximum runtime in seconds. Defaults to infinite."));
  72   cl::opt<bool> NoUser32("no-user32",
  73     cl::desc("Terminate process if it loads user32.dll."));
  74
  75   StringRef ToolName;
  76
  77   template <typename HandleType>
  78   class ScopedHandle {
  79     typedef typename HandleType::handle_type handle_type;
  80
  81     handle_type Handle;
  82
  83   public:
  84     ScopedHandle()
  85       : Handle(HandleType::GetInvalidHandle()) {}
  86
  87     explicit ScopedHandle(handle_type handle)
  88       : Handle(handle) {}
  89
  90     ~ScopedHandle() {
  91       HandleType::Destruct(Handle);
  92     }
  93
  94     ScopedHandle& operator=(handle_type handle) {
  95       // Cleanup current handle.
  96       if (!HandleType::isValid(Handle))
  97         HandleType::Destruct(Handle);
  98       Handle = handle;
  99       return *this;
 100     }
 101
 102     operator bool() const {
 103       return HandleType::isValid(Handle);
 104     }
 105
 106     operator handle_type() {
 107       return Handle;
 108     }
 109   };
 110
 111   // This implements the most common handle in the Windows API.
 112   struct CommonHandle {
 113     typedef HANDLE handle_type;
 114
 115     static handle_type GetInvalidHandle() {
 116       return INVALID_HANDLE_VALUE;
 117     }
 118
 119     static void Destruct(handle_type Handle) {
 120       ::CloseHandle(Handle);
 121     }
 122
 123     static bool isValid(handle_type Handle) {
 124       return Handle != GetInvalidHandle();
 125     }
 126   };
 127
 128   struct FileMappingHandle {
 129     typedef HANDLE handle_type;
 130
 131     static handle_type GetInvalidHandle() {
 132       return NULL;
 133     }
 134
 135     static void Destruct(handle_type Handle) {
 136       ::CloseHandle(Handle);
 137     }
 138
 139     static bool isValid(handle_type Handle) {
 140       return Handle != GetInvalidHandle();
 141     }
 142   };
 143
 144   struct MappedViewOfFileHandle {
 145     typedef LPVOID handle_type;
 146
 147     static handle_type GetInvalidHandle() {
 148       return NULL;
 149     }
 150
 151     static void Destruct(handle_type Handle) {
 152       ::UnmapViewOfFile(Handle);
 153     }
 154
 155     static bool isValid(handle_type Handle) {
 156       return Handle != GetInvalidHandle();
 157     }
 158   };
 159
 160   struct ProcessHandle : CommonHandle {};
 161   struct ThreadHandle  : CommonHandle {};
 162   struct TokenHandle   : CommonHandle {};
 163   struct FileHandle    : CommonHandle {};
 164
 165   typedef ScopedHandle<FileMappingHandle>       FileMappingScopedHandle;
 166   typedef ScopedHandle<MappedViewOfFileHandle>  MappedViewOfFileScopedHandle;
 167   typedef ScopedHandle<ProcessHandle>           ProcessScopedHandle;
 168   typedef ScopedHandle<ThreadHandle>            ThreadScopedHandle;
 169   typedef ScopedHandle<TokenHandle>             TokenScopedHandle;
 170   typedef ScopedHandle<FileHandle>              FileScopedHandle;
 171 }
 172
 173 static std::error_code windows_error(DWORD E) { return mapWindowsError(E); }
 174
 175 static std::error_code GetFileNameFromHandle(HANDLE FileHandle,
 176                                              std::string &Name) {
 177   char Filename[MAX_PATH+1];
 178   bool Success = false;
 179   Name.clear();
 180
 181   // Get the file size.
 182   LARGE_INTEGER FileSize;
 183   Success = ::GetFileSizeEx(FileHandle, &FileSize);
 184
 185   if (!Success)
 186     return windows_error(::GetLastError());
 187
 188   // Create a file mapping object.
 189   FileMappingScopedHandle FileMapping(
 190     ::CreateFileMappingA(FileHandle,
 191                          NULL,
 192                          PAGE_READONLY,
 193                          0,
 194                          1,
 195                          NULL));
 196
 197   if (!FileMapping)
 198     return windows_error(::GetLastError());
 199
 200   // Create a file mapping to get the file name.
 201   MappedViewOfFileScopedHandle MappedFile(
 202     ::MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 1));
 203
 204   if (!MappedFile)
 205     return windows_error(::GetLastError());
 206
 207   Success = ::GetMappedFileNameA(::GetCurrentProcess(),
 208                                 MappedFile,
 209                                 Filename,
 210                                 array_lengthof(Filename) - 1);
 211
 212   if (!Success)
 213     return windows_error(::GetLastError());
 214   else {
 215     Name = Filename;
 216     return std::error_code();
 217   }
 218 }
 219
 220 /// Find program using shell lookup rules.
 221 /// @param Program This is either an absolute path, relative path, or simple a
 222 ///        program name. Look in PATH for any programs that match. If no
 223 ///        extension is present, try all extensions in PATHEXT.
 224 /// @return If ec == errc::success, The absolute path to the program. Otherwise
 225 ///         the return value is undefined.
 226 static std::string FindProgram(const std::string &Program,
 227                                std::error_code &ec) {
 228   char PathName[MAX_PATH + 1];
 229   typedef SmallVector<StringRef, 12> pathext_t;
 230   pathext_t pathext;
 231   // Check for the program without an extension (in case it already has one).
 232   pathext.push_back("");
 233   SplitString(std::getenv("PATHEXT"), pathext, ";");
 234
 235   for (pathext_t::iterator i = pathext.begin(), e = pathext.end(); i != e; ++i){
 236     SmallString<5> ext;
 237     for (std::size_t ii = 0, e = i->size(); ii != e; ++ii)
 238       ext.push_back(::tolower((*i)[ii]));
 239     LPCSTR Extension = NULL;
 240     if (ext.size() && ext[0] == '.')
 241       Extension = ext.c_str();
 242     DWORD length = ::SearchPathA(NULL,
 243                                  Program.c_str(),
 244                                  Extension,
 245                                  array_lengthof(PathName),
 246                                  PathName,
 247                                  NULL);
 248     if (length == 0)
 249       ec = windows_error(::GetLastError());
 250     else if (length > array_lengthof(PathName)) {
 251       // This may have been the file, return with error.
 252       ec = windows_error(ERROR_BUFFER_OVERFLOW);
 253       break;
 254     } else {
 255       // We found the path! Return it.
 256       ec = std::error_code();
 257       break;
 258     }
 259   }
 260
 261   // Make sure PathName is valid.
 262   PathName[MAX_PATH] = 0;
 263   return PathName;
 264 }
 265
 266 static StringRef ExceptionCodeToString(DWORD ExceptionCode) {
 267   switch(ExceptionCode) {
 268   case EXCEPTION_ACCESS_VIOLATION: return "EXCEPTION_ACCESS_VIOLATION";
 269   case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 270     return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
 271   case EXCEPTION_BREAKPOINT: return "EXCEPTION_BREAKPOINT";
 272   case EXCEPTION_DATATYPE_MISALIGNMENT:
 273     return "EXCEPTION_DATATYPE_MISALIGNMENT";
 274   case EXCEPTION_FLT_DENORMAL_OPERAND: return "EXCEPTION_FLT_DENORMAL_OPERAND";
 275   case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
 276   case EXCEPTION_FLT_INEXACT_RESULT: return "EXCEPTION_FLT_INEXACT_RESULT";
 277   case EXCEPTION_FLT_INVALID_OPERATION:
 278     return "EXCEPTION_FLT_INVALID_OPERATION";
 279   case EXCEPTION_FLT_OVERFLOW: return "EXCEPTION_FLT_OVERFLOW";
 280   case EXCEPTION_FLT_STACK_CHECK: return "EXCEPTION_FLT_STACK_CHECK";
 281   case EXCEPTION_FLT_UNDERFLOW: return "EXCEPTION_FLT_UNDERFLOW";
 282   case EXCEPTION_ILLEGAL_INSTRUCTION: return "EXCEPTION_ILLEGAL_INSTRUCTION";
 283   case EXCEPTION_IN_PAGE_ERROR: return "EXCEPTION_IN_PAGE_ERROR";
 284   case EXCEPTION_INT_DIVIDE_BY_ZERO: return "EXCEPTION_INT_DIVIDE_BY_ZERO";
 285   case EXCEPTION_INT_OVERFLOW: return "EXCEPTION_INT_OVERFLOW";
 286   case EXCEPTION_INVALID_DISPOSITION: return "EXCEPTION_INVALID_DISPOSITION";
 287   case EXCEPTION_NONCONTINUABLE_EXCEPTION:
 288     return "EXCEPTION_NONCONTINUABLE_EXCEPTION";
 289   case EXCEPTION_PRIV_INSTRUCTION: return "EXCEPTION_PRIV_INSTRUCTION";
 290   case EXCEPTION_SINGLE_STEP: return "EXCEPTION_SINGLE_STEP";
 291   case EXCEPTION_STACK_OVERFLOW: return "EXCEPTION_STACK_OVERFLOW";
 292   default: return "<unknown>";
 293   }
 294 }
 295
 296 int main(int argc, char **argv) {
 297   // Print a stack trace if we signal out.
 298   sys::PrintStackTraceOnErrorSignal(argv[0]);
 299   PrettyStackTraceProgram X(argc, argv);
 300   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 301
 302   ToolName = argv[0];
 303
 304   cl::ParseCommandLineOptions(argc, argv, "Dr. Watson Assassin.\n");
 305   if (ProgramToRun.size() == 0) {
 306     cl::PrintHelpMessage();
 307     return -1;
 308   }
 309
 310   if (Timeout > std::numeric_limits<uint32_t>::max() / 1000) {
 311     errs() << ToolName << ": Timeout value too large, must be less than: "
 312                        << std::numeric_limits<uint32_t>::max() / 1000
 313                        << '\n';
 314     return -1;
 315   }
 316
 317   std::string CommandLine(ProgramToRun);
 318
 319   std::error_code ec;
 320   ProgramToRun = FindProgram(ProgramToRun, ec);
 321   if (ec) {
 322     errs() << ToolName << ": Failed to find program: '" << CommandLine
 323            << "': " << ec.message() << '\n';
 324     return -1;
 325   }
 326
 327   if (TraceExecution)
 328     errs() << ToolName << ": Found Program: " << ProgramToRun << '\n';
 329
 330   for (const std::string &Arg : Argv) {
 331     CommandLine.push_back(' ');
 332     CommandLine.append(Arg);
 333   }
 334
 335   if (TraceExecution)
 336     errs() << ToolName << ": Program Image Path: " << ProgramToRun << '\n'
 337            << ToolName << ": Command Line: " << CommandLine << '\n';
 338
 339   STARTUPINFOA StartupInfo;
 340   PROCESS_INFORMATION ProcessInfo;
 341   std::memset(&StartupInfo, 0, sizeof(StartupInfo));
 342   StartupInfo.cb = sizeof(StartupInfo);
 343   std::memset(&ProcessInfo, 0, sizeof(ProcessInfo));
 344
 345   // Set error mode to not display any message boxes. The child process inherits
 346   // this.
 347   ::SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
 348   ::_set_error_mode(_OUT_TO_STDERR);
 349
 350   BOOL success = ::CreateProcessA(ProgramToRun.c_str(),
 351                                   const_cast<LPSTR>(CommandLine.c_str()),
 352                                   NULL,
 353                                   NULL,
 354                                   FALSE,
 355                                   DEBUG_PROCESS,
 356                                   NULL,
 357                                   NULL,
 358                                   &StartupInfo,
 359                                   &ProcessInfo);
 360   if (!success) {
 361     errs() << ToolName << ": Failed to run program: '" << ProgramToRun << "': "
 362            << std::error_code(windows_error(::GetLastError())).message()
 363            << '\n';
 364     return -1;
 365   }
 366
 367   // Make sure ::CloseHandle is called on exit.
 368   std::map<DWORD, HANDLE> ProcessIDToHandle;
 369
 370   DEBUG_EVENT DebugEvent;
 371   std::memset(&DebugEvent, 0, sizeof(DebugEvent));
 372   DWORD dwContinueStatus = DBG_CONTINUE;
 373
 374   // Run the program under the debugger until either it exits, or throws an
 375   // exception.
 376   if (TraceExecution)
 377     errs() << ToolName << ": Debugging...\n";
 378
 379   while(true) {
 380     DWORD TimeLeft = INFINITE;
 381     if (Timeout > 0) {
 382       FILETIME CreationTime, ExitTime, KernelTime, UserTime;
 383       ULARGE_INTEGER a, b;
 384       success = ::GetProcessTimes(ProcessInfo.hProcess,
 385                                   &CreationTime,
 386                                   &ExitTime,
 387                                   &KernelTime,
 388                                   &UserTime);
 389       if (!success) {
 390         ec = windows_error(::GetLastError());
 391
 392         errs() << ToolName << ": Failed to get process times: "
 393                << ec.message() << '\n';
 394         return -1;
 395       }
 396       a.LowPart = KernelTime.dwLowDateTime;
 397       a.HighPart = KernelTime.dwHighDateTime;
 398       b.LowPart = UserTime.dwLowDateTime;
 399       b.HighPart = UserTime.dwHighDateTime;
 400       // Convert 100-nanosecond units to milliseconds.
 401       uint64_t TotalTimeMiliseconds = (a.QuadPart + b.QuadPart) / 10000;
 402       // Handle the case where the process has been running for more than 49
 403       // days.
 404       if (TotalTimeMiliseconds > std::numeric_limits<uint32_t>::max()) {
 405         errs() << ToolName << ": Timeout Failed: Process has been running for"
 406                               "more than 49 days.\n";
 407         return -1;
 408       }
 409
 410       // We check with > instead of using Timeleft because if
 411       // TotalTimeMiliseconds is greater than Timeout * 1000, TimeLeft would
 412       // underflow.
 413       if (TotalTimeMiliseconds > (Timeout * 1000)) {
 414         errs() << ToolName << ": Process timed out.\n";
 415         ::TerminateProcess(ProcessInfo.hProcess, -1);
 416         // Otherwise other stuff starts failing...
 417         return -1;
 418       }
 419
 420       TimeLeft = (Timeout * 1000) - static_cast<uint32_t>(TotalTimeMiliseconds);
 421     }
 422     success = WaitForDebugEvent(&DebugEvent, TimeLeft);
 423
 424     if (!success) {
 425       DWORD LastError = ::GetLastError();
 426       ec = windows_error(LastError);
 427
 428       if (LastError == ERROR_SEM_TIMEOUT || LastError == WSAETIMEDOUT) {
 429         errs() << ToolName << ": Process timed out.\n";
 430         ::TerminateProcess(ProcessInfo.hProcess, -1);
 431         // Otherwise other stuff starts failing...
 432         return -1;
 433       }
 434
 435       errs() << ToolName << ": Failed to wait for debug event in program: '"
 436              << ProgramToRun << "': " << ec.message() << '\n';
 437       return -1;
 438     }
 439
 440     switch(DebugEvent.dwDebugEventCode) {
 441     case CREATE_PROCESS_DEBUG_EVENT:
 442       // Make sure we remove the handle on exit.
 443       if (TraceExecution)
 444         errs() << ToolName << ": Debug Event: CREATE_PROCESS_DEBUG_EVENT\n";
 445       ProcessIDToHandle[DebugEvent.dwProcessId] =
 446         DebugEvent.u.CreateProcessInfo.hProcess;
 447       ::CloseHandle(DebugEvent.u.CreateProcessInfo.hFile);
 448       break;
 449     case EXIT_PROCESS_DEBUG_EVENT: {
 450         if (TraceExecution)
 451           errs() << ToolName << ": Debug Event: EXIT_PROCESS_DEBUG_EVENT\n";
 452
 453         // If this is the process we originally created, exit with its exit
 454         // code.
 455         if (DebugEvent.dwProcessId == ProcessInfo.dwProcessId)
 456           return DebugEvent.u.ExitProcess.dwExitCode;
 457
 458         // Otherwise cleanup any resources we have for it.
 459         std::map<DWORD, HANDLE>::iterator ExitingProcess =
 460           ProcessIDToHandle.find(DebugEvent.dwProcessId);
 461         if (ExitingProcess == ProcessIDToHandle.end()) {
 462           errs() << ToolName << ": Got unknown process id!\n";
 463           return -1;
 464         }
 465         ::CloseHandle(ExitingProcess->second);
 466         ProcessIDToHandle.erase(ExitingProcess);
 467       }
 468       break;
 469     case CREATE_THREAD_DEBUG_EVENT:
 470       ::CloseHandle(DebugEvent.u.CreateThread.hThread);
 471       break;
 472     case LOAD_DLL_DEBUG_EVENT: {
 473         // Cleanup the file handle.
 474         FileScopedHandle DLLFile(DebugEvent.u.LoadDll.hFile);
 475         std::string DLLName;
 476         ec = GetFileNameFromHandle(DLLFile, DLLName);
 477         if (ec) {
 478           DLLName = "<failed to get file name from file handle> : ";
 479           DLLName += ec.message();
 480         }
 481         if (TraceExecution) {
 482           errs() << ToolName << ": Debug Event: LOAD_DLL_DEBUG_EVENT\n";
 483           errs().indent(ToolName.size()) << ": DLL Name : " << DLLName << '\n';
 484         }
 485
 486         if (NoUser32 && sys::path::stem(DLLName) == "user32") {
 487           // Program is loading user32.dll, in the applications we are testing,
 488           // this only happens if an assert has fired. By now the message has
 489           // already been printed, so simply close the program.
 490           errs() << ToolName << ": user32.dll loaded!\n";
 491           errs().indent(ToolName.size())
 492                  << ": This probably means that assert was called. Closing "
 493                     "program to prevent message box from popping up.\n";
 494           dwContinueStatus = DBG_CONTINUE;
 495           ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1);
 496           return -1;
 497         }
 498       }
 499       break;
 500     case EXCEPTION_DEBUG_EVENT: {
 501         // Close the application if this exception will not be handled by the
 502         // child application.
 503         if (TraceExecution)
 504           errs() << ToolName << ": Debug Event: EXCEPTION_DEBUG_EVENT\n";
 505
 506         EXCEPTION_DEBUG_INFO  &Exception = DebugEvent.u.Exception;
 507         if (Exception.dwFirstChance > 0) {
 508           if (TraceExecution) {
 509             errs().indent(ToolName.size()) << ": Debug Info : ";
 510             errs() << "First chance exception at "
 511                    << Exception.ExceptionRecord.ExceptionAddress
 512                    << ", exception code: "
 513                    << ExceptionCodeToString(
 514                         Exception.ExceptionRecord.ExceptionCode)
 515                    << " (" << Exception.ExceptionRecord.ExceptionCode << ")\n";
 516           }
 517           dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
 518         } else {
 519           errs() << ToolName << ": Unhandled exception in: " << ProgramToRun
 520                  << "!\n";
 521                  errs().indent(ToolName.size()) << ": location: ";
 522                  errs() << Exception.ExceptionRecord.ExceptionAddress
 523                         << ", exception code: "
 524                         << ExceptionCodeToString(
 525                             Exception.ExceptionRecord.ExceptionCode)
 526                         << " (" << Exception.ExceptionRecord.ExceptionCode
 527                         << ")\n";
 528           dwContinueStatus = DBG_CONTINUE;
 529           ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1);
 530           return -1;
 531         }
 532       }
 533       break;
 534     default:
 535       // Do nothing.
 536       if (TraceExecution)
 537         errs() << ToolName << ": Debug Event: <unknown>\n";
 538       break;
 539     }
 540
 541     success = ContinueDebugEvent(DebugEvent.dwProcessId,
 542                                  DebugEvent.dwThreadId,
 543                                  dwContinueStatus);
 544     if (!success) {
 545       ec = windows_error(::GetLastError());
 546       errs() << ToolName << ": Failed to continue debugging program: '"
 547              << ProgramToRun << "': " << ec.message() << '\n';
 548       return -1;
 549     }
 550
 551     dwContinueStatus = DBG_CONTINUE;
 552   }
 553
 554   assert(0 && "Fell out of debug loop. This shouldn't be possible!");
 555   return -1;
 556 }