| //===-- ProcessWindowsLive.cpp ----------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // Windows includes |
| #include "lldb/Host/windows/windows.h" |
| #include <psapi.h> |
| |
| // C++ Includes |
| #include <list> |
| #include <mutex> |
| #include <set> |
| #include <vector> |
| |
| // Other libraries and framework includes |
| #include "lldb/Core/Module.h" |
| #include "lldb/Core/ModuleSpec.h" |
| #include "lldb/Core/PluginManager.h" |
| #include "lldb/Core/Section.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Host/Host.h" |
| #include "lldb/Host/HostNativeProcessBase.h" |
| #include "lldb/Host/HostNativeThreadBase.h" |
| #include "lldb/Host/HostProcess.h" |
| #include "lldb/Host/MonitoringProcessLauncher.h" |
| #include "lldb/Host/ThreadLauncher.h" |
| #include "lldb/Host/windows/HostThreadWindows.h" |
| #include "lldb/Host/windows/ProcessLauncherWindows.h" |
| #include "lldb/Symbol/ObjectFile.h" |
| #include "lldb/Target/DynamicLoader.h" |
| #include "lldb/Target/FileAction.h" |
| #include "lldb/Target/MemoryRegionInfo.h" |
| #include "lldb/Target/RegisterContext.h" |
| #include "lldb/Target/StopInfo.h" |
| #include "lldb/Target/Target.h" |
| |
| #include "Plugins/Process/Windows/Common/ProcessWindowsLog.h" |
| |
| #include "DebuggerThread.h" |
| #include "ExceptionRecord.h" |
| #include "LocalDebugDelegate.h" |
| #include "ProcessWindowsLive.h" |
| #include "TargetThreadWindowsLive.h" |
| |
| #include "llvm/Support/ConvertUTF.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| #define BOOL_STR(b) ((b) ? "true" : "false") |
| |
| namespace { |
| |
| std::string GetProcessExecutableName(HANDLE process_handle) { |
| std::vector<wchar_t> file_name; |
| DWORD file_name_size = MAX_PATH; // first guess, not an absolute limit |
| DWORD copied = 0; |
| do { |
| file_name_size *= 2; |
| file_name.resize(file_name_size); |
| copied = ::GetModuleFileNameExW(process_handle, NULL, file_name.data(), |
| file_name_size); |
| } while (copied >= file_name_size); |
| file_name.resize(copied); |
| std::string result; |
| llvm::convertWideToUTF8(file_name.data(), result); |
| return result; |
| } |
| |
| std::string GetProcessExecutableName(DWORD pid) { |
| std::string file_name; |
| HANDLE process_handle = |
| ::OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid); |
| if (process_handle != NULL) { |
| file_name = GetProcessExecutableName(process_handle); |
| ::CloseHandle(process_handle); |
| } |
| return file_name; |
| } |
| |
| } // anonymous namespace |
| |
| namespace lldb_private { |
| |
| // We store a pointer to this class in the ProcessWindows, so that we don't |
| // expose Windows |
| // OS specific types and implementation details from a public header file. |
| class ProcessWindowsData { |
| public: |
| ProcessWindowsData(bool stop_at_entry) |
| : m_stop_at_entry(stop_at_entry), m_initial_stop_event(nullptr), |
| m_initial_stop_received(false) { |
| m_initial_stop_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr); |
| } |
| |
| ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); } |
| |
| lldb_private::Error m_launch_error; |
| lldb_private::DebuggerThreadSP m_debugger; |
| StopInfoSP m_pending_stop_info; |
| HANDLE m_initial_stop_event; |
| bool m_stop_at_entry; |
| bool m_initial_stop_received; |
| std::map<lldb::tid_t, HostThread> m_new_threads; |
| std::set<lldb::tid_t> m_exited_threads; |
| }; |
| } |
| //------------------------------------------------------------------------------ |
| // Static functions. |
| |
| ProcessSP ProcessWindowsLive::CreateInstance(lldb::TargetSP target_sp, |
| lldb::ListenerSP listener_sp, |
| const FileSpec *) { |
| return ProcessSP(new ProcessWindowsLive(target_sp, listener_sp)); |
| } |
| |
| void ProcessWindowsLive::Initialize() { |
| static std::once_flag g_once_flag; |
| |
| std::call_once(g_once_flag, []() { |
| PluginManager::RegisterPlugin(GetPluginNameStatic(), |
| GetPluginDescriptionStatic(), CreateInstance); |
| }); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Constructors and destructors. |
| |
| ProcessWindowsLive::ProcessWindowsLive(lldb::TargetSP target_sp, |
| lldb::ListenerSP listener_sp) |
| : lldb_private::ProcessWindows(target_sp, listener_sp) {} |
| |
| ProcessWindowsLive::~ProcessWindowsLive() {} |
| |
| void ProcessWindowsLive::Terminate() {} |
| |
| lldb_private::ConstString ProcessWindowsLive::GetPluginNameStatic() { |
| static ConstString g_name("windows"); |
| return g_name; |
| } |
| |
| const char *ProcessWindowsLive::GetPluginDescriptionStatic() { |
| return "Process plugin for Windows"; |
| } |
| |
| Error ProcessWindowsLive::EnableBreakpointSite(BreakpointSite *bp_site) { |
| WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS, |
| "EnableBreakpointSite called with bp_site 0x%p " |
| "(id=%d, addr=0x%x)", |
| bp_site->GetID(), bp_site->GetLoadAddress()); |
| |
| Error error = EnableSoftwareBreakpoint(bp_site); |
| if (!error.Success()) { |
| WINERR_IFALL(WINDOWS_LOG_BREAKPOINTS, "EnableBreakpointSite failed. %s", |
| error.AsCString()); |
| } |
| return error; |
| } |
| |
| Error ProcessWindowsLive::DisableBreakpointSite(BreakpointSite *bp_site) { |
| WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS, |
| "DisableBreakpointSite called with bp_site 0x%p " |
| "(id=%d, addr=0x%x)", |
| bp_site, bp_site->GetID(), bp_site->GetLoadAddress()); |
| |
| Error error = DisableSoftwareBreakpoint(bp_site); |
| |
| if (!error.Success()) { |
| WINERR_IFALL(WINDOWS_LOG_BREAKPOINTS, "DisableBreakpointSite failed. %s", |
| error.AsCString()); |
| } |
| return error; |
| } |
| |
| bool ProcessWindowsLive::UpdateThreadList(ThreadList &old_thread_list, |
| ThreadList &new_thread_list) { |
| // Add all the threads that were previously running and for which we did not |
| // detect a thread |
| // exited event. |
| int new_size = 0; |
| int continued_threads = 0; |
| int exited_threads = 0; |
| int new_threads = 0; |
| |
| for (ThreadSP old_thread : old_thread_list.Threads()) { |
| lldb::tid_t old_thread_id = old_thread->GetID(); |
| auto exited_thread_iter = |
| m_session_data->m_exited_threads.find(old_thread_id); |
| if (exited_thread_iter == m_session_data->m_exited_threads.end()) { |
| new_thread_list.AddThread(old_thread); |
| ++new_size; |
| ++continued_threads; |
| WINLOGV_IFALL( |
| WINDOWS_LOG_THREAD, |
| "UpdateThreadList - Thread %u was running and is still running.", |
| old_thread_id); |
| } else { |
| WINLOGV_IFALL(WINDOWS_LOG_THREAD, |
| "UpdateThreadList - Thread %u was running and has exited.", |
| old_thread_id); |
| ++exited_threads; |
| } |
| } |
| |
| // Also add all the threads that are new since the last time we broke into the |
| // debugger. |
| for (const auto &thread_info : m_session_data->m_new_threads) { |
| ThreadSP thread(new TargetThreadWindowsLive(*this, thread_info.second)); |
| thread->SetID(thread_info.first); |
| new_thread_list.AddThread(thread); |
| ++new_size; |
| ++new_threads; |
| WINLOGV_IFALL(WINDOWS_LOG_THREAD, |
| "UpdateThreadList - Thread %u is new since last update.", |
| thread_info.first); |
| } |
| |
| WINLOG_IFALL( |
| WINDOWS_LOG_THREAD, |
| "UpdateThreadList - %d new threads, %d old threads, %d exited threads.", |
| new_threads, continued_threads, exited_threads); |
| |
| m_session_data->m_new_threads.clear(); |
| m_session_data->m_exited_threads.clear(); |
| |
| return new_size > 0; |
| } |
| |
| Error ProcessWindowsLive::DoLaunch(Module *exe_module, |
| ProcessLaunchInfo &launch_info) { |
| // Even though m_session_data is accessed here, it is before a debugger thread |
| // has been |
| // kicked off. So there's no race conditions, and it shouldn't be necessary |
| // to acquire |
| // the mutex. |
| |
| Error result; |
| if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) { |
| StreamString stream; |
| stream.Printf("ProcessWindows unable to launch '%s'. ProcessWindows can " |
| "only be used for debug launches.", |
| launch_info.GetExecutableFile().GetPath().c_str()); |
| std::string message = stream.GetString(); |
| result.SetErrorString(message.c_str()); |
| |
| WINERR_IFALL(WINDOWS_LOG_PROCESS, message.c_str()); |
| return result; |
| } |
| |
| bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry); |
| m_session_data.reset(new ProcessWindowsData(stop_at_entry)); |
| |
| SetPrivateState(eStateLaunching); |
| DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this())); |
| m_session_data->m_debugger.reset(new DebuggerThread(delegate)); |
| DebuggerThreadSP debugger = m_session_data->m_debugger; |
| |
| // Kick off the DebugLaunch asynchronously and wait for it to complete. |
| result = debugger->DebugLaunch(launch_info); |
| if (result.Fail()) { |
| WINERR_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch failed launching '%s'. %s", |
| launch_info.GetExecutableFile().GetPath().c_str(), |
| result.AsCString()); |
| return result; |
| } |
| |
| HostProcess process; |
| Error error = WaitForDebuggerConnection(debugger, process); |
| if (error.Fail()) { |
| WINERR_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch failed launching '%s'. %s", |
| launch_info.GetExecutableFile().GetPath().c_str(), |
| error.AsCString()); |
| return error; |
| } |
| |
| WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoLaunch successfully launched '%s'", |
| launch_info.GetExecutableFile().GetPath().c_str()); |
| |
| // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the |
| // private state |
| // should already be set to eStateStopped as a result of hitting the initial |
| // breakpoint. If |
| // it was not set, the breakpoint should have already been resumed from and |
| // the private state |
| // should already be eStateRunning. |
| launch_info.SetProcessID(process.GetProcessId()); |
| SetID(process.GetProcessId()); |
| |
| return result; |
| } |
| |
| Error ProcessWindowsLive::DoAttachToProcessWithID( |
| lldb::pid_t pid, const ProcessAttachInfo &attach_info) { |
| m_session_data.reset( |
| new ProcessWindowsData(!attach_info.GetContinueOnceAttached())); |
| |
| DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this())); |
| DebuggerThreadSP debugger(new DebuggerThread(delegate)); |
| |
| m_session_data->m_debugger = debugger; |
| |
| DWORD process_id = static_cast<DWORD>(pid); |
| Error error = debugger->DebugAttach(process_id, attach_info); |
| if (error.Fail()) { |
| WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoAttachToProcessWithID encountered an " |
| "error occurred initiating the " |
| "asynchronous attach. %s", |
| error.AsCString()); |
| return error; |
| } |
| |
| HostProcess process; |
| error = WaitForDebuggerConnection(debugger, process); |
| if (error.Fail()) { |
| WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoAttachToProcessWithID encountered an " |
| "error waiting for the debugger to " |
| "connect. %s", |
| error.AsCString()); |
| return error; |
| } |
| |
| WINLOG_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoAttachToProcessWithID successfully attached to process with pid=%u", |
| process_id); |
| |
| // We've hit the initial stop. If eLaunchFlagsStopAtEntry was specified, the |
| // private state |
| // should already be set to eStateStopped as a result of hitting the initial |
| // breakpoint. If |
| // it was not set, the breakpoint should have already been resumed from and |
| // the private state |
| // should already be eStateRunning. |
| SetID(process.GetProcessId()); |
| return error; |
| } |
| |
| Error ProcessWindowsLive::WaitForDebuggerConnection(DebuggerThreadSP debugger, |
| HostProcess &process) { |
| Error result; |
| WINLOG_IFANY(WINDOWS_LOG_PROCESS | WINDOWS_LOG_BREAKPOINTS, |
| "WaitForDebuggerConnection Waiting for loader breakpoint."); |
| |
| // Block this function until we receive the initial stop from the process. |
| if (::WaitForSingleObject(m_session_data->m_initial_stop_event, INFINITE) == |
| WAIT_OBJECT_0) { |
| WINLOG_IFANY(WINDOWS_LOG_PROCESS | WINDOWS_LOG_BREAKPOINTS, |
| "WaitForDebuggerConnection hit loader breakpoint, returning."); |
| |
| process = debugger->GetProcess(); |
| return m_session_data->m_launch_error; |
| } else |
| return Error(::GetLastError(), eErrorTypeWin32); |
| } |
| |
| Error ProcessWindowsLive::DoResume() { |
| llvm::sys::ScopedLock lock(m_mutex); |
| Error error; |
| |
| StateType private_state = GetPrivateState(); |
| if (private_state == eStateStopped || private_state == eStateCrashed) { |
| WINLOG_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoResume called for process %I64u while state is %u. Resuming...", |
| m_session_data->m_debugger->GetProcess().GetProcessId(), |
| GetPrivateState()); |
| |
| ExceptionRecordSP active_exception = |
| m_session_data->m_debugger->GetActiveException().lock(); |
| if (active_exception) { |
| // Resume the process and continue processing debug events. Mask |
| // the exception so that from the process's view, there is no |
| // indication that anything happened. |
| m_session_data->m_debugger->ContinueAsyncException( |
| ExceptionResult::MaskException); |
| } |
| |
| WINLOG_IFANY(WINDOWS_LOG_PROCESS | WINDOWS_LOG_THREAD, |
| "DoResume resuming %u threads.", m_thread_list.GetSize()); |
| |
| for (int i = 0; i < m_thread_list.GetSize(); ++i) { |
| auto thread = std::static_pointer_cast<TargetThreadWindowsLive>( |
| m_thread_list.GetThreadAtIndex(i)); |
| thread->DoResume(); |
| } |
| |
| SetPrivateState(eStateRunning); |
| } else { |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoResume called for process %I64u but state is %u. Returning...", |
| m_session_data->m_debugger->GetProcess().GetProcessId(), |
| GetPrivateState()); |
| } |
| return error; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // ProcessInterface protocol. |
| |
| lldb_private::ConstString ProcessWindowsLive::GetPluginName() { |
| return GetPluginNameStatic(); |
| } |
| |
| uint32_t ProcessWindowsLive::GetPluginVersion() { return 1; } |
| |
| Error ProcessWindowsLive::DoDetach(bool keep_stopped) { |
| DebuggerThreadSP debugger_thread; |
| StateType private_state; |
| { |
| // Acquire the lock only long enough to get the DebuggerThread. |
| // StopDebugging() will trigger a call back into ProcessWindows which |
| // will also acquire the lock. Thus we have to release the lock before |
| // calling StopDebugging(). |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| private_state = GetPrivateState(); |
| |
| if (!m_session_data) { |
| WINWARN_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoDetach called while state = %u, but there is no active session.", |
| private_state); |
| return Error(); |
| } |
| |
| debugger_thread = m_session_data->m_debugger; |
| } |
| |
| Error error; |
| if (private_state != eStateExited && private_state != eStateDetached) { |
| WINLOG_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoDetach called for process %I64u while state = %u. Detaching...", |
| debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(), |
| private_state); |
| error = debugger_thread->StopDebugging(false); |
| if (error.Success()) { |
| SetPrivateState(eStateDetached); |
| } |
| |
| // By the time StopDebugging returns, there is no more debugger thread, so |
| // we can be assured that no other thread will race for the session data. |
| m_session_data.reset(); |
| } else { |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, "DoDetach called for process %I64u while state = " |
| "%u, but cannot destroy in this state.", |
| debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(), |
| private_state); |
| } |
| |
| return error; |
| } |
| |
| Error ProcessWindowsLive::DoDestroy() { |
| DebuggerThreadSP debugger_thread; |
| StateType private_state; |
| { |
| // Acquire this lock inside an inner scope, only long enough to get the |
| // DebuggerThread. |
| // StopDebugging() will trigger a call back into ProcessWindows which will |
| // acquire the lock |
| // again, so we need to not deadlock. |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| private_state = GetPrivateState(); |
| |
| if (!m_session_data) { |
| WINWARN_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoDestroy called while state = %u, but there is no active session.", |
| private_state); |
| return Error(); |
| } |
| |
| debugger_thread = m_session_data->m_debugger; |
| } |
| |
| Error error; |
| if (private_state != eStateExited && private_state != eStateDetached) { |
| WINLOG_IFALL( |
| WINDOWS_LOG_PROCESS, "DoDestroy called for process %I64u while state = " |
| "%u. Shutting down...", |
| debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(), |
| private_state); |
| error = debugger_thread->StopDebugging(true); |
| |
| // By the time StopDebugging returns, there is no more debugger thread, so |
| // we can be assured that no other thread will race for the session data. |
| m_session_data.reset(); |
| } else { |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, "DoDestroy called for process %I64u while state = " |
| "%u, but cannot destroy in this state.", |
| debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(), |
| private_state); |
| } |
| |
| return error; |
| } |
| |
| void ProcessWindowsLive::RefreshStateAfterStop() { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| if (!m_session_data) { |
| WINWARN_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "RefreshStateAfterStop called with no active session. Returning..."); |
| return; |
| } |
| |
| m_thread_list.RefreshStateAfterStop(); |
| |
| std::weak_ptr<ExceptionRecord> exception_record = |
| m_session_data->m_debugger->GetActiveException(); |
| ExceptionRecordSP active_exception = exception_record.lock(); |
| if (!active_exception) { |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "RefreshStateAfterStop called for process %I64u but there is no " |
| "active exception. Why is the process stopped?", |
| m_session_data->m_debugger->GetProcess().GetProcessId()); |
| return; |
| } |
| |
| StopInfoSP stop_info; |
| m_thread_list.SetSelectedThreadByID(active_exception->GetThreadID()); |
| ThreadSP stop_thread = m_thread_list.GetSelectedThread(); |
| if (!stop_thread) |
| return; |
| |
| switch (active_exception->GetExceptionCode()) { |
| case EXCEPTION_SINGLE_STEP: { |
| RegisterContextSP register_context = stop_thread->GetRegisterContext(); |
| const uint64_t pc = register_context->GetPC(); |
| BreakpointSiteSP site(GetBreakpointSiteList().FindByAddress(pc)); |
| if (site && site->ValidForThisThread(stop_thread.get())) { |
| WINLOG_IFANY(WINDOWS_LOG_BREAKPOINTS | WINDOWS_LOG_EXCEPTION | |
| WINDOWS_LOG_STEP, |
| "Single-stepped onto a breakpoint in process %I64u at " |
| "address 0x%I64x with breakpoint site %d", |
| m_session_data->m_debugger->GetProcess().GetProcessId(), pc, |
| site->GetID()); |
| stop_info = StopInfo::CreateStopReasonWithBreakpointSiteID(*stop_thread, |
| site->GetID()); |
| stop_thread->SetStopInfo(stop_info); |
| } else { |
| WINLOG_IFANY(WINDOWS_LOG_EXCEPTION | WINDOWS_LOG_STEP, |
| "RefreshStateAfterStop single stepping thread %u", |
| stop_thread->GetID()); |
| stop_info = StopInfo::CreateStopReasonToTrace(*stop_thread); |
| stop_thread->SetStopInfo(stop_info); |
| } |
| return; |
| } |
| |
| case EXCEPTION_BREAKPOINT: { |
| RegisterContextSP register_context = stop_thread->GetRegisterContext(); |
| |
| // The current EIP is AFTER the BP opcode, which is one byte. |
| uint64_t pc = register_context->GetPC() - 1; |
| |
| BreakpointSiteSP site(GetBreakpointSiteList().FindByAddress(pc)); |
| if (site) { |
| WINLOG_IFANY( |
| WINDOWS_LOG_BREAKPOINTS | WINDOWS_LOG_EXCEPTION, |
| "RefreshStateAfterStop detected breakpoint in process %I64u at " |
| "address 0x%I64x with breakpoint site %d", |
| m_session_data->m_debugger->GetProcess().GetProcessId(), pc, |
| site->GetID()); |
| |
| if (site->ValidForThisThread(stop_thread.get())) { |
| WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS | WINDOWS_LOG_EXCEPTION, |
| "Breakpoint site %d is valid for this thread (0x%I64x), " |
| "creating stop info.", |
| site->GetID(), stop_thread->GetID()); |
| |
| stop_info = StopInfo::CreateStopReasonWithBreakpointSiteID( |
| *stop_thread, site->GetID()); |
| register_context->SetPC(pc); |
| } else { |
| WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS | WINDOWS_LOG_EXCEPTION, |
| "Breakpoint site %d is not valid for this thread, " |
| "creating empty stop info.", |
| site->GetID()); |
| } |
| stop_thread->SetStopInfo(stop_info); |
| return; |
| } else { |
| // The thread hit a hard-coded breakpoint like an `int 3` or |
| // `__debugbreak()`. |
| WINLOG_IFALL( |
| WINDOWS_LOG_BREAKPOINTS | WINDOWS_LOG_EXCEPTION, |
| "No breakpoint site matches for this thread. __debugbreak()? " |
| "Creating stop info with the exception."); |
| // FALLTHROUGH: We'll treat this as a generic exception record in the |
| // default case. |
| } |
| } |
| |
| default: { |
| std::string desc; |
| llvm::raw_string_ostream desc_stream(desc); |
| desc_stream << "Exception " |
| << llvm::format_hex(active_exception->GetExceptionCode(), 8) |
| << " encountered at address " |
| << llvm::format_hex(active_exception->GetExceptionAddress(), 8); |
| stop_info = StopInfo::CreateStopReasonWithException( |
| *stop_thread, desc_stream.str().c_str()); |
| stop_thread->SetStopInfo(stop_info); |
| WINLOG_IFALL(WINDOWS_LOG_EXCEPTION, desc_stream.str().c_str()); |
| return; |
| } |
| } |
| } |
| |
| bool ProcessWindowsLive::IsAlive() { |
| StateType state = GetPrivateState(); |
| switch (state) { |
| case eStateCrashed: |
| case eStateDetached: |
| case eStateUnloaded: |
| case eStateExited: |
| case eStateInvalid: |
| return false; |
| default: |
| return true; |
| } |
| } |
| |
| Error ProcessWindowsLive::DoHalt(bool &caused_stop) { |
| Error error; |
| StateType state = GetPrivateState(); |
| if (state == eStateStopped) |
| caused_stop = false; |
| else { |
| llvm::sys::ScopedLock lock(m_mutex); |
| caused_stop = ::DebugBreakProcess(m_session_data->m_debugger->GetProcess() |
| .GetNativeProcess() |
| .GetSystemHandle()); |
| if (!caused_stop) { |
| error.SetError(::GetLastError(), eErrorTypeWin32); |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "DoHalt called DebugBreakProcess, but it failed with error %u", |
| error.GetError()); |
| } |
| } |
| return error; |
| } |
| |
| void ProcessWindowsLive::DidLaunch() { |
| ArchSpec arch_spec; |
| DidAttach(arch_spec); |
| } |
| |
| void ProcessWindowsLive::DidAttach(ArchSpec &arch_spec) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| // The initial stop won't broadcast the state change event, so account for |
| // that here. |
| if (m_session_data && GetPrivateState() == eStateStopped && |
| m_session_data->m_stop_at_entry) |
| RefreshStateAfterStop(); |
| } |
| |
| size_t ProcessWindowsLive::DoReadMemory(lldb::addr_t vm_addr, void *buf, |
| size_t size, Error &error) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| if (!m_session_data) |
| return 0; |
| |
| WINLOG_IFALL(WINDOWS_LOG_MEMORY, |
| "DoReadMemory attempting to read %u bytes from address 0x%I64x", |
| size, vm_addr); |
| |
| HostProcess process = m_session_data->m_debugger->GetProcess(); |
| void *addr = reinterpret_cast<void *>(vm_addr); |
| SIZE_T bytes_read = 0; |
| if (!ReadProcessMemory(process.GetNativeProcess().GetSystemHandle(), addr, |
| buf, size, &bytes_read)) { |
| error.SetError(GetLastError(), eErrorTypeWin32); |
| WINERR_IFALL(WINDOWS_LOG_MEMORY, "DoReadMemory failed with error code %u", |
| error.GetError()); |
| } |
| return bytes_read; |
| } |
| |
| size_t ProcessWindowsLive::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, |
| size_t size, Error &error) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| WINLOG_IFALL( |
| WINDOWS_LOG_MEMORY, |
| "DoWriteMemory attempting to write %u bytes into address 0x%I64x", size, |
| vm_addr); |
| |
| if (!m_session_data) { |
| WINERR_IFANY( |
| WINDOWS_LOG_MEMORY, |
| "DoWriteMemory cannot write, there is no active debugger connection."); |
| return 0; |
| } |
| |
| HostProcess process = m_session_data->m_debugger->GetProcess(); |
| void *addr = reinterpret_cast<void *>(vm_addr); |
| SIZE_T bytes_written = 0; |
| lldb::process_t handle = process.GetNativeProcess().GetSystemHandle(); |
| if (WriteProcessMemory(handle, addr, buf, size, &bytes_written)) |
| FlushInstructionCache(handle, addr, bytes_written); |
| else { |
| error.SetError(GetLastError(), eErrorTypeWin32); |
| WINLOG_IFALL(WINDOWS_LOG_MEMORY, "DoWriteMemory failed with error code %u", |
| error.GetError()); |
| } |
| return bytes_written; |
| } |
| |
| Error ProcessWindowsLive::GetMemoryRegionInfo(lldb::addr_t vm_addr, |
| MemoryRegionInfo &info) { |
| Error error; |
| llvm::sys::ScopedLock lock(m_mutex); |
| info.Clear(); |
| |
| if (!m_session_data) { |
| error.SetErrorString( |
| "GetMemoryRegionInfo called with no debugging session."); |
| WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString()); |
| return error; |
| } |
| HostProcess process = m_session_data->m_debugger->GetProcess(); |
| lldb::process_t handle = process.GetNativeProcess().GetSystemHandle(); |
| if (handle == nullptr || handle == LLDB_INVALID_PROCESS) { |
| error.SetErrorString( |
| "GetMemoryRegionInfo called with an invalid target process."); |
| WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString()); |
| return error; |
| } |
| |
| WINLOG_IFALL(WINDOWS_LOG_MEMORY, |
| "GetMemoryRegionInfo getting info for address 0x%I64x", vm_addr); |
| |
| void *addr = reinterpret_cast<void *>(vm_addr); |
| MEMORY_BASIC_INFORMATION mem_info = {0}; |
| SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info)); |
| if (result == 0) { |
| if (::GetLastError() == ERROR_INVALID_PARAMETER) { |
| // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with an |
| // address |
| // past the highest accessible address. We should return a range from the |
| // vm_addr |
| // to LLDB_INVALID_ADDRESS |
| info.GetRange().SetRangeBase(vm_addr); |
| info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS); |
| info.SetReadable(MemoryRegionInfo::eNo); |
| info.SetExecutable(MemoryRegionInfo::eNo); |
| info.SetWritable(MemoryRegionInfo::eNo); |
| info.SetMapped(MemoryRegionInfo::eNo); |
| return error; |
| } else { |
| error.SetError(::GetLastError(), eErrorTypeWin32); |
| WINERR_IFALL(WINDOWS_LOG_MEMORY, "VirtualQueryEx returned error %u while " |
| "getting memory region info for address " |
| "0x%I64x", |
| error.GetError(), vm_addr); |
| return error; |
| } |
| } |
| |
| // Protect bits are only valid for MEM_COMMIT regions. |
| if (mem_info.State == MEM_COMMIT) { |
| const bool readable = IsPageReadable(mem_info.Protect); |
| const bool executable = IsPageExecutable(mem_info.Protect); |
| const bool writable = IsPageWritable(mem_info.Protect); |
| info.SetReadable(readable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo); |
| info.SetExecutable(executable ? MemoryRegionInfo::eYes |
| : MemoryRegionInfo::eNo); |
| info.SetWritable(writable ? MemoryRegionInfo::eYes : MemoryRegionInfo::eNo); |
| } else { |
| info.SetReadable(MemoryRegionInfo::eNo); |
| info.SetExecutable(MemoryRegionInfo::eNo); |
| info.SetWritable(MemoryRegionInfo::eNo); |
| } |
| |
| // AllocationBase is defined for MEM_COMMIT and MEM_RESERVE but not MEM_FREE. |
| if (mem_info.State != MEM_FREE) { |
| info.GetRange().SetRangeBase( |
| reinterpret_cast<addr_t>(mem_info.AllocationBase)); |
| info.GetRange().SetRangeEnd(reinterpret_cast<addr_t>(mem_info.BaseAddress) + |
| mem_info.RegionSize); |
| info.SetMapped(MemoryRegionInfo::eYes); |
| } else { |
| // In the unmapped case we need to return the distance to the next block of |
| // memory. |
| // VirtualQueryEx nearly does that except that it gives the distance from |
| // the start |
| // of the page containing vm_addr. |
| SYSTEM_INFO data; |
| GetSystemInfo(&data); |
| DWORD page_offset = vm_addr % data.dwPageSize; |
| info.GetRange().SetRangeBase(vm_addr); |
| info.GetRange().SetByteSize(mem_info.RegionSize - page_offset); |
| info.SetMapped(MemoryRegionInfo::eNo); |
| } |
| |
| error.SetError(::GetLastError(), eErrorTypeWin32); |
| WINLOGV_IFALL(WINDOWS_LOG_MEMORY, "Memory region info for address 0x%I64u: " |
| "readable=%s, executable=%s, writable=%s", |
| BOOL_STR(info.GetReadable()), BOOL_STR(info.GetExecutable()), |
| BOOL_STR(info.GetWritable())); |
| return error; |
| } |
| |
| bool ProcessWindowsLive::CanDebug(lldb::TargetSP target_sp, |
| bool plugin_specified_by_name) { |
| if (plugin_specified_by_name) |
| return true; |
| |
| // For now we are just making sure the file exists for a given module |
| ModuleSP exe_module_sp(target_sp->GetExecutableModule()); |
| if (exe_module_sp.get()) |
| return exe_module_sp->GetFileSpec().Exists(); |
| // However, if there is no executable module, we return true since we might be |
| // preparing to attach. |
| return true; |
| } |
| |
| void ProcessWindowsLive::OnExitProcess(uint32_t exit_code) { |
| // No need to acquire the lock since m_session_data isn't accessed. |
| WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Process %u exited with code %u", GetID(), |
| exit_code); |
| |
| TargetSP target = m_target_sp.lock(); |
| if (target) { |
| ModuleSP executable_module = target->GetExecutableModule(); |
| ModuleList unloaded_modules; |
| unloaded_modules.Append(executable_module); |
| target->ModulesDidUnload(unloaded_modules, true); |
| } |
| |
| SetProcessExitStatus(GetID(), true, 0, exit_code); |
| SetPrivateState(eStateExited); |
| } |
| |
| void ProcessWindowsLive::OnDebuggerConnected(lldb::addr_t image_base) { |
| DebuggerThreadSP debugger = m_session_data->m_debugger; |
| |
| WINLOG_IFALL(WINDOWS_LOG_PROCESS, |
| "Debugger connected to process %I64u. Image base = 0x%I64x", |
| debugger->GetProcess().GetProcessId(), image_base); |
| |
| ModuleSP module = GetTarget().GetExecutableModule(); |
| if (!module) { |
| // During attach, we won't have the executable module, so find it now. |
| const DWORD pid = debugger->GetProcess().GetProcessId(); |
| const std::string file_name = GetProcessExecutableName(pid); |
| if (file_name.empty()) { |
| return; |
| } |
| |
| FileSpec executable_file(file_name, true); |
| ModuleSpec module_spec(executable_file); |
| Error error; |
| module = GetTarget().GetSharedModule(module_spec, &error); |
| if (!module) { |
| return; |
| } |
| |
| GetTarget().SetExecutableModule(module, false); |
| } |
| |
| bool load_addr_changed; |
| module->SetLoadAddress(GetTarget(), image_base, false, load_addr_changed); |
| |
| ModuleList loaded_modules; |
| loaded_modules.Append(module); |
| GetTarget().ModulesDidLoad(loaded_modules); |
| |
| // Add the main executable module to the list of pending module loads. We |
| // can't call |
| // GetTarget().ModulesDidLoad() here because we still haven't returned from |
| // DoLaunch() / DoAttach() yet |
| // so the target may not have set the process instance to `this` yet. |
| llvm::sys::ScopedLock lock(m_mutex); |
| const HostThreadWindows &wmain_thread = |
| debugger->GetMainThread().GetNativeThread(); |
| m_session_data->m_new_threads[wmain_thread.GetThreadId()] = |
| debugger->GetMainThread(); |
| } |
| |
| ExceptionResult |
| ProcessWindowsLive::OnDebugException(bool first_chance, |
| const ExceptionRecord &record) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| // FIXME: Without this check, occasionally when running the test suite there |
| // is |
| // an issue where m_session_data can be null. It's not clear how this could |
| // happen |
| // but it only surfaces while running the test suite. In order to properly |
| // diagnose |
| // this, we probably need to first figure allow the test suite to print out |
| // full |
| // lldb logs, and then add logging to the process plugin. |
| if (!m_session_data) { |
| WINERR_IFANY(WINDOWS_LOG_EXCEPTION, "Debugger thread reported exception " |
| "0x%x at address 0x%I64x, but there is " |
| "no session.", |
| record.GetExceptionCode(), record.GetExceptionAddress()); |
| return ExceptionResult::SendToApplication; |
| } |
| |
| if (!first_chance) { |
| // Any second chance exception is an application crash by definition. |
| SetPrivateState(eStateCrashed); |
| } |
| |
| ExceptionResult result = ExceptionResult::SendToApplication; |
| switch (record.GetExceptionCode()) { |
| case EXCEPTION_BREAKPOINT: |
| // Handle breakpoints at the first chance. |
| result = ExceptionResult::BreakInDebugger; |
| |
| if (!m_session_data->m_initial_stop_received) { |
| WINLOG_IFANY(WINDOWS_LOG_BREAKPOINTS, "Hit loader breakpoint at address " |
| "0x%I64x, setting initial stop " |
| "event.", |
| record.GetExceptionAddress()); |
| m_session_data->m_initial_stop_received = true; |
| ::SetEvent(m_session_data->m_initial_stop_event); |
| } else { |
| WINLOG_IFANY(WINDOWS_LOG_BREAKPOINTS, |
| "Hit non-loader breakpoint at address 0x%I64x.", |
| record.GetExceptionAddress()); |
| } |
| SetPrivateState(eStateStopped); |
| break; |
| case EXCEPTION_SINGLE_STEP: |
| result = ExceptionResult::BreakInDebugger; |
| SetPrivateState(eStateStopped); |
| break; |
| default: |
| WINLOG_IFANY(WINDOWS_LOG_EXCEPTION, "Debugger thread reported exception " |
| "0x%x at address 0x%I64x " |
| "(first_chance=%s)", |
| record.GetExceptionCode(), record.GetExceptionAddress(), |
| BOOL_STR(first_chance)); |
| // For non-breakpoints, give the application a chance to handle the |
| // exception first. |
| if (first_chance) |
| result = ExceptionResult::SendToApplication; |
| else |
| result = ExceptionResult::BreakInDebugger; |
| } |
| |
| return result; |
| } |
| |
| void ProcessWindowsLive::OnCreateThread(const HostThread &new_thread) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| const HostThreadWindows &wnew_thread = new_thread.GetNativeThread(); |
| m_session_data->m_new_threads[wnew_thread.GetThreadId()] = new_thread; |
| } |
| |
| void ProcessWindowsLive::OnExitThread(lldb::tid_t thread_id, |
| uint32_t exit_code) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| // On a forced termination, we may get exit thread events after the session |
| // data has been cleaned up. |
| if (!m_session_data) |
| return; |
| |
| // A thread may have started and exited before the debugger stopped allowing a |
| // refresh. |
| // Just remove it from the new threads list in that case. |
| auto iter = m_session_data->m_new_threads.find(thread_id); |
| if (iter != m_session_data->m_new_threads.end()) |
| m_session_data->m_new_threads.erase(iter); |
| else |
| m_session_data->m_exited_threads.insert(thread_id); |
| } |
| |
| void ProcessWindowsLive::OnLoadDll(const ModuleSpec &module_spec, |
| lldb::addr_t module_addr) { |
| // Confusingly, there is no Target::AddSharedModule. Instead, calling |
| // GetSharedModule() with |
| // a new module will add it to the module list and return a corresponding |
| // ModuleSP. |
| Error error; |
| ModuleSP module = GetTarget().GetSharedModule(module_spec, &error); |
| bool load_addr_changed = false; |
| module->SetLoadAddress(GetTarget(), module_addr, false, load_addr_changed); |
| |
| ModuleList loaded_modules; |
| loaded_modules.Append(module); |
| GetTarget().ModulesDidLoad(loaded_modules); |
| } |
| |
| void ProcessWindowsLive::OnUnloadDll(lldb::addr_t module_addr) { |
| Address resolved_addr; |
| if (GetTarget().ResolveLoadAddress(module_addr, resolved_addr)) { |
| ModuleSP module = resolved_addr.GetModule(); |
| if (module) { |
| ModuleList unloaded_modules; |
| unloaded_modules.Append(module); |
| GetTarget().ModulesDidUnload(unloaded_modules, false); |
| } |
| } |
| } |
| |
| void ProcessWindowsLive::OnDebugString(const std::string &string) {} |
| |
| void ProcessWindowsLive::OnDebuggerError(const Error &error, uint32_t type) { |
| llvm::sys::ScopedLock lock(m_mutex); |
| |
| if (m_session_data->m_initial_stop_received) { |
| // This happened while debugging. Do we shutdown the debugging session, try |
| // to continue, |
| // or do something else? |
| WINERR_IFALL(WINDOWS_LOG_PROCESS, "Error %u occurred during debugging. " |
| "Unexpected behavior may result. %s", |
| error.GetError(), error.AsCString()); |
| } else { |
| // If we haven't actually launched the process yet, this was an error |
| // launching the |
| // process. Set the internal error and signal the initial stop event so |
| // that the DoLaunch |
| // method wakes up and returns a failure. |
| m_session_data->m_launch_error = error; |
| ::SetEvent(m_session_data->m_initial_stop_event); |
| WINERR_IFALL( |
| WINDOWS_LOG_PROCESS, |
| "Error %u occurred launching the process before the initial stop. %s", |
| error.GetError(), error.AsCString()); |
| return; |
| } |
| } |