| //===-- NativeProcessProtocol.cpp -------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "NativeProcessProtocol.h" |
| |
| #include "lldb/lldb-enumerations.h" |
| #include "lldb/Core/ArchSpec.h" |
| #include "lldb/Core/Log.h" |
| #include "lldb/Core/State.h" |
| #include "lldb/Target/NativeRegisterContext.h" |
| |
| #include "NativeThreadProtocol.h" |
| #include "SoftwareBreakpoint.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| // ----------------------------------------------------------------------------- |
| // NativeProcessProtocol Members |
| // ----------------------------------------------------------------------------- |
| |
| NativeProcessProtocol::NativeProcessProtocol (lldb::pid_t pid) : |
| m_pid (pid), |
| m_threads (), |
| m_current_thread_id (LLDB_INVALID_THREAD_ID), |
| m_threads_mutex (Mutex::eMutexTypeRecursive), |
| m_state (lldb::eStateInvalid), |
| m_state_mutex (Mutex::eMutexTypeRecursive), |
| m_exit_type (eExitTypeInvalid), |
| m_exit_status (0), |
| m_exit_description (), |
| m_delegates_mutex (Mutex::eMutexTypeRecursive), |
| m_delegates (), |
| m_breakpoint_list (), |
| m_terminal_fd (-1), |
| m_stop_id (0) |
| { |
| } |
| |
| lldb_private::Error |
| NativeProcessProtocol::GetMemoryRegionInfo (lldb::addr_t load_addr, MemoryRegionInfo &range_info) |
| { |
| // Default: not implemented. |
| return Error ("not implemented"); |
| } |
| |
| bool |
| NativeProcessProtocol::GetExitStatus (ExitType *exit_type, int *status, std::string &exit_description) |
| { |
| if (m_state == lldb::eStateExited) |
| { |
| *exit_type = m_exit_type; |
| *status = m_exit_status; |
| exit_description = m_exit_description; |
| return true; |
| } |
| |
| *status = 0; |
| return false; |
| } |
| |
| bool |
| NativeProcessProtocol::SetExitStatus (ExitType exit_type, int status, const char *exit_description, bool bNotifyStateChange) |
| { |
| Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); |
| if (log) |
| log->Printf ("NativeProcessProtocol::%s(%d, %d, %s, %s) called", |
| __FUNCTION__, |
| exit_type, |
| status, |
| exit_description ? exit_description : "nullptr", |
| bNotifyStateChange ? "true" : "false"); |
| |
| // Exit status already set |
| if (m_state == lldb::eStateExited) |
| { |
| if (log) |
| log->Printf ("NativeProcessProtocol::%s exit status already set to %d, ignoring new set to %d", __FUNCTION__, m_exit_status, status); |
| return false; |
| } |
| |
| m_state = lldb::eStateExited; |
| |
| m_exit_type = exit_type; |
| m_exit_status = status; |
| if (exit_description && exit_description[0]) |
| m_exit_description = exit_description; |
| else |
| m_exit_description.clear(); |
| |
| if (bNotifyStateChange) |
| SynchronouslyNotifyProcessStateChanged (lldb::eStateExited); |
| |
| return true; |
| } |
| |
| NativeThreadProtocolSP |
| NativeProcessProtocol::GetThreadAtIndex (uint32_t idx) |
| { |
| Mutex::Locker locker (m_threads_mutex); |
| if (idx < m_threads.size ()) |
| return m_threads[idx]; |
| return NativeThreadProtocolSP (); |
| } |
| |
| NativeThreadProtocolSP |
| NativeProcessProtocol::GetThreadByID (lldb::tid_t tid) |
| { |
| Mutex::Locker locker (m_threads_mutex); |
| for (auto thread_sp : m_threads) |
| { |
| if (thread_sp->GetID() == tid) |
| return thread_sp; |
| } |
| return NativeThreadProtocolSP (); |
| } |
| |
| bool |
| NativeProcessProtocol::IsAlive () const |
| { |
| return m_state != eStateDetached |
| && m_state != eStateExited |
| && m_state != eStateInvalid |
| && m_state != eStateUnloaded; |
| } |
| |
| bool |
| NativeProcessProtocol::GetByteOrder (lldb::ByteOrder &byte_order) const |
| { |
| ArchSpec process_arch; |
| if (!GetArchitecture (process_arch)) |
| return false; |
| byte_order = process_arch.GetByteOrder (); |
| return true; |
| } |
| |
| uint32_t |
| NativeProcessProtocol::GetMaxWatchpoints () const |
| { |
| // This default implementation will return the number of |
| // *hardware* breakpoints available. MacOSX and other OS |
| // implementations that support software breakpoints will want to |
| // override this correctly for their implementation. |
| Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); |
| |
| // get any thread |
| NativeThreadProtocolSP thread_sp (const_cast<NativeProcessProtocol*> (this)->GetThreadAtIndex (0)); |
| if (!thread_sp) |
| { |
| if (log) |
| log->Warning ("NativeProcessProtocol::%s (): failed to find a thread to grab a NativeRegisterContext!", __FUNCTION__); |
| return 0; |
| } |
| |
| NativeRegisterContextSP reg_ctx_sp (thread_sp->GetRegisterContext ()); |
| if (!reg_ctx_sp) |
| { |
| if (log) |
| log->Warning ("NativeProcessProtocol::%s (): failed to get a RegisterContextNativeProcess from the first thread!", __FUNCTION__); |
| return 0; |
| } |
| |
| return reg_ctx_sp->NumSupportedHardwareWatchpoints (); |
| } |
| |
| Error |
| NativeProcessProtocol::SetWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware) |
| { |
| // This default implementation assumes setting the watchpoint for |
| // the process will require setting the watchpoint for each of the |
| // threads. Furthermore, it will track watchpoints set for the |
| // process and will add them to each thread that is attached to |
| // via the (FIXME implement) OnThreadAttached () method. |
| |
| Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); |
| |
| // FIXME save the watchpoint on the set of process watchpoint vars |
| // so we can add them to a thread each time a new thread is registered. |
| |
| // Update the thread list |
| UpdateThreads (); |
| |
| // Keep track of the threads we successfully set the watchpoint |
| // for. If one of the thread watchpoint setting operations fails, |
| // back off and remove the watchpoint for all the threads that |
| // were successfully set so we get back to a consistent state. |
| std::vector<NativeThreadProtocolSP> watchpoint_established_threads; |
| |
| // Tell each thread to set a watchpoint. In the event that |
| // hardware watchpoints are requested but the SetWatchpoint fails, |
| // try to set a software watchpoint as a fallback. It's |
| // conceivable that if there are more threads than hardware |
| // watchpoints available, some of the threads will fail to set |
| // hardware watchpoints while software ones may be available. |
| Mutex::Locker locker (m_threads_mutex); |
| for (auto thread_sp : m_threads) |
| { |
| assert (thread_sp && "thread list should not have a NULL thread!"); |
| if (!thread_sp) |
| continue; |
| |
| Error thread_error = thread_sp->SetWatchpoint (addr, size, watch_flags, hardware); |
| if (thread_error.Fail () && hardware) |
| { |
| // Try software watchpoints since we failed on hardware watchpoint setting |
| // and we may have just run out of hardware watchpoints. |
| thread_error = thread_sp->SetWatchpoint (addr, size, watch_flags, false); |
| if (thread_error.Success ()) |
| { |
| if (log) |
| log->Warning ("hardware watchpoint requested but software watchpoint set"); |
| } |
| } |
| |
| if (thread_error.Success ()) |
| { |
| // Remember that we set this watchpoint successfully in |
| // case we need to clear it later. |
| watchpoint_established_threads.push_back (thread_sp); |
| } |
| else |
| { |
| // Unset the watchpoint for each thread we successfully |
| // set so that we get back to a consistent state of "not |
| // set" for the watchpoint. |
| for (auto unwatch_thread_sp : watchpoint_established_threads) |
| { |
| Error remove_error = unwatch_thread_sp->RemoveWatchpoint (addr); |
| if (remove_error.Fail () && log) |
| { |
| log->Warning ("NativeProcessProtocol::%s (): RemoveWatchpoint failed for pid=%" PRIu64 ", tid=%" PRIu64 ": %s", |
| __FUNCTION__, GetID (), unwatch_thread_sp->GetID (), remove_error.AsCString ()); |
| } |
| } |
| |
| return thread_error; |
| } |
| } |
| return Error (); |
| } |
| |
| Error |
| NativeProcessProtocol::RemoveWatchpoint (lldb::addr_t addr) |
| { |
| // FIXME remove the watchpoint on the set of process watchpoint vars |
| // so we can add them to a thread each time a new thread is registered. |
| |
| // Update the thread list |
| UpdateThreads (); |
| |
| Error overall_error; |
| |
| Mutex::Locker locker (m_threads_mutex); |
| for (auto thread_sp : m_threads) |
| { |
| assert (thread_sp && "thread list should not have a NULL thread!"); |
| if (!thread_sp) |
| continue; |
| |
| const Error thread_error = thread_sp->RemoveWatchpoint (addr); |
| if (thread_error.Fail ()) |
| { |
| // Keep track of the first thread error if any threads |
| // fail. We want to try to remove the watchpoint from |
| // every thread, though, even if one or more have errors. |
| if (!overall_error.Fail ()) |
| overall_error = thread_error; |
| } |
| } |
| return overall_error; |
| } |
| |
| bool |
| NativeProcessProtocol::RegisterNativeDelegate (NativeDelegate &native_delegate) |
| { |
| Mutex::Locker locker (m_delegates_mutex); |
| if (std::find (m_delegates.begin (), m_delegates.end (), &native_delegate) != m_delegates.end ()) |
| return false; |
| |
| m_delegates.push_back (&native_delegate); |
| native_delegate.InitializeDelegate (this); |
| return true; |
| } |
| |
| bool |
| NativeProcessProtocol::UnregisterNativeDelegate (NativeDelegate &native_delegate) |
| { |
| Mutex::Locker locker (m_delegates_mutex); |
| |
| const auto initial_size = m_delegates.size (); |
| m_delegates.erase (remove (m_delegates.begin (), m_delegates.end (), &native_delegate), m_delegates.end ()); |
| |
| // We removed the delegate if the count of delegates shrank after |
| // removing all copies of the given native_delegate from the vector. |
| return m_delegates.size () < initial_size; |
| } |
| |
| void |
| NativeProcessProtocol::SynchronouslyNotifyProcessStateChanged (lldb::StateType state) |
| { |
| Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); |
| |
| Mutex::Locker locker (m_delegates_mutex); |
| for (auto native_delegate: m_delegates) |
| native_delegate->ProcessStateChanged (this, state); |
| |
| if (log) |
| { |
| if (!m_delegates.empty ()) |
| { |
| log->Printf ("NativeProcessProtocol::%s: sent state notification [%s] from process %" PRIu64, |
| __FUNCTION__, lldb_private::StateAsCString (state), GetID ()); |
| } |
| else |
| { |
| log->Printf ("NativeProcessProtocol::%s: would send state notification [%s] from process %" PRIu64 ", but no delegates", |
| __FUNCTION__, lldb_private::StateAsCString (state), GetID ()); |
| } |
| } |
| } |
| |
| Error |
| NativeProcessProtocol::SetSoftwareBreakpoint (lldb::addr_t addr, uint32_t size_hint) |
| { |
| Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); |
| if (log) |
| log->Printf ("NativeProcessProtocol::%s addr = 0x%" PRIx64, __FUNCTION__, addr); |
| |
| return m_breakpoint_list.AddRef (addr, size_hint, false, |
| [this] (lldb::addr_t addr, size_t size_hint, bool /* hardware */, NativeBreakpointSP &breakpoint_sp)->Error |
| { return SoftwareBreakpoint::CreateSoftwareBreakpoint (*this, addr, size_hint, breakpoint_sp); }); |
| } |
| |
| Error |
| NativeProcessProtocol::RemoveBreakpoint (lldb::addr_t addr) |
| { |
| return m_breakpoint_list.DecRef (addr); |
| } |
| |
| Error |
| NativeProcessProtocol::EnableBreakpoint (lldb::addr_t addr) |
| { |
| return m_breakpoint_list.EnableBreakpoint (addr); |
| } |
| |
| Error |
| NativeProcessProtocol::DisableBreakpoint (lldb::addr_t addr) |
| { |
| return m_breakpoint_list.DisableBreakpoint (addr); |
| } |
| |
| lldb::StateType |
| NativeProcessProtocol::GetState () const |
| { |
| Mutex::Locker locker (m_state_mutex); |
| return m_state; |
| } |
| |
| void |
| NativeProcessProtocol::SetState (lldb::StateType state, bool notify_delegates) |
| { |
| Mutex::Locker locker (m_state_mutex); |
| m_state = state; |
| |
| if (StateIsStoppedState (state, false)) |
| { |
| ++m_stop_id; |
| |
| // Give process a chance to do any stop id bump processing, such as |
| // clearing cached data that is invalidated each time the process runs. |
| // Note if/when we support some threads running, we'll end up needing |
| // to manage this per thread and per process. |
| DoStopIDBumped (m_stop_id); |
| } |
| |
| // Optionally notify delegates of the state change. |
| if (notify_delegates) |
| SynchronouslyNotifyProcessStateChanged (state); |
| } |
| |
| uint32_t NativeProcessProtocol::GetStopID () const |
| { |
| Mutex::Locker locker (m_state_mutex); |
| return m_stop_id; |
| } |
| |
| void |
| NativeProcessProtocol::DoStopIDBumped (uint32_t /* newBumpId */) |
| { |
| // Default implementation does nothing. |
| } |