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/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 /// @brief 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(); 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 (std::vector<std::string>::iterator i = Argv.begin(), 331 e = Argv.end(); 332 i != e; ++i) { 333 CommandLine.push_back(' '); 334 CommandLine.append(*i); 335 } 336 337 if (TraceExecution) 338 errs() << ToolName << ": Program Image Path: " << ProgramToRun << '\n' 339 << ToolName << ": Command Line: " << CommandLine << '\n'; 340 341 STARTUPINFO StartupInfo; 342 PROCESS_INFORMATION ProcessInfo; 343 std::memset(&StartupInfo, 0, sizeof(StartupInfo)); 344 StartupInfo.cb = sizeof(StartupInfo); 345 std::memset(&ProcessInfo, 0, sizeof(ProcessInfo)); 346 347 // Set error mode to not display any message boxes. The child process inherits 348 // this. 349 ::SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX); 350 ::_set_error_mode(_OUT_TO_STDERR); 351 352 BOOL success = ::CreateProcessA(ProgramToRun.c_str(), 353 LPSTR(CommandLine.c_str()), 354 NULL, 355 NULL, 356 FALSE, 357 DEBUG_PROCESS, 358 NULL, 359 NULL, 360 &StartupInfo, 361 &ProcessInfo); 362 if (!success) { 363 errs() << ToolName << ": Failed to run program: '" << ProgramToRun << "': " 364 << std::error_code(windows_error(::GetLastError())).message() 365 << '\n'; 366 return -1; 367 } 368 369 // Make sure ::CloseHandle is called on exit. 370 std::map<DWORD, HANDLE> ProcessIDToHandle; 371 372 DEBUG_EVENT DebugEvent; 373 std::memset(&DebugEvent, 0, sizeof(DebugEvent)); 374 DWORD dwContinueStatus = DBG_CONTINUE; 375 376 // Run the program under the debugger until either it exits, or throws an 377 // exception. 378 if (TraceExecution) 379 errs() << ToolName << ": Debugging...\n"; 380 381 while(true) { 382 DWORD TimeLeft = INFINITE; 383 if (Timeout > 0) { 384 FILETIME CreationTime, ExitTime, KernelTime, UserTime; 385 ULARGE_INTEGER a, b; 386 success = ::GetProcessTimes(ProcessInfo.hProcess, 387 &CreationTime, 388 &ExitTime, 389 &KernelTime, 390 &UserTime); 391 if (!success) { 392 ec = windows_error(::GetLastError()); 393 394 errs() << ToolName << ": Failed to get process times: " 395 << ec.message() << '\n'; 396 return -1; 397 } 398 a.LowPart = KernelTime.dwLowDateTime; 399 a.HighPart = KernelTime.dwHighDateTime; 400 b.LowPart = UserTime.dwLowDateTime; 401 b.HighPart = UserTime.dwHighDateTime; 402 // Convert 100-nanosecond units to milliseconds. 403 uint64_t TotalTimeMiliseconds = (a.QuadPart + b.QuadPart) / 10000; 404 // Handle the case where the process has been running for more than 49 405 // days. 406 if (TotalTimeMiliseconds > std::numeric_limits<uint32_t>::max()) { 407 errs() << ToolName << ": Timeout Failed: Process has been running for" 408 "more than 49 days.\n"; 409 return -1; 410 } 411 412 // We check with > instead of using Timeleft because if 413 // TotalTimeMiliseconds is greater than Timeout * 1000, TimeLeft would 414 // underflow. 415 if (TotalTimeMiliseconds > (Timeout * 1000)) { 416 errs() << ToolName << ": Process timed out.\n"; 417 ::TerminateProcess(ProcessInfo.hProcess, -1); 418 // Otherwise other stuff starts failing... 419 return -1; 420 } 421 422 TimeLeft = (Timeout * 1000) - static_cast<uint32_t>(TotalTimeMiliseconds); 423 } 424 success = WaitForDebugEvent(&DebugEvent, TimeLeft); 425 426 if (!success) { 427 DWORD LastError = ::GetLastError(); 428 ec = windows_error(LastError); 429 430 if (LastError == ERROR_SEM_TIMEOUT || LastError == WSAETIMEDOUT) { 431 errs() << ToolName << ": Process timed out.\n"; 432 ::TerminateProcess(ProcessInfo.hProcess, -1); 433 // Otherwise other stuff starts failing... 434 return -1; 435 } 436 437 errs() << ToolName << ": Failed to wait for debug event in program: '" 438 << ProgramToRun << "': " << ec.message() << '\n'; 439 return -1; 440 } 441 442 switch(DebugEvent.dwDebugEventCode) { 443 case CREATE_PROCESS_DEBUG_EVENT: 444 // Make sure we remove the handle on exit. 445 if (TraceExecution) 446 errs() << ToolName << ": Debug Event: CREATE_PROCESS_DEBUG_EVENT\n"; 447 ProcessIDToHandle[DebugEvent.dwProcessId] = 448 DebugEvent.u.CreateProcessInfo.hProcess; 449 ::CloseHandle(DebugEvent.u.CreateProcessInfo.hFile); 450 break; 451 case EXIT_PROCESS_DEBUG_EVENT: { 452 if (TraceExecution) 453 errs() << ToolName << ": Debug Event: EXIT_PROCESS_DEBUG_EVENT\n"; 454 455 // If this is the process we originally created, exit with its exit 456 // code. 457 if (DebugEvent.dwProcessId == ProcessInfo.dwProcessId) 458 return DebugEvent.u.ExitProcess.dwExitCode; 459 460 // Otherwise cleanup any resources we have for it. 461 std::map<DWORD, HANDLE>::iterator ExitingProcess = 462 ProcessIDToHandle.find(DebugEvent.dwProcessId); 463 if (ExitingProcess == ProcessIDToHandle.end()) { 464 errs() << ToolName << ": Got unknown process id!\n"; 465 return -1; 466 } 467 ::CloseHandle(ExitingProcess->second); 468 ProcessIDToHandle.erase(ExitingProcess); 469 } 470 break; 471 case CREATE_THREAD_DEBUG_EVENT: 472 ::CloseHandle(DebugEvent.u.CreateThread.hThread); 473 break; 474 case LOAD_DLL_DEBUG_EVENT: { 475 // Cleanup the file handle. 476 FileScopedHandle DLLFile(DebugEvent.u.LoadDll.hFile); 477 std::string DLLName; 478 ec = GetFileNameFromHandle(DLLFile, DLLName); 479 if (ec) { 480 DLLName = "<failed to get file name from file handle> : "; 481 DLLName += ec.message(); 482 } 483 if (TraceExecution) { 484 errs() << ToolName << ": Debug Event: LOAD_DLL_DEBUG_EVENT\n"; 485 errs().indent(ToolName.size()) << ": DLL Name : " << DLLName << '\n'; 486 } 487 488 if (NoUser32 && sys::path::stem(DLLName) == "user32") { 489 // Program is loading user32.dll, in the applications we are testing, 490 // this only happens if an assert has fired. By now the message has 491 // already been printed, so simply close the program. 492 errs() << ToolName << ": user32.dll loaded!\n"; 493 errs().indent(ToolName.size()) 494 << ": This probably means that assert was called. Closing " 495 "program to prevent message box from popping up.\n"; 496 dwContinueStatus = DBG_CONTINUE; 497 ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1); 498 return -1; 499 } 500 } 501 break; 502 case EXCEPTION_DEBUG_EVENT: { 503 // Close the application if this exception will not be handled by the 504 // child application. 505 if (TraceExecution) 506 errs() << ToolName << ": Debug Event: EXCEPTION_DEBUG_EVENT\n"; 507 508 EXCEPTION_DEBUG_INFO &Exception = DebugEvent.u.Exception; 509 if (Exception.dwFirstChance > 0) { 510 if (TraceExecution) { 511 errs().indent(ToolName.size()) << ": Debug Info : "; 512 errs() << "First chance exception at " 513 << Exception.ExceptionRecord.ExceptionAddress 514 << ", exception code: " 515 << ExceptionCodeToString( 516 Exception.ExceptionRecord.ExceptionCode) 517 << " (" << Exception.ExceptionRecord.ExceptionCode << ")\n"; 518 } 519 dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED; 520 } else { 521 errs() << ToolName << ": Unhandled exception in: " << ProgramToRun 522 << "!\n"; 523 errs().indent(ToolName.size()) << ": location: "; 524 errs() << Exception.ExceptionRecord.ExceptionAddress 525 << ", exception code: " 526 << ExceptionCodeToString( 527 Exception.ExceptionRecord.ExceptionCode) 528 << " (" << Exception.ExceptionRecord.ExceptionCode 529 << ")\n"; 530 dwContinueStatus = DBG_CONTINUE; 531 ::TerminateProcess(ProcessIDToHandle[DebugEvent.dwProcessId], -1); 532 return -1; 533 } 534 } 535 break; 536 default: 537 // Do nothing. 538 if (TraceExecution) 539 errs() << ToolName << ": Debug Event: <unknown>\n"; 540 break; 541 } 542 543 success = ContinueDebugEvent(DebugEvent.dwProcessId, 544 DebugEvent.dwThreadId, 545 dwContinueStatus); 546 if (!success) { 547 ec = windows_error(::GetLastError()); 548 errs() << ToolName << ": Failed to continue debugging program: '" 549 << ProgramToRun << "': " << ec.message() << '\n'; 550 return -1; 551 } 552 553 dwContinueStatus = DBG_CONTINUE; 554 } 555 556 assert(0 && "Fell out of debug loop. This shouldn't be possible!"); 557 return -1; 558 } 559