| //===- KillTheDoctor - Prevent Dr. Watson from stopping tests ---*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This program provides an extremely hacky way to stop Dr. Watson from starting |
| // due to unhandled exceptions in child processes. |
| // |
| // This simply starts the program named in the first positional argument with |
| // the arguments following it under a debugger. All this debugger does is catch |
| // any unhandled exceptions thrown in the child process and close the program |
| // (and hopefully tells someone about it). |
| // |
| // This also provides another really hacky method to prevent assert dialog boxes |
| // from popping up. When --no-user32 is passed, if any process loads user32.dll, |
| // we assume it is trying to call MessageBoxEx and terminate it. The proper way |
| // to do this would be to actually set a break point, but there's quite a bit |
| // of code involved to get the address of MessageBoxEx in the remote process's |
| // address space due to Address space layout randomization (ASLR). This can be |
| // added if it's ever actually needed. |
| // |
| // If the subprocess exits for any reason other than successful termination, -1 |
| // is returned. If the process exits normally the value it returned is returned. |
| // |
| // I hate Windows. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/ADT/SmallVector.h" |
| #include "llvm/ADT/StringExtras.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/Twine.h" |
| #include "llvm/Support/CommandLine.h" |
| #include "llvm/Support/ManagedStatic.h" |
| #include "llvm/Support/PrettyStackTrace.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "llvm/Support/type_traits.h" |
| #include "llvm/Support/Signals.h" |
| #include "llvm/Support/system_error.h" |
| #include <algorithm> |
| #include <cerrno> |
| #include <cstdlib> |
| #include <map> |
| #include <string> |
| #include <Windows.h> |
| #include <WinError.h> |
| #include <Dbghelp.h> |
| #include <psapi.h> |
| using namespace llvm; |
| |
| #undef max |
| |
| namespace { |
| cl::opt<std::string> ProgramToRun(cl::Positional, |
| cl::desc("<program to run>")); |
| cl::list<std::string> Argv(cl::ConsumeAfter, |
| cl::desc("<program arguments>...")); |
| cl::opt<bool> TraceExecution("x", |
| cl::desc("Print detailed output about what is being run to stderr.")); |
| cl::opt<unsigned> Timeout("t", cl::init(0), |
| cl::desc("Set maximum runtime in seconds. Defaults to infinite.")); |
| cl::opt<bool> NoUser32("no-user32", |
| cl::desc("Terminate process if it loads user32.dll.")); |
| |
| StringRef ToolName; |
| |
| template <typename HandleType> |
| class ScopedHandle { |
| typedef typename HandleType::handle_type handle_type; |
| |
| handle_type Handle; |
| |
| public: |
| ScopedHandle() |
| : Handle(HandleType::GetInvalidHandle()) {} |
| |
| explicit ScopedHandle(handle_type handle) |
| : Handle(handle) {} |
| |
| ~ScopedHandle() { |
| HandleType::Destruct(Handle); |
| } |
| |
| ScopedHandle& operator=(handle_type handle) { |
| // Cleanup current handle. |
| if (!HandleType::isValid(Handle)) |
| HandleType::Destruct(Handle); |
| Handle = handle; |
| return *this; |
| } |
| |
| operator bool() const { |
| return HandleType::isValid(Handle); |
| } |
| |
| operator handle_type() { |
| return Handle; |
| } |
| }; |
| |
| // This implements the most common handle in the Windows API. |
| struct CommonHandle { |
| typedef HANDLE handle_type; |
| |
| static handle_type GetInvalidHandle() { |
| return INVALID_HANDLE_VALUE; |
| } |
| |
| static void Destruct(handle_type Handle) { |
| ::CloseHandle(Handle); |
| } |
| |
| static bool isValid(handle_type Handle) { |
| return Handle != GetInvalidHandle(); |
| } |
| }; |
| |
| struct FileMappingHandle { |
| typedef HANDLE handle_type; |
| |
| static handle_type GetInvalidHandle() { |
| return NULL; |
| } |
| |
| static void Destruct(handle_type Handle) { |
| ::CloseHandle(Handle); |
| } |
| |
| static bool isValid(handle_type Handle) { |
| return Handle != GetInvalidHandle(); |
| } |
| }; |
| |
| struct MappedViewOfFileHandle { |
| typedef LPVOID handle_type; |
| |
| static handle_type GetInvalidHandle() { |
| return NULL; |
| } |
| |
| static void Destruct(handle_type Handle) { |
| ::UnmapViewOfFile(Handle); |
| } |
| |
| static bool isValid(handle_type Handle) { |
| return Handle != GetInvalidHandle(); |
| } |
| }; |
| |
| struct ProcessHandle : CommonHandle {}; |
| struct ThreadHandle : CommonHandle {}; |
| struct TokenHandle : CommonHandle {}; |
| struct FileHandle : CommonHandle {}; |
| |
| typedef ScopedHandle<FileMappingHandle> FileMappingScopedHandle; |
| typedef ScopedHandle<MappedViewOfFileHandle> MappedViewOfFileScopedHandle; |
| typedef ScopedHandle<ProcessHandle> ProcessScopedHandle; |
| typedef ScopedHandle<ThreadHandle> ThreadScopedHandle; |
| typedef ScopedHandle<TokenHandle> TokenScopedHandle; |
| typedef ScopedHandle<FileHandle> FileScopedHandle; |
| } |
| |
| static error_code GetFileNameFromHandle(HANDLE FileHandle, |
| std::string& Name) { |
| char Filename[MAX_PATH+1]; |
| bool Success = false; |
| Name.clear(); |
| |
| // Get the file size. |
| LARGE_INTEGER FileSize; |
| Success = ::GetFileSizeEx(FileHandle, &FileSize); |
| |
| if (!Success) |
| return windows_error(::GetLastError()); |
| |
| // Create a file mapping object. |
| FileMappingScopedHandle FileMapping( |
| ::CreateFileMappingA(FileHandle, |
| NULL, |
| PAGE_READONLY, |
| 0, |
| 1, |
| NULL)); |
| |
| if (!FileMapping) |
| return windows_error(::GetLastError()); |
| |
| // Create a file mapping to get the file name. |
| MappedViewOfFileScopedHandle MappedFile( |
| ::MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 1)); |
| |
| if (!MappedFile) |
| return windows_error(::GetLastError()); |
| |
| Success = ::GetMappedFileNameA(::GetCurrentProcess(), |
| MappedFile, |
| Filename, |
| array_lengthof(Filename) - 1); |
| |
| if (!Success) |
| return windows_error(::GetLastError()); |
| else { |
| Name = Filename; |
| return windows_error::success; |
| } |
| } |
| |
| static std::string QuoteProgramPathIfNeeded(StringRef Command) { |
| if (Command.find_first_of(' ') == StringRef::npos) |
| return Command; |
| else { |
| std::string ret; |
| ret.reserve(Command.size() + 3); |
| ret.push_back('"'); |
| ret.append(Command.begin(), Command.end()); |
| ret.push_back('"'); |
| return ret; |
| } |
| } |
| |
| /// @brief Find program using shell lookup rules. |
| /// @param Program This is either an absolute path, relative path, or simple a |
| /// program name. Look in PATH for any programs that match. If no |
| /// extension is present, try all extensions in PATHEXT. |
| /// @return If ec == errc::success, The absolute path to the program. Otherwise |
| /// the return value is undefined. |
| static std::string FindProgram(const std::string &Program, error_code &ec) { |
| char PathName[MAX_PATH + 1]; |
| typedef SmallVector<StringRef, 12> pathext_t; |
| pathext_t pathext; |
| // Check for the program without an extension (in case it already has one). |
| pathext.push_back(""); |
| SplitString(std::getenv("PATHEXT"), pathext, ";"); |
| |
| for (pathext_t::iterator i = pathext.begin(), e = pathext.end(); i != e; ++i){ |
| SmallString<5> ext; |
| for (std::size_t ii = 0, e = i->size(); ii != e; ++ii) |
| ext.push_back(::tolower((*i)[ii])); |
| LPCSTR Extension = NULL; |
| if (ext.size() && ext[0] == '.') |
| Extension = ext.c_str(); |
| DWORD length = ::SearchPathA(NULL, |
| Program.c_str(), |
| Extension, |
| array_lengthof(PathName), |
| PathName, |
| NULL); |
| if (length == 0) |
| ec = windows_error(::GetLastError()); |
| else if (length > array_lengthof(PathName)) { |
| // This may have been the file, return with error. |
| ec = windows_error::buffer_overflow; |
| break; |
| } else { |
| // We found the path! Return it. |
| ec = windows_error::success; |
| break; |
| } |
| } |
| |
| // Make sure PathName is valid. |
| PathName[MAX_PATH] = 0; |
| return PathName; |
| } |
| |
| static error_code EnableDebugPrivileges() { |
| HANDLE TokenHandle; |
| BOOL success = ::OpenProcessToken(::GetCurrentProcess(), |
| TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, |
| &TokenHandle); |
| if (!success) |
| return windows_error(::GetLastError()); |
| |
| TokenScopedHandle Token(TokenHandle); |
| TOKEN_PRIVILEGES TokenPrivileges; |
| LUID LocallyUniqueID; |
| |
| success = ::LookupPrivilegeValueA(NULL, |
| SE_DEBUG_NAME, |
| &LocallyUniqueID); |
| if (!success) |
| return windows_error(::GetLastError()); |
| |
| TokenPrivileges.PrivilegeCount = 1; |
| TokenPrivileges.Privileges[0].Luid = LocallyUniqueID; |
| TokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; |
| |
| success = ::AdjustTokenPrivileges(Token, |
| FALSE, |
| &TokenPrivileges, |
| sizeof(TOKEN_PRIVILEGES), |
| NULL, |
| NULL); |
| // The value of success is basically useless. Either way we are just returning |
| // the value of ::GetLastError(). |
| return windows_error(::GetLastError()); |
| } |
| |
| static StringRef ExceptionCodeToString(DWORD ExceptionCode) { |
| switch(ExceptionCode) { |
| case EXCEPTION_ACCESS_VIOLATION: return "EXCEPTION_ACCESS_VIOLATION"; |
| case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: |
| return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED"; |
| case EXCEPTION_BREAKPOINT: return "EXCEPTION_BREAKPOINT"; |
| case EXCEPTION_DATATYPE_MISALIGNMENT: |
| return "EXCEPTION_DATATYPE_MISALIGNMENT"; |
| case EXCEPTION_FLT_DENORMAL_OPERAND: return "EXCEPTION_FLT_DENORMAL_OPERAND"; |
| case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "EXCEPTION_FLT_DIVIDE_BY_ZERO"; |
| case EXCEPTION_FLT_INEXACT_RESULT: return "EXCEPTION_FLT_INEXACT_RESULT"; |
| case EXCEPTION_FLT_INVALID_OPERATION: |
| return "EXCEPTION_FLT_INVALID_OPERATION"; |
| case EXCEPTION_FLT_OVERFLOW: return "EXCEPTION_FLT_OVERFLOW"; |
| case EXCEPTION_FLT_STACK_CHECK: return "EXCEPTION_FLT_STACK_CHECK"; |
| case EXCEPTION_FLT_UNDERFLOW: return "EXCEPTION_FLT_UNDERFLOW"; |
| case EXCEPTION_ILLEGAL_INSTRUCTION: return "EXCEPTION_ILLEGAL_INSTRUCTION"; |
| case EXCEPTION_IN_PAGE_ERROR: return "EXCEPTION_IN_PAGE_ERROR"; |
| case EXCEPTION_INT_DIVIDE_BY_ZERO: return "EXCEPTION_INT_DIVIDE_BY_ZERO"; |
| case EXCEPTION_INT_OVERFLOW: return "EXCEPTION_INT_OVERFLOW"; |
| case EXCEPTION_INVALID_DISPOSITION: return "EXCEPTION_INVALID_DISPOSITION"; |
| case EXCEPTION_NONCONTINUABLE_EXCEPTION: |
| return "EXCEPTION_NONCONTINUABLE_EXCEPTION"; |
| case EXCEPTION_PRIV_INSTRUCTION: return "EXCEPTION_PRIV_INSTRUCTION"; |
| case EXCEPTION_SINGLE_STEP: return "EXCEPTION_SINGLE_STEP"; |
| case EXCEPTION_STACK_OVERFLOW: return "EXCEPTION_STACK_OVERFLOW"; |
| default: return "<unknown>"; |
| } |
| } |
| |
| int main(int argc, char **argv) { |
| // Print a stack trace if we signal out. |
| sys::PrintStackTraceOnErrorSignal(); |
| PrettyStackTraceProgram X(argc, argv); |
| llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
| |
| ToolName = argv[0]; |
| |
| cl::ParseCommandLineOptions(argc, argv, "Dr. Watson Assassin.\n"); |
| if (ProgramToRun.size() == 0) { |
| cl::PrintHelpMessage(); |
| return -1; |
| } |
| |
| if (Timeout > std::numeric_limits<uint32_t>::max() / 1000) { |
| errs() << ToolName << ": Timeout value too large, must be less than: " |
| << std::numeric_limits<uint32_t>::max() / 1000 |
| << '\n'; |
| return -1; |
| } |
| |
| std::string CommandLine(ProgramToRun); |
| |
| error_code ec; |
| ProgramToRun = FindProgram(ProgramToRun, ec); |
| if (ec) { |
| errs() << ToolName << ": Failed to find program: '" << CommandLine |
| << "': " << ec.message() << '\n'; |
| return -1; |
| } |
| |
| if (TraceExecution) |
| errs() << ToolName << ": Found Program: " << ProgramToRun << '\n'; |
| |
| for (std::vector<std::string>::iterator i = Argv.begin(), |
| e = Argv.end(); |
| i != e; ++i) { |
| CommandLine.push_back(' '); |
| CommandLine.append(*i); |
| } |
| |
| if (TraceExecution) |
| errs() << ToolName << ": Program Image Path: " << ProgramToRun << '\n' |
| << ToolName << ": Command Line: " << CommandLine << '\n'; |
| |
| STARTUPINFO StartupInfo; |
| PROCESS_INFORMATION ProcessInfo; |
| std::memset(&StartupInfo, 0, sizeof(StartupInfo)); |
| StartupInfo.cb = sizeof(StartupInfo); |
| std::memset(&ProcessInfo, 0, sizeof(ProcessInfo)); |
| |
| // Set error mode to not display any message boxes. The child process inherits |
| // this. |
| ::SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX); |
| ::_set_error_mode(_OUT_TO_STDERR); |
| |
| BOOL success = ::CreateProcessA(ProgramToRun.c_str(), |
| LPSTR(CommandLine.c_str()), |
| NULL, |
| NULL, |
| FALSE, |
| DEBUG_PROCESS, |
| NULL, |
| NULL, |
| &StartupInfo, |
| &ProcessInfo); |
| if (!success) { |
| errs() << ToolName << ": Failed to run program: '" << ProgramToRun |
| << "': " << error_code(windows_error(::GetLastError())).message() |
| << '\n'; |
| return -1; |
| } |
| |
| // Make sure ::CloseHandle is called on exit. |
| std::map<DWORD, HANDLE> ProcessIDToHandle; |
| |
| DEBUG_EVENT DebugEvent; |
| std::memset(&DebugEvent, 0, sizeof(DebugEvent)); |
| DWORD dwContinueStatus = DBG_CONTINUE; |
| |
| // Run the program under the debugger until either it exits, or throws an |
| // exception. |
| if (TraceExecution) |
| errs() << ToolName << ": Debugging...\n"; |
| |
| while(true) { |
| DWORD TimeLeft = INFINITE; |
| if (Timeout > 0) { |
| FILETIME CreationTime, ExitTime, KernelTime, UserTime; |
| ULARGE_INTEGER a, b; |
| success = ::GetProcessTimes(ProcessInfo.hProcess, |
| &CreationTime, |
| &ExitTime, |
| &KernelTime, |
| &UserTime); |
| if (!success) { |
| ec = windows_error(::GetLastError()); |
| |
| errs() << ToolName << ": Failed to get process times: " |
| << ec.message() << '\n'; |
| return -1; |
| } |
| a.LowPart = KernelTime.dwLowDateTime; |
| a.HighPart = KernelTime.dwHighDateTime; |
| b.LowPart = UserTime.dwLowDateTime; |
| b.HighPart = UserTime.dwHighDateTime; |
| // Convert 100-nanosecond units to milliseconds. |
| uint64_t TotalTimeMiliseconds = (a.QuadPart + b.QuadPart) / 10000; |
| // Handle the case where the process has been running for more than 49 |
| // days. |
| if (TotalTimeMiliseconds > std::numeric_limits<uint32_t>::max()) { |
| errs() << ToolName << ": Timeout Failed: Process has been running for" |
| "more than 49 days.\n"; |
| return -1; |
| } |
| |
| // We check with > instead of using Timeleft because if |
| // TotalTimeMiliseconds is greater than Timeout * 1000, TimeLeft would |
| // underflow. |
| if (TotalTimeMiliseconds > (Timeout * 1000)) { |
| errs() << ToolName << ": Process timed out.\n"; |
| ::TerminateProcess(ProcessInfo.hProcess, -1); |
| // Otherwise other stuff starts failing... |
| return -1; |
| } |
| |
| TimeLeft = (Timeout * 1000) - static_cast<uint32_t>(TotalTimeMiliseconds); |
| } |
| success = WaitForDebugEvent(&DebugEvent, TimeLeft); |
| |
| if (!success) { |
| ec = windows_error(::GetLastError()); |
| |
| if (ec == errc::timed_out) { |
| errs() << ToolName << ": Process timed out.\n"; |
| ::TerminateProcess(ProcessInfo.hProcess, -1); |
| // Otherwise other stuff starts failing... |
| return -1; |
| } |
| |
| errs() << ToolName << ": Failed to wait for debug event in program: '" |
| << ProgramToRun << "': " << ec.message() << '\n'; |
| return -1; |
| } |
| |
| switch(DebugEvent.dwDebugEventCode) { |
| case CREATE_PROCESS_DEBUG_EVENT: |
| // Make sure we remove the handle on exit. |
| if (TraceExecution) |
| errs() << ToolName << ": Debug Event: CREATE_PROCESS_DEBUG_EVENT\n"; |
| ProcessIDToHandle[DebugEvent.dwProcessId] = |
| DebugEvent.u.CreateProcessInfo.hProcess; |
| ::CloseHandle(DebugEvent.u.CreateProcessInfo.hFile); |
| break; |
| case EXIT_PROCESS_DEBUG_EVENT: { |
| if (TraceExecution) |
| errs() << ToolName << ": Debug Event: EXIT_PROCESS_DEBUG_EVENT\n"; |
| |
| // If this is the process we originally created, exit with its exit |
| // code. |
| if (DebugEvent.dwProcessId == ProcessInfo.dwProcessId) |
| return DebugEvent.u.ExitProcess.dwExitCode; |
| |
| // Otherwise cleanup any resources we have for it. |
| std::map<DWORD, HANDLE>::iterator ExitingProcess = |
| ProcessIDToHandle.find(DebugEvent.dwProcessId); |
| if (ExitingProcess == ProcessIDToHandle.end()) { |
| errs() << ToolName << ": Got unknown process id!\n"; |
| return -1; |
| } |
| ::CloseHandle(ExitingProcess->second); |
| ProcessIDToHandle.erase(ExitingProcess); |
| } |
| break; |
| case CREATE_THREAD_DEBUG_EVENT: |
| ::CloseHandle(DebugEvent.u.CreateThread.hThread); |
| break; |
| case LOAD_DLL_DEBUG_EVENT: { |
| // Cleanup the file handle. |
| FileScopedHandle DLLFile(DebugEvent.u.LoadDll.hFile); |
| std::string DLLName; |
| ec = GetFileNameFromHandle(DLLFile, DLLName); |
| if (ec) { |
| DLLName = "<failed to get file name from file handle> : "; |
| DLLName += ec.message(); |
| } |
| if (TraceExecution) { |
| errs() << ToolName << ": Debug Event: LOAD_DLL_DEBUG_EVENT\n"; |
| errs().indent(ToolName.size()) << ": DLL Name : " << DLLName << '\n'; |
| } |
| |
| if (NoUser32 && sys::path::stem(DLLName) == "user32") { |
| // Program is loading user32.dll, in the applications we are testing, |
| // this only happens if an assert has fired. By now the message has |
| // already been printed, so simply close the program. |
| errs() << ToolName << ": user32.dll loaded!\n"; |
| errs().indent(ToolName.size()) |
| << ": This probably means that assert was called. Closing " |
| "program to prevent message box from popping up.\n"; |
| dwContinueStatus = DBG_CONTINUE; |
| ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1); |
| return -1; |
| } |
| } |
| break; |
| case EXCEPTION_DEBUG_EVENT: { |
| // Close the application if this exception will not be handled by the |
| // child application. |
| if (TraceExecution) |
| errs() << ToolName << ": Debug Event: EXCEPTION_DEBUG_EVENT\n"; |
| |
| EXCEPTION_DEBUG_INFO &Exception = DebugEvent.u.Exception; |
| if (Exception.dwFirstChance > 0) { |
| if (TraceExecution) { |
| errs().indent(ToolName.size()) << ": Debug Info : "; |
| errs() << "First chance exception at " |
| << Exception.ExceptionRecord.ExceptionAddress |
| << ", exception code: " |
| << ExceptionCodeToString( |
| Exception.ExceptionRecord.ExceptionCode) |
| << " (" << Exception.ExceptionRecord.ExceptionCode << ")\n"; |
| } |
| dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED; |
| } else { |
| errs() << ToolName << ": Unhandled exception in: " << ProgramToRun |
| << "!\n"; |
| errs().indent(ToolName.size()) << ": location: "; |
| errs() << Exception.ExceptionRecord.ExceptionAddress |
| << ", exception code: " |
| << ExceptionCodeToString( |
| Exception.ExceptionRecord.ExceptionCode) |
| << " (" << Exception.ExceptionRecord.ExceptionCode |
| << ")\n"; |
| dwContinueStatus = DBG_CONTINUE; |
| ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1); |
| return -1; |
| } |
| } |
| break; |
| default: |
| // Do nothing. |
| if (TraceExecution) |
| errs() << ToolName << ": Debug Event: <unknown>\n"; |
| break; |
| } |
| |
| success = ContinueDebugEvent(DebugEvent.dwProcessId, |
| DebugEvent.dwThreadId, |
| dwContinueStatus); |
| if (!success) { |
| ec = windows_error(::GetLastError()); |
| errs() << ToolName << ": Failed to continue debugging program: '" |
| << ProgramToRun << "': " << ec.message() << '\n'; |
| return -1; |
| } |
| |
| dwContinueStatus = DBG_CONTINUE; |
| } |
| |
| assert(0 && "Fell out of debug loop. This shouldn't be possible!"); |
| return -1; |
| } |
