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