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