Home | History | Annotate | Download | only in KillTheDoctor 
      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 }
    560