diff options
Diffstat (limited to 'source/Plugins/Process/Darwin/NativeThreadDarwin.cpp')
| -rw-r--r-- | source/Plugins/Process/Darwin/NativeThreadDarwin.cpp | 284 |
1 files changed, 284 insertions, 0 deletions
diff --git a/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp b/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp new file mode 100644 index 0000000000000..5e7f9ae7e6f95 --- /dev/null +++ b/source/Plugins/Process/Darwin/NativeThreadDarwin.cpp @@ -0,0 +1,284 @@ +//===-- NativeThreadDarwin.cpp -------------------------------- -*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "NativeThreadDarwin.h" + +// C includes +#include <libproc.h> + +// LLDB includes +#include "lldb/Core/Stream.h" + +#include "NativeProcessDarwin.h" + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::process_darwin; + +uint64_t NativeThreadDarwin::GetGloballyUniqueThreadIDForMachPortID( + ::thread_t mach_port_id) { + thread_identifier_info_data_t tident; + mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT; + + auto mach_err = ::thread_info(mach_port_id, THREAD_IDENTIFIER_INFO, + (thread_info_t)&tident, &tident_count); + if (mach_err != KERN_SUCCESS) { + // When we fail to get thread info for the supposed port, assume it is + // really a globally unique thread id already, or return the best thing + // we can, which is the thread port. + return mach_port_id; + } + return tident.thread_id; +} + +NativeThreadDarwin::NativeThreadDarwin(NativeProcessDarwin *process, + bool is_64_bit, + lldb::tid_t unique_thread_id, + ::thread_t mach_thread_port) + : NativeThreadProtocol(process, unique_thread_id), + m_mach_thread_port(mach_thread_port), m_basic_info(), + m_proc_threadinfo() {} + +bool NativeThreadDarwin::GetIdentifierInfo() { + // Don't try to get the thread info once and cache it for the life of the + // thread. It changes over time, for instance + // if the thread name changes, then the thread_handle also changes... So you + // have to refetch it every time. + mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT; + kern_return_t kret = ::thread_info(m_mach_thread_port, THREAD_IDENTIFIER_INFO, + (thread_info_t)&m_ident_info, &count); + return kret == KERN_SUCCESS; + + return false; +} + +std::string NativeThreadDarwin::GetName() { + std::string name; + + if (GetIdentifierInfo()) { + auto process_sp = GetProcess(); + if (!process_sp) { + name = "<unavailable>"; + return name; + } + + int len = ::proc_pidinfo(process_sp->GetID(), PROC_PIDTHREADINFO, + m_ident_info.thread_handle, &m_proc_threadinfo, + sizeof(m_proc_threadinfo)); + + if (len && m_proc_threadinfo.pth_name[0]) + name = m_proc_threadinfo.pth_name; + } + return name; +} + +lldb::StateType NativeThreadDarwin::GetState() { + // TODO implement + return eStateInvalid; +} + +bool NativeThreadDarwin::GetStopReason(ThreadStopInfo &stop_info, + std::string &description) { + // TODO implement + return false; +} + +NativeRegisterContextSP NativeThreadDarwin::GetRegisterContext() { + // TODO implement + return NativeRegisterContextSP(); +} + +Error NativeThreadDarwin::SetWatchpoint(lldb::addr_t addr, size_t size, + uint32_t watch_flags, bool hardware) { + Error error; + error.SetErrorString("not yet implemented"); + return error; +} + +Error NativeThreadDarwin::RemoveWatchpoint(lldb::addr_t addr) { + Error error; + error.SetErrorString("not yet implemented"); + return error; +} + +void NativeThreadDarwin::Dump(Stream &stream) const { +// This is what we really want once we have the thread class wired up. +#if 0 + DNBLogThreaded("[%3u] #%3u tid: 0x%8.8" PRIx64 ", pc: 0x%16.16" PRIx64 ", sp: 0x%16.16" PRIx64 ", user: %d.%6.6d, system: %d.%6.6d, cpu: %2d, policy: %2d, run_state: %2d (%s), flags: %2d, suspend_count: %2d (current %2d), sleep_time: %d", + index, + m_seq_id, + m_unique_id, + GetPC(INVALID_NUB_ADDRESS), + GetSP(INVALID_NUB_ADDRESS), + m_basic_info.user_time.seconds, m_basic_info.user_time.microseconds, + m_basic_info.system_time.seconds, m_basic_info.system_time.microseconds, + m_basic_info.cpu_usage, + m_basic_info.policy, + m_basic_info.run_state, + thread_run_state, + m_basic_info.flags, + m_basic_info.suspend_count, m_suspend_count, + m_basic_info.sleep_time); + +#else + // Here's all we have right now. + stream.Printf("tid: 0x%8.8" PRIx64 ", thread port: 0x%4.4x", GetID(), + m_mach_thread_port); +#endif +} + +bool NativeThreadDarwin::NotifyException(MachException::Data &exc) { +// TODO implement this. +#if 0 + // Allow the arch specific protocol to process (MachException::Data &)exc + // first before possible reassignment of m_stop_exception with exc. + // See also MachThread::GetStopException(). + bool handled = m_arch_ap->NotifyException(exc); + + if (m_stop_exception.IsValid()) + { + // We may have more than one exception for a thread, but we need to + // only remember the one that we will say is the reason we stopped. + // We may have been single stepping and also gotten a signal exception, + // so just remember the most pertinent one. + if (m_stop_exception.IsBreakpoint()) + m_stop_exception = exc; + } + else + { + m_stop_exception = exc; + } + + return handled; +#else + // Pretend we handled it. + return true; +#endif +} + +bool NativeThreadDarwin::ShouldStop(bool &step_more) const { +// TODO: implement this +#if 0 + // See if this thread is at a breakpoint? + DNBBreakpoint *bp = CurrentBreakpoint(); + + if (bp) + { + // This thread is sitting at a breakpoint, ask the breakpoint + // if we should be stopping here. + return true; + } + else + { + if (m_arch_ap->StepNotComplete()) + { + step_more = true; + return false; + } + // The thread state is used to let us know what the thread was + // trying to do. MachThread::ThreadWillResume() will set the + // thread state to various values depending if the thread was + // the current thread and if it was to be single stepped, or + // resumed. + if (GetState() == eStateRunning) + { + // If our state is running, then we should continue as we are in + // the process of stepping over a breakpoint. + return false; + } + else + { + // Stop if we have any kind of valid exception for this + // thread. + if (GetStopException().IsValid()) + return true; + } + } + return false; +#else + return false; +#endif +} + +void NativeThreadDarwin::ThreadDidStop() { +// TODO implement this. +#if 0 + // This thread has existed prior to resuming under debug nub control, + // and has just been stopped. Do any cleanup that needs to be done + // after running. + + // The thread state and breakpoint will still have the same values + // as they had prior to resuming the thread, so it makes it easy to check + // if we were trying to step a thread, or we tried to resume while being + // at a breakpoint. + + // When this method gets called, the process state is still in the + // state it was in while running so we can act accordingly. + m_arch_ap->ThreadDidStop(); + + + // We may have suspended this thread so the primary thread could step + // without worrying about race conditions, so lets restore our suspend + // count. + RestoreSuspendCountAfterStop(); + + // Update the basic information for a thread + MachThread::GetBasicInfo(m_mach_port_number, &m_basic_info); + + if (m_basic_info.suspend_count > 0) + SetState(eStateSuspended); + else + SetState(eStateStopped); +#endif +} + +bool NativeThreadDarwin::MachPortNumberIsValid(::thread_t thread) { + return thread != (::thread_t)(0); +} + +const struct thread_basic_info *NativeThreadDarwin::GetBasicInfo() const { + if (GetBasicInfo(m_mach_thread_port, &m_basic_info)) + return &m_basic_info; + return NULL; +} + +bool NativeThreadDarwin::GetBasicInfo(::thread_t thread, + struct thread_basic_info *basicInfoPtr) { + if (MachPortNumberIsValid(thread)) { + unsigned int info_count = THREAD_BASIC_INFO_COUNT; + kern_return_t err = ::thread_info(thread, THREAD_BASIC_INFO, + (thread_info_t)basicInfoPtr, &info_count); + if (err == KERN_SUCCESS) + return true; + } + ::memset(basicInfoPtr, 0, sizeof(struct thread_basic_info)); + return false; +} + +bool NativeThreadDarwin::IsUserReady() const { + if (m_basic_info.run_state == 0) + GetBasicInfo(); + + switch (m_basic_info.run_state) { + default: + case TH_STATE_UNINTERRUPTIBLE: + break; + + case TH_STATE_RUNNING: + case TH_STATE_STOPPED: + case TH_STATE_WAITING: + case TH_STATE_HALTED: + return true; + } + return false; +} + +NativeProcessDarwinSP NativeThreadDarwin::GetNativeProcessDarwinSP() { + return std::static_pointer_cast<NativeProcessDarwin>(GetProcess()); +} |