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