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:
ScopedHandle()84 ScopedHandle()
85 : Handle(HandleType::GetInvalidHandle()) {}
86
ScopedHandle(handle_type handle)87 explicit ScopedHandle(handle_type handle)
88 : Handle(handle) {}
89
~ScopedHandle()90 ~ScopedHandle() {
91 HandleType::Destruct(Handle);
92 }
93
operator =(handle_type handle)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
operator bool() const102 operator bool() const {
103 return HandleType::isValid(Handle);
104 }
105
operator handle_type()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
GetInvalidHandle__anonc6b8317c0111::CommonHandle115 static handle_type GetInvalidHandle() {
116 return INVALID_HANDLE_VALUE;
117 }
118
Destruct__anonc6b8317c0111::CommonHandle119 static void Destruct(handle_type Handle) {
120 ::CloseHandle(Handle);
121 }
122
isValid__anonc6b8317c0111::CommonHandle123 static bool isValid(handle_type Handle) {
124 return Handle != GetInvalidHandle();
125 }
126 };
127
128 struct FileMappingHandle {
129 typedef HANDLE handle_type;
130
GetInvalidHandle__anonc6b8317c0111::FileMappingHandle131 static handle_type GetInvalidHandle() {
132 return NULL;
133 }
134
Destruct__anonc6b8317c0111::FileMappingHandle135 static void Destruct(handle_type Handle) {
136 ::CloseHandle(Handle);
137 }
138
isValid__anonc6b8317c0111::FileMappingHandle139 static bool isValid(handle_type Handle) {
140 return Handle != GetInvalidHandle();
141 }
142 };
143
144 struct MappedViewOfFileHandle {
145 typedef LPVOID handle_type;
146
GetInvalidHandle__anonc6b8317c0111::MappedViewOfFileHandle147 static handle_type GetInvalidHandle() {
148 return NULL;
149 }
150
Destruct__anonc6b8317c0111::MappedViewOfFileHandle151 static void Destruct(handle_type Handle) {
152 ::UnmapViewOfFile(Handle);
153 }
154
isValid__anonc6b8317c0111::MappedViewOfFileHandle155 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
windows_error(DWORD E)173 static std::error_code windows_error(DWORD E) { return mapWindowsError(E); }
174
GetFileNameFromHandle(HANDLE FileHandle,std::string & Name)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.
FindProgram(const std::string & Program,std::error_code & ec)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
ExceptionCodeToString(DWORD ExceptionCode)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
main(int argc,char ** argv)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