1 //===-- DebuggerThread.cpp --------------------------------------*- 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 #include "DebuggerThread.h"
11 #include "ExceptionRecord.h"
12 #include "IDebugDelegate.h"
13 
14 #include "lldb/Core/Error.h"
15 #include "lldb/Core/Log.h"
16 #include "lldb/Core/ModuleSpec.h"
17 #include "lldb/Host/FileSpec.h"
18 #include "lldb/Host/Predicate.h"
19 #include "lldb/Host/ThisThread.h"
20 #include "lldb/Host/ThreadLauncher.h"
21 #include "lldb/Host/windows/HostProcessWindows.h"
22 #include "lldb/Host/windows/HostThreadWindows.h"
23 #include "lldb/Host/windows/ProcessLauncherWindows.h"
24 #include "lldb/Target/Process.h"
25 #include "lldb/Target/ProcessLaunchInfo.h"
26 
27 #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
28 
29 #include "llvm/ADT/STLExtras.h"
30 #include "llvm/Support/ConvertUTF.h"
31 #include "llvm/Support/raw_ostream.h"
32 
33 using namespace lldb;
34 using namespace lldb_private;
35 
36 namespace {
37 struct DebugLaunchContext {
38   DebugLaunchContext(DebuggerThread *thread,
39                      const ProcessLaunchInfo &launch_info)
40       : m_thread(thread), m_launch_info(launch_info) {}
41   DebuggerThread *m_thread;
42   ProcessLaunchInfo m_launch_info;
43 };
44 
45 struct DebugAttachContext {
46   DebugAttachContext(DebuggerThread *thread, lldb::pid_t pid,
47                      const ProcessAttachInfo &attach_info)
48       : m_thread(thread), m_pid(pid), m_attach_info(attach_info) {}
49   DebuggerThread *m_thread;
50   lldb::pid_t m_pid;
51   ProcessAttachInfo m_attach_info;
52 };
53 }
54 
55 DebuggerThread::DebuggerThread(DebugDelegateSP debug_delegate)
56     : m_debug_delegate(debug_delegate), m_pid_to_detach(0),
57       m_is_shutting_down(false) {
58   m_debugging_ended_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
59 }
60 
61 DebuggerThread::~DebuggerThread() { ::CloseHandle(m_debugging_ended_event); }
62 
63 Error DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
64   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
65                "DebuggerThread::DebugLaunch launching '%s'",
66                launch_info.GetExecutableFile().GetPath().c_str());
67 
68   Error error;
69   DebugLaunchContext *context = new DebugLaunchContext(this, launch_info);
70   HostThread slave_thread(ThreadLauncher::LaunchThread(
71       "lldb.plugin.process-windows.slave[?]", DebuggerThreadLaunchRoutine,
72       context, &error));
73 
74   if (!error.Success()) {
75     WINERR_IFALL(WINDOWS_LOG_PROCESS,
76                  "DebugLaunch couldn't launch debugger thread.  %s",
77                  error.AsCString());
78   }
79 
80   return error;
81 }
82 
83 Error DebuggerThread::DebugAttach(lldb::pid_t pid,
84                                   const ProcessAttachInfo &attach_info) {
85   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
86                "DebuggerThread::DebugAttach attaching to '%llu'", pid);
87 
88   Error error;
89   DebugAttachContext *context = new DebugAttachContext(this, pid, attach_info);
90   HostThread slave_thread(ThreadLauncher::LaunchThread(
91       "lldb.plugin.process-windows.slave[?]", DebuggerThreadAttachRoutine,
92       context, &error));
93 
94   if (!error.Success()) {
95     WINERR_IFALL(WINDOWS_LOG_PROCESS,
96                  "DebugAttach couldn't attach to process '%llu'.  %s", pid,
97                  error.AsCString());
98   }
99 
100   return error;
101 }
102 
103 lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(void *data) {
104   DebugLaunchContext *context = static_cast<DebugLaunchContext *>(data);
105   lldb::thread_result_t result =
106       context->m_thread->DebuggerThreadLaunchRoutine(context->m_launch_info);
107   delete context;
108   return result;
109 }
110 
111 lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(void *data) {
112   DebugAttachContext *context = static_cast<DebugAttachContext *>(data);
113   lldb::thread_result_t result = context->m_thread->DebuggerThreadAttachRoutine(
114       context->m_pid, context->m_attach_info);
115   delete context;
116   return result;
117 }
118 
119 lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(
120     const ProcessLaunchInfo &launch_info) {
121   // Grab a shared_ptr reference to this so that we know it won't get deleted
122   // until after the
123   // thread routine has exited.
124   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
125 
126   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
127                "DebuggerThread preparing to launch '%s' on background thread.",
128                launch_info.GetExecutableFile().GetPath().c_str());
129 
130   Error error;
131   ProcessLauncherWindows launcher;
132   HostProcess process(launcher.LaunchProcess(launch_info, error));
133   // If we couldn't create the process, notify waiters immediately.  Otherwise
134   // enter the debug
135   // loop and wait until we get the create process debug notification.  Note
136   // that if the process
137   // was created successfully, we can throw away the process handle we got from
138   // CreateProcess
139   // because Windows will give us another (potentially more useful?) handle when
140   // it sends us the
141   // CREATE_PROCESS_DEBUG_EVENT.
142   if (error.Success())
143     DebugLoop();
144   else
145     m_debug_delegate->OnDebuggerError(error, 0);
146 
147   return 0;
148 }
149 
150 lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
151     lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
152   // Grab a shared_ptr reference to this so that we know it won't get deleted
153   // until after the
154   // thread routine has exited.
155   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
156 
157   WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DebuggerThread preparing to attach to "
158                                     "process '%llu' on background thread.",
159                pid);
160 
161   if (!DebugActiveProcess((DWORD)pid)) {
162     Error error(::GetLastError(), eErrorTypeWin32);
163     m_debug_delegate->OnDebuggerError(error, 0);
164     return 0;
165   }
166 
167   // The attach was successful, enter the debug loop.  From here on out, this is
168   // no different than
169   // a create process operation, so all the same comments in DebugLaunch should
170   // apply from this
171   // point out.
172   DebugLoop();
173 
174   return 0;
175 }
176 
177 Error DebuggerThread::StopDebugging(bool terminate) {
178   Error error;
179 
180   lldb::pid_t pid = m_process.GetProcessId();
181 
182   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
183                "StopDebugging('%s') called (inferior=%I64u).",
184                (terminate ? "true" : "false"), pid);
185 
186   // Set m_is_shutting_down to true if it was false.  Return if it was already
187   // true.
188   bool expected = false;
189   if (!m_is_shutting_down.compare_exchange_strong(expected, true))
190     return error;
191 
192   // Make a copy of the process, since the termination sequence will reset
193   // DebuggerThread's internal copy and it needs to remain open for the Wait
194   // operation.
195   HostProcess process_copy = m_process;
196   lldb::process_t handle = m_process.GetNativeProcess().GetSystemHandle();
197 
198   if (terminate) {
199     // Initiate the termination before continuing the exception, so that the
200     // next debug
201     // event we get is the exit process event, and not some other event.
202     BOOL terminate_suceeded = TerminateProcess(handle, 0);
203     WINLOG_IFALL(WINDOWS_LOG_PROCESS, "StopDebugging called "
204                                       "TerminateProcess(0x%p, 0) "
205                                       "(inferior=%I64u), success='%s'",
206                  handle, pid, (terminate_suceeded ? "true" : "false"));
207   }
208 
209   // If we're stuck waiting for an exception to continue (e.g. the user is at a
210   // breakpoint
211   // messing around in the debugger), continue it now.  But only AFTER calling
212   // TerminateProcess
213   // to make sure that the very next call to WaitForDebugEvent is an exit
214   // process event.
215   if (m_active_exception.get()) {
216     WINLOG_IFANY(WINDOWS_LOG_PROCESS | WINDOWS_LOG_EXCEPTION,
217                  "StopDebugging masking active exception");
218 
219     ContinueAsyncException(ExceptionResult::MaskException);
220   }
221 
222   if (!terminate) {
223     // Indicate that we want to detach.
224     m_pid_to_detach = GetProcess().GetProcessId();
225 
226     // Force a fresh break so that the detach can happen from the debugger
227     // thread.
228     if (!::DebugBreakProcess(
229             GetProcess().GetNativeProcess().GetSystemHandle())) {
230       error.SetError(::GetLastError(), eErrorTypeWin32);
231     }
232   }
233 
234   WINLOG_IFALL(
235       WINDOWS_LOG_PROCESS,
236       "StopDebugging waiting for detach from process %llu to complete.", pid);
237 
238   DWORD wait_result = WaitForSingleObject(m_debugging_ended_event, 5000);
239   if (wait_result != WAIT_OBJECT_0) {
240     error.SetError(GetLastError(), eErrorTypeWin32);
241     WINERR_IFALL(WINDOWS_LOG_PROCESS,
242                  "StopDebugging WaitForSingleObject(0x%p, 5000) returned %lu",
243                  m_debugging_ended_event, wait_result);
244   } else {
245     WINLOG_IFALL(
246         WINDOWS_LOG_PROCESS,
247         "StopDebugging detach from process %llu completed successfully.", pid);
248   }
249 
250   if (!error.Success()) {
251     WINERR_IFALL(WINDOWS_LOG_PROCESS, "StopDebugging encountered an error "
252                                       "while trying to stop process %llu.  %s",
253                  pid, error.AsCString());
254   }
255   return error;
256 }
257 
258 void DebuggerThread::ContinueAsyncException(ExceptionResult result) {
259   if (!m_active_exception.get())
260     return;
261 
262   WINLOG_IFANY(
263       WINDOWS_LOG_PROCESS | WINDOWS_LOG_EXCEPTION,
264       "ContinueAsyncException called for inferior process %I64u, broadcasting.",
265       m_process.GetProcessId());
266 
267   m_active_exception.reset();
268   m_exception_pred.SetValue(result, eBroadcastAlways);
269 }
270 
271 void DebuggerThread::FreeProcessHandles() {
272   m_process = HostProcess();
273   m_main_thread = HostThread();
274   if (m_image_file) {
275     ::CloseHandle(m_image_file);
276     m_image_file = nullptr;
277   }
278 }
279 
280 void DebuggerThread::DebugLoop() {
281   DEBUG_EVENT dbe = {};
282   bool should_debug = true;
283   WINLOG_IFALL(WINDOWS_LOG_EVENT, "Entering WaitForDebugEvent loop");
284   while (should_debug) {
285     WINLOGD_IFALL(WINDOWS_LOG_EVENT, "Calling WaitForDebugEvent");
286     BOOL wait_result = WaitForDebugEvent(&dbe, INFINITE);
287     if (wait_result) {
288       DWORD continue_status = DBG_CONTINUE;
289       switch (dbe.dwDebugEventCode) {
290       case EXCEPTION_DEBUG_EVENT: {
291         ExceptionResult status =
292             HandleExceptionEvent(dbe.u.Exception, dbe.dwThreadId);
293 
294         if (status == ExceptionResult::MaskException)
295           continue_status = DBG_CONTINUE;
296         else if (status == ExceptionResult::SendToApplication)
297           continue_status = DBG_EXCEPTION_NOT_HANDLED;
298 
299         break;
300       }
301       case CREATE_THREAD_DEBUG_EVENT:
302         continue_status =
303             HandleCreateThreadEvent(dbe.u.CreateThread, dbe.dwThreadId);
304         break;
305       case CREATE_PROCESS_DEBUG_EVENT:
306         continue_status =
307             HandleCreateProcessEvent(dbe.u.CreateProcessInfo, dbe.dwThreadId);
308         break;
309       case EXIT_THREAD_DEBUG_EVENT:
310         continue_status =
311             HandleExitThreadEvent(dbe.u.ExitThread, dbe.dwThreadId);
312         break;
313       case EXIT_PROCESS_DEBUG_EVENT:
314         continue_status =
315             HandleExitProcessEvent(dbe.u.ExitProcess, dbe.dwThreadId);
316         should_debug = false;
317         break;
318       case LOAD_DLL_DEBUG_EVENT:
319         continue_status = HandleLoadDllEvent(dbe.u.LoadDll, dbe.dwThreadId);
320         break;
321       case UNLOAD_DLL_DEBUG_EVENT:
322         continue_status = HandleUnloadDllEvent(dbe.u.UnloadDll, dbe.dwThreadId);
323         break;
324       case OUTPUT_DEBUG_STRING_EVENT:
325         continue_status = HandleODSEvent(dbe.u.DebugString, dbe.dwThreadId);
326         break;
327       case RIP_EVENT:
328         continue_status = HandleRipEvent(dbe.u.RipInfo, dbe.dwThreadId);
329         if (dbe.u.RipInfo.dwType == SLE_ERROR)
330           should_debug = false;
331         break;
332       }
333 
334       WINLOGD_IFALL(
335           WINDOWS_LOG_EVENT,
336           "DebugLoop calling ContinueDebugEvent(%lu, %lu, %lu) on thread %lu.",
337           dbe.dwProcessId, dbe.dwThreadId, continue_status,
338           ::GetCurrentThreadId());
339 
340       ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status);
341 
342       if (m_detached) {
343         should_debug = false;
344       }
345     } else {
346       WINERR_IFALL(
347           WINDOWS_LOG_EVENT,
348           "DebugLoop returned FALSE from WaitForDebugEvent.  Error = %lu",
349           ::GetLastError());
350 
351       should_debug = false;
352     }
353   }
354   FreeProcessHandles();
355 
356   WINLOG_IFALL(WINDOWS_LOG_EVENT, "WaitForDebugEvent loop completed, exiting.");
357   SetEvent(m_debugging_ended_event);
358 }
359 
360 ExceptionResult
361 DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
362                                      DWORD thread_id) {
363   if (m_is_shutting_down) {
364     // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a magic
365     // exception that
366     // we use simply to wake up the DebuggerThread so that we can close out the
367     // debug loop.
368     if (m_pid_to_detach != 0 &&
369         info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT) {
370       WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION |
371                        WINDOWS_LOG_PROCESS,
372                    "Breakpoint exception is cue to detach from process 0x%lx",
373                    m_pid_to_detach.load());
374       ::DebugActiveProcessStop(m_pid_to_detach);
375       m_detached = true;
376     }
377 
378     // Don't perform any blocking operations while we're shutting down.  That
379     // will
380     // cause TerminateProcess -> WaitForSingleObject to time out.
381     return ExceptionResult::SendToApplication;
382   }
383 
384   bool first_chance = (info.dwFirstChance != 0);
385 
386   m_active_exception.reset(
387       new ExceptionRecord(info.ExceptionRecord, thread_id));
388   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION,
389                "HandleExceptionEvent encountered %s chance exception 0x%lx on "
390                "thread 0x%lx",
391                first_chance ? "first" : "second",
392                info.ExceptionRecord.ExceptionCode, thread_id);
393 
394   ExceptionResult result =
395       m_debug_delegate->OnDebugException(first_chance, *m_active_exception);
396   m_exception_pred.SetValue(result, eBroadcastNever);
397 
398   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION,
399                "DebuggerThread::HandleExceptionEvent waiting for ExceptionPred "
400                "!= BreakInDebugger");
401 
402   m_exception_pred.WaitForValueNotEqualTo(ExceptionResult::BreakInDebugger,
403                                           result);
404 
405   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION,
406                "DebuggerThread::HandleExceptionEvent got ExceptionPred = %u",
407                m_exception_pred.GetValue());
408 
409   return result;
410 }
411 
412 DWORD
413 DebuggerThread::HandleCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO &info,
414                                         DWORD thread_id) {
415   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
416                "HandleCreateThreadEvent Thread 0x%lx spawned in process %llu",
417                thread_id, m_process.GetProcessId());
418   HostThread thread(info.hThread);
419   thread.GetNativeThread().SetOwnsHandle(false);
420   m_debug_delegate->OnCreateThread(thread);
421   return DBG_CONTINUE;
422 }
423 
424 DWORD
425 DebuggerThread::HandleCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO &info,
426                                          DWORD thread_id) {
427   uint32_t process_id = ::GetProcessId(info.hProcess);
428 
429   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_PROCESS,
430                "HandleCreateProcessEvent process %u spawned", process_id);
431 
432   std::string thread_name;
433   llvm::raw_string_ostream name_stream(thread_name);
434   name_stream << "lldb.plugin.process-windows.slave[" << process_id << "]";
435   name_stream.flush();
436   ThisThread::SetName(thread_name.c_str());
437 
438   // info.hProcess and info.hThread are closed automatically by Windows when
439   // EXIT_PROCESS_DEBUG_EVENT is received.
440   m_process = HostProcess(info.hProcess);
441   ((HostProcessWindows &)m_process.GetNativeProcess()).SetOwnsHandle(false);
442   m_main_thread = HostThread(info.hThread);
443   m_main_thread.GetNativeThread().SetOwnsHandle(false);
444   m_image_file = info.hFile;
445 
446   lldb::addr_t load_addr = reinterpret_cast<lldb::addr_t>(info.lpBaseOfImage);
447   m_debug_delegate->OnDebuggerConnected(load_addr);
448 
449   return DBG_CONTINUE;
450 }
451 
452 DWORD
453 DebuggerThread::HandleExitThreadEvent(const EXIT_THREAD_DEBUG_INFO &info,
454                                       DWORD thread_id) {
455   WINLOG_IFANY(
456       WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
457       "HandleExitThreadEvent Thread %lu exited with code %lu in process %llu",
458       thread_id, info.dwExitCode, m_process.GetProcessId());
459   m_debug_delegate->OnExitThread(thread_id, info.dwExitCode);
460   return DBG_CONTINUE;
461 }
462 
463 DWORD
464 DebuggerThread::HandleExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO &info,
465                                        DWORD thread_id) {
466   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
467                "HandleExitProcessEvent process %llu exited with code %lu",
468                m_process.GetProcessId(), info.dwExitCode);
469 
470   m_debug_delegate->OnExitProcess(info.dwExitCode);
471 
472   FreeProcessHandles();
473   return DBG_CONTINUE;
474 }
475 
476 DWORD
477 DebuggerThread::HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info,
478                                    DWORD thread_id) {
479   if (info.hFile == nullptr) {
480     // Not sure what this is, so just ignore it.
481     WINWARN_IFALL(WINDOWS_LOG_EVENT, "Inferior %llu - HandleLoadDllEvent has "
482                                      "a NULL file handle, returning...",
483                   m_process.GetProcessId());
484     return DBG_CONTINUE;
485   }
486 
487   std::vector<wchar_t> buffer(1);
488   DWORD required_size =
489       GetFinalPathNameByHandleW(info.hFile, &buffer[0], 0, VOLUME_NAME_DOS);
490   if (required_size > 0) {
491     buffer.resize(required_size + 1);
492     required_size = GetFinalPathNameByHandleW(info.hFile, &buffer[0],
493                                               required_size, VOLUME_NAME_DOS);
494     std::string path_str_utf8;
495     llvm::convertWideToUTF8(buffer.data(), path_str_utf8);
496     llvm::StringRef path_str = path_str_utf8;
497     const char *path = path_str.data();
498     if (path_str.startswith("\\\\?\\"))
499       path += 4;
500 
501     FileSpec file_spec(path, false);
502     ModuleSpec module_spec(file_spec);
503     lldb::addr_t load_addr = reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll);
504 
505     WINLOG_IFALL(WINDOWS_LOG_EVENT, "Inferior %I64u - HandleLoadDllEvent DLL "
506                                     "'%s' loaded at address 0x%p...",
507                  m_process.GetProcessId(), path, info.lpBaseOfDll);
508 
509     m_debug_delegate->OnLoadDll(module_spec, load_addr);
510   } else {
511     WINERR_IFALL(WINDOWS_LOG_EVENT, "Inferior %llu - HandleLoadDllEvent Error "
512                                     "%lu occurred calling "
513                                     "GetFinalPathNameByHandle",
514                  m_process.GetProcessId(), ::GetLastError());
515   }
516   // Windows does not automatically close info.hFile, so we need to do it.
517   ::CloseHandle(info.hFile);
518   return DBG_CONTINUE;
519 }
520 
521 DWORD
522 DebuggerThread::HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
523                                      DWORD thread_id) {
524   WINLOG_IFALL(WINDOWS_LOG_EVENT,
525                "HandleUnloadDllEvent process %llu unloading DLL at addr 0x%p.",
526                m_process.GetProcessId(), info.lpBaseOfDll);
527 
528   m_debug_delegate->OnUnloadDll(
529       reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll));
530   return DBG_CONTINUE;
531 }
532 
533 DWORD
534 DebuggerThread::HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info,
535                                DWORD thread_id) {
536   return DBG_CONTINUE;
537 }
538 
539 DWORD
540 DebuggerThread::HandleRipEvent(const RIP_INFO &info, DWORD thread_id) {
541   WINERR_IFALL(WINDOWS_LOG_EVENT, "HandleRipEvent encountered error %lu "
542                                   "(type=%lu) in process %llu thread %lu",
543                info.dwError, info.dwType, m_process.GetProcessId(), thread_id);
544 
545   Error error(info.dwError, eErrorTypeWin32);
546   m_debug_delegate->OnDebuggerError(error, info.dwType);
547 
548   return DBG_CONTINUE;
549 }
550