utils/KillTheDoctor/KillTheDoctor.cpp

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