diff options
Diffstat (limited to 'tools/debugserver/source/MacOSX/MachThread.cpp')
| -rw-r--r-- | tools/debugserver/source/MacOSX/MachThread.cpp | 783 |
1 files changed, 0 insertions, 783 deletions
diff --git a/tools/debugserver/source/MacOSX/MachThread.cpp b/tools/debugserver/source/MacOSX/MachThread.cpp deleted file mode 100644 index 062e1c3d9edf..000000000000 --- a/tools/debugserver/source/MacOSX/MachThread.cpp +++ /dev/null @@ -1,783 +0,0 @@ -//===-- MachThread.cpp ------------------------------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// Created by Greg Clayton on 6/19/07. -// -//===----------------------------------------------------------------------===// - -#include "MachThread.h" -#include "DNB.h" -#include "DNBLog.h" -#include "MachProcess.h" -#include "ThreadInfo.h" -#include <dlfcn.h> -#include <inttypes.h> -#include <mach/thread_policy.h> - -static uint32_t GetSequenceID() { - static uint32_t g_nextID = 0; - return ++g_nextID; -} - -MachThread::MachThread(MachProcess *process, bool is_64_bit, - uint64_t unique_thread_id, thread_t mach_port_num) - : m_process(process), m_unique_id(unique_thread_id), - m_mach_port_number(mach_port_num), m_seq_id(GetSequenceID()), - m_state(eStateUnloaded), m_state_mutex(PTHREAD_MUTEX_RECURSIVE), - m_suspend_count(0), m_stop_exception(), - m_arch_ap(DNBArchProtocol::Create(this)), m_reg_sets(NULL), - m_num_reg_sets(0), m_ident_info(), m_proc_threadinfo(), - m_dispatch_queue_name(), m_is_64_bit(is_64_bit), - m_pthread_qos_class_decode(nullptr) { - nub_size_t num_reg_sets = 0; - m_reg_sets = m_arch_ap->GetRegisterSetInfo(&num_reg_sets); - m_num_reg_sets = num_reg_sets; - - m_pthread_qos_class_decode = - (unsigned int (*)(unsigned long, int *, unsigned long *))dlsym( - RTLD_DEFAULT, "_pthread_qos_class_decode"); - - // Get the thread state so we know if a thread is in a state where we can't - // muck with it and also so we get the suspend count correct in case it was - // already suspended - GetBasicInfo(); - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, - "MachThread::MachThread ( process = %p, tid = 0x%8.8" PRIx64 - ", seq_id = %u )", - reinterpret_cast<void *>(&m_process), m_unique_id, m_seq_id); -} - -MachThread::~MachThread() { - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, - "MachThread::~MachThread() for tid = 0x%8.8" PRIx64 " (%u)", - m_unique_id, m_seq_id); -} - -void MachThread::Suspend() { - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", - __FUNCTION__); - if (MachPortNumberIsValid(m_mach_port_number)) { - DNBError err(::thread_suspend(m_mach_port_number), DNBError::MachKernel); - if (err.Success()) - m_suspend_count++; - if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail()) - err.LogThreaded("::thread_suspend (%4.4" PRIx32 ")", m_mach_port_number); - } -} - -void MachThread::Resume(bool others_stopped) { - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", - __FUNCTION__); - if (MachPortNumberIsValid(m_mach_port_number)) { - SetSuspendCountBeforeResume(others_stopped); - } -} - -bool MachThread::SetSuspendCountBeforeResume(bool others_stopped) { - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", - __FUNCTION__); - DNBError err; - if (!MachPortNumberIsValid(m_mach_port_number)) - return false; - - integer_t times_to_resume; - - if (others_stopped) { - if (GetBasicInfo()) { - times_to_resume = m_basic_info.suspend_count; - m_suspend_count = -(times_to_resume - m_suspend_count); - } else - times_to_resume = 0; - } else { - times_to_resume = m_suspend_count; - m_suspend_count = 0; - } - - if (times_to_resume > 0) { - while (times_to_resume > 0) { - err = ::thread_resume(m_mach_port_number); - if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail()) - err.LogThreaded("::thread_resume (%4.4" PRIx32 ")", m_mach_port_number); - if (err.Success()) - --times_to_resume; - else { - if (GetBasicInfo()) - times_to_resume = m_basic_info.suspend_count; - else - times_to_resume = 0; - } - } - } - return true; -} - -bool MachThread::RestoreSuspendCountAfterStop() { - DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", - __FUNCTION__); - DNBError err; - if (!MachPortNumberIsValid(m_mach_port_number)) - return false; - - if (m_suspend_count > 0) { - while (m_suspend_count > 0) { - err = ::thread_resume(m_mach_port_number); - if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail()) - err.LogThreaded("::thread_resume (%4.4" PRIx32 ")", m_mach_port_number); - if (err.Success()) - --m_suspend_count; - else { - if (GetBasicInfo()) - m_suspend_count = m_basic_info.suspend_count; - else - m_suspend_count = 0; - return false; // ??? - } - } - } else if (m_suspend_count < 0) { - while (m_suspend_count < 0) { - err = ::thread_suspend(m_mach_port_number); - if (err.Success()) - ++m_suspend_count; - if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail()) { - err.LogThreaded("::thread_suspend (%4.4" PRIx32 ")", - m_mach_port_number); - return false; - } - } - } - return true; -} - -const char *MachThread::GetBasicInfoAsString() const { - static char g_basic_info_string[1024]; - struct thread_basic_info basicInfo; - - if (GetBasicInfo(m_mach_port_number, &basicInfo)) { - - // char run_state_str[32]; - // size_t run_state_str_size = sizeof(run_state_str); - // switch (basicInfo.run_state) - // { - // case TH_STATE_RUNNING: strlcpy(run_state_str, "running", - // run_state_str_size); break; - // case TH_STATE_STOPPED: strlcpy(run_state_str, "stopped", - // run_state_str_size); break; - // case TH_STATE_WAITING: strlcpy(run_state_str, "waiting", - // run_state_str_size); break; - // case TH_STATE_UNINTERRUPTIBLE: strlcpy(run_state_str, - // "uninterruptible", run_state_str_size); break; - // case TH_STATE_HALTED: strlcpy(run_state_str, "halted", - // run_state_str_size); break; - // default: snprintf(run_state_str, - // run_state_str_size, "%d", basicInfo.run_state); break; // ??? - // } - float user = (float)basicInfo.user_time.seconds + - (float)basicInfo.user_time.microseconds / 1000000.0f; - float system = (float)basicInfo.user_time.seconds + - (float)basicInfo.user_time.microseconds / 1000000.0f; - snprintf(g_basic_info_string, sizeof(g_basic_info_string), - "Thread 0x%8.8" PRIx64 ": user=%f system=%f cpu=%d sleep_time=%d", - m_unique_id, user, system, basicInfo.cpu_usage, - basicInfo.sleep_time); - - return g_basic_info_string; - } - return NULL; -} - -// Finds the Mach port number for a given thread in the inferior process' port -// namespace. -thread_t MachThread::InferiorThreadID() const { - mach_msg_type_number_t i; - mach_port_name_array_t names; - mach_port_type_array_t types; - mach_msg_type_number_t ncount, tcount; - thread_t inferior_tid = INVALID_NUB_THREAD; - task_t my_task = ::mach_task_self(); - task_t task = m_process->Task().TaskPort(); - - kern_return_t kret = - ::mach_port_names(task, &names, &ncount, &types, &tcount); - if (kret == KERN_SUCCESS) { - - for (i = 0; i < ncount; i++) { - mach_port_t my_name; - mach_msg_type_name_t my_type; - - kret = ::mach_port_extract_right(task, names[i], MACH_MSG_TYPE_COPY_SEND, - &my_name, &my_type); - if (kret == KERN_SUCCESS) { - ::mach_port_deallocate(my_task, my_name); - if (my_name == m_mach_port_number) { - inferior_tid = names[i]; - break; - } - } - } - // Free up the names and types - ::vm_deallocate(my_task, (vm_address_t)names, - ncount * sizeof(mach_port_name_t)); - ::vm_deallocate(my_task, (vm_address_t)types, - tcount * sizeof(mach_port_type_t)); - } - return inferior_tid; -} - -bool MachThread::IsUserReady() { - 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; -} - -struct thread_basic_info *MachThread::GetBasicInfo() { - if (MachThread::GetBasicInfo(m_mach_port_number, &m_basic_info)) - return &m_basic_info; - return NULL; -} - -bool MachThread::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 MachThread::ThreadIDIsValid(uint64_t thread) { return thread != 0; } - -bool MachThread::MachPortNumberIsValid(thread_t thread) { - return thread != THREAD_NULL; -} - -bool MachThread::GetRegisterState(int flavor, bool force) { - return m_arch_ap->GetRegisterState(flavor, force) == KERN_SUCCESS; -} - -bool MachThread::SetRegisterState(int flavor) { - return m_arch_ap->SetRegisterState(flavor) == KERN_SUCCESS; -} - -uint64_t MachThread::GetPC(uint64_t failValue) { - // Get program counter - return m_arch_ap->GetPC(failValue); -} - -bool MachThread::SetPC(uint64_t value) { - // Set program counter - return m_arch_ap->SetPC(value); -} - -uint64_t MachThread::GetSP(uint64_t failValue) { - // Get stack pointer - return m_arch_ap->GetSP(failValue); -} - -nub_process_t MachThread::ProcessID() const { - if (m_process) - return m_process->ProcessID(); - return INVALID_NUB_PROCESS; -} - -void MachThread::Dump(uint32_t index) { - const char *thread_run_state = NULL; - - switch (m_basic_info.run_state) { - case TH_STATE_RUNNING: - thread_run_state = "running"; - break; // 1 thread is running normally - case TH_STATE_STOPPED: - thread_run_state = "stopped"; - break; // 2 thread is stopped - case TH_STATE_WAITING: - thread_run_state = "waiting"; - break; // 3 thread is waiting normally - case TH_STATE_UNINTERRUPTIBLE: - thread_run_state = "uninter"; - break; // 4 thread is in an uninterruptible wait - case TH_STATE_HALTED: - thread_run_state = "halted "; - break; // 5 thread is halted at a - default: - thread_run_state = "???"; - break; - } - - 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); - // DumpRegisterState(0); -} - -void MachThread::ThreadWillResume(const DNBThreadResumeAction *thread_action, - bool others_stopped) { - if (thread_action->addr != INVALID_NUB_ADDRESS) - SetPC(thread_action->addr); - - SetState(thread_action->state); - switch (thread_action->state) { - case eStateStopped: - case eStateSuspended: - assert(others_stopped == false); - Suspend(); - break; - - case eStateRunning: - case eStateStepping: - Resume(others_stopped); - break; - default: - break; - } - m_arch_ap->ThreadWillResume(); - m_stop_exception.Clear(); -} - -DNBBreakpoint *MachThread::CurrentBreakpoint() { - return m_process->Breakpoints().FindByAddress(GetPC()); -} - -bool MachThread::ShouldStop(bool &step_more) { - // 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; -} -bool MachThread::IsStepping() { return GetState() == eStateStepping; } - -bool MachThread::ThreadDidStop() { - // 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); - return true; -} - -bool MachThread::NotifyException(MachException::Data &exc) { - // 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; -} - -nub_state_t MachThread::GetState() { - // If any other threads access this we will need a mutex for it - PTHREAD_MUTEX_LOCKER(locker, m_state_mutex); - return m_state; -} - -void MachThread::SetState(nub_state_t state) { - PTHREAD_MUTEX_LOCKER(locker, m_state_mutex); - m_state = state; - DNBLogThreadedIf(LOG_THREAD, - "MachThread::SetState ( %s ) for tid = 0x%8.8" PRIx64 "", - DNBStateAsString(state), m_unique_id); -} - -nub_size_t MachThread::GetNumRegistersInSet(nub_size_t regSet) const { - if (regSet < m_num_reg_sets) - return m_reg_sets[regSet].num_registers; - return 0; -} - -const char *MachThread::GetRegisterSetName(nub_size_t regSet) const { - if (regSet < m_num_reg_sets) - return m_reg_sets[regSet].name; - return NULL; -} - -const DNBRegisterInfo *MachThread::GetRegisterInfo(nub_size_t regSet, - nub_size_t regIndex) const { - if (regSet < m_num_reg_sets) - if (regIndex < m_reg_sets[regSet].num_registers) - return &m_reg_sets[regSet].registers[regIndex]; - return NULL; -} -void MachThread::DumpRegisterState(nub_size_t regSet) { - if (regSet == REGISTER_SET_ALL) { - for (regSet = 1; regSet < m_num_reg_sets; regSet++) - DumpRegisterState(regSet); - } else { - if (m_arch_ap->RegisterSetStateIsValid((int)regSet)) { - const size_t numRegisters = GetNumRegistersInSet(regSet); - uint32_t regIndex = 0; - DNBRegisterValueClass reg; - for (regIndex = 0; regIndex < numRegisters; ++regIndex) { - if (m_arch_ap->GetRegisterValue((uint32_t)regSet, regIndex, ®)) { - reg.Dump(NULL, NULL); - } - } - } else { - DNBLog("%s: registers are not currently valid.", - GetRegisterSetName(regSet)); - } - } -} - -const DNBRegisterSetInfo * -MachThread::GetRegisterSetInfo(nub_size_t *num_reg_sets) const { - *num_reg_sets = m_num_reg_sets; - return &m_reg_sets[0]; -} - -bool MachThread::GetRegisterValue(uint32_t set, uint32_t reg, - DNBRegisterValue *value) { - return m_arch_ap->GetRegisterValue(set, reg, value); -} - -bool MachThread::SetRegisterValue(uint32_t set, uint32_t reg, - const DNBRegisterValue *value) { - return m_arch_ap->SetRegisterValue(set, reg, value); -} - -nub_size_t MachThread::GetRegisterContext(void *buf, nub_size_t buf_len) { - return m_arch_ap->GetRegisterContext(buf, buf_len); -} - -nub_size_t MachThread::SetRegisterContext(const void *buf, nub_size_t buf_len) { - return m_arch_ap->SetRegisterContext(buf, buf_len); -} - -uint32_t MachThread::SaveRegisterState() { - return m_arch_ap->SaveRegisterState(); -} -bool MachThread::RestoreRegisterState(uint32_t save_id) { - return m_arch_ap->RestoreRegisterState(save_id); -} - -uint32_t MachThread::EnableHardwareBreakpoint(const DNBBreakpoint *bp) { - if (bp != NULL && bp->IsBreakpoint()) - return m_arch_ap->EnableHardwareBreakpoint(bp->Address(), bp->ByteSize()); - return INVALID_NUB_HW_INDEX; -} - -uint32_t MachThread::EnableHardwareWatchpoint(const DNBBreakpoint *wp, - bool also_set_on_task) { - if (wp != NULL && wp->IsWatchpoint()) - return m_arch_ap->EnableHardwareWatchpoint( - wp->Address(), wp->ByteSize(), wp->WatchpointRead(), - wp->WatchpointWrite(), also_set_on_task); - return INVALID_NUB_HW_INDEX; -} - -bool MachThread::RollbackTransForHWP() { - return m_arch_ap->RollbackTransForHWP(); -} - -bool MachThread::FinishTransForHWP() { return m_arch_ap->FinishTransForHWP(); } - -bool MachThread::DisableHardwareBreakpoint(const DNBBreakpoint *bp) { - if (bp != NULL && bp->IsHardware()) - return m_arch_ap->DisableHardwareBreakpoint(bp->GetHardwareIndex()); - return false; -} - -bool MachThread::DisableHardwareWatchpoint(const DNBBreakpoint *wp, - bool also_set_on_task) { - if (wp != NULL && wp->IsHardware()) - return m_arch_ap->DisableHardwareWatchpoint(wp->GetHardwareIndex(), - also_set_on_task); - return false; -} - -uint32_t MachThread::NumSupportedHardwareWatchpoints() const { - return m_arch_ap->NumSupportedHardwareWatchpoints(); -} - -bool MachThread::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_port_number, THREAD_IDENTIFIER_INFO, - (thread_info_t)&m_ident_info, &count); - return kret == KERN_SUCCESS; - - return false; -} - -const char *MachThread::GetName() { - if (GetIdentifierInfo()) { - int len = ::proc_pidinfo(m_process->ProcessID(), PROC_PIDTHREADINFO, - m_ident_info.thread_handle, &m_proc_threadinfo, - sizeof(m_proc_threadinfo)); - - if (len && m_proc_threadinfo.pth_name[0]) - return m_proc_threadinfo.pth_name; - } - return NULL; -} - -uint64_t -MachThread::GetGloballyUniqueThreadIDForMachPortID(thread_t mach_port_id) { - kern_return_t kr; - thread_identifier_info_data_t tident; - mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT; - kr = thread_info(mach_port_id, THREAD_IDENTIFIER_INFO, (thread_info_t)&tident, - &tident_count); - if (kr != KERN_SUCCESS) { - return mach_port_id; - } - return tident.thread_id; -} - -nub_addr_t MachThread::GetPThreadT() { - nub_addr_t pthread_t_value = INVALID_NUB_ADDRESS; - if (MachPortNumberIsValid(m_mach_port_number)) { - kern_return_t kr; - thread_identifier_info_data_t tident; - mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT; - kr = thread_info(m_mach_port_number, THREAD_IDENTIFIER_INFO, - (thread_info_t)&tident, &tident_count); - if (kr == KERN_SUCCESS) { - // Dereference thread_handle to get the pthread_t value for this thread. - if (m_is_64_bit) { - uint64_t addr; - if (m_process->ReadMemory(tident.thread_handle, 8, &addr) == 8) { - if (addr != 0) { - pthread_t_value = addr; - } - } - } else { - uint32_t addr; - if (m_process->ReadMemory(tident.thread_handle, 4, &addr) == 4) { - if (addr != 0) { - pthread_t_value = addr; - } - } - } - } - } - return pthread_t_value; -} - -// Return this thread's TSD (Thread Specific Data) address. -// This is computed based on this thread's pthread_t value. -// -// We compute the TSD from the pthread_t by one of two methods. -// -// If plo_pthread_tsd_base_offset is non-zero, this is a simple offset that we -// add to -// the pthread_t to get the TSD base address. -// -// Else we read a pointer from memory at pthread_t + -// plo_pthread_tsd_base_address_offset and -// that gives us the TSD address. -// -// These plo_pthread_tsd_base values must be read out of libpthread by lldb & -// provided to debugserver. - -nub_addr_t -MachThread::GetTSDAddressForThread(uint64_t plo_pthread_tsd_base_address_offset, - uint64_t plo_pthread_tsd_base_offset, - uint64_t plo_pthread_tsd_entry_size) { - nub_addr_t tsd_addr = INVALID_NUB_ADDRESS; - nub_addr_t pthread_t_value = GetPThreadT(); - if (plo_pthread_tsd_base_offset != 0 && - plo_pthread_tsd_base_offset != INVALID_NUB_ADDRESS) { - tsd_addr = pthread_t_value + plo_pthread_tsd_base_offset; - } else { - if (plo_pthread_tsd_entry_size == 4) { - uint32_t addr = 0; - if (m_process->ReadMemory(pthread_t_value + - plo_pthread_tsd_base_address_offset, - 4, &addr) == 4) { - if (addr != 0) { - tsd_addr = addr; - } - } - } - if (plo_pthread_tsd_entry_size == 4) { - uint64_t addr = 0; - if (m_process->ReadMemory(pthread_t_value + - plo_pthread_tsd_base_address_offset, - 8, &addr) == 8) { - if (addr != 0) { - tsd_addr = addr; - } - } - } - } - return tsd_addr; -} - -nub_addr_t MachThread::GetDispatchQueueT() { - nub_addr_t dispatch_queue_t_value = INVALID_NUB_ADDRESS; - if (MachPortNumberIsValid(m_mach_port_number)) { - kern_return_t kr; - thread_identifier_info_data_t tident; - mach_msg_type_number_t tident_count = THREAD_IDENTIFIER_INFO_COUNT; - kr = thread_info(m_mach_port_number, THREAD_IDENTIFIER_INFO, - (thread_info_t)&tident, &tident_count); - if (kr == KERN_SUCCESS && tident.dispatch_qaddr != 0 && - tident.dispatch_qaddr != INVALID_NUB_ADDRESS) { - // Dereference dispatch_qaddr to get the dispatch_queue_t value for this - // thread's queue, if any. - if (m_is_64_bit) { - uint64_t addr; - if (m_process->ReadMemory(tident.dispatch_qaddr, 8, &addr) == 8) { - if (addr != 0) - dispatch_queue_t_value = addr; - } - } else { - uint32_t addr; - if (m_process->ReadMemory(tident.dispatch_qaddr, 4, &addr) == 4) { - if (addr != 0) - dispatch_queue_t_value = addr; - } - } - } - } - return dispatch_queue_t_value; -} - -ThreadInfo::QoS MachThread::GetRequestedQoS(nub_addr_t tsd, - uint64_t dti_qos_class_index) { - ThreadInfo::QoS qos_value; - if (MachPortNumberIsValid(m_mach_port_number) && - m_pthread_qos_class_decode != nullptr) { - uint64_t pthread_priority_value = 0; - if (m_is_64_bit) { - uint64_t pri; - if (m_process->ReadMemory(tsd + (dti_qos_class_index * 8), 8, &pri) == - 8) { - pthread_priority_value = pri; - } - } else { - uint32_t pri; - if (m_process->ReadMemory(tsd + (dti_qos_class_index * 4), 4, &pri) == - 4) { - pthread_priority_value = pri; - } - } - - uint32_t requested_qos = - m_pthread_qos_class_decode(pthread_priority_value, NULL, NULL); - - switch (requested_qos) { - // These constants from <pthread/qos.h> - case 0x21: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_USER_INTERACTIVE"; - qos_value.printable_name = "User Interactive"; - break; - case 0x19: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_USER_INITIATED"; - qos_value.printable_name = "User Initiated"; - break; - case 0x15: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_DEFAULT"; - qos_value.printable_name = "Default"; - break; - case 0x11: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_UTILITY"; - qos_value.printable_name = "Utility"; - break; - case 0x09: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_BACKGROUND"; - qos_value.printable_name = "Background"; - break; - case 0x00: - qos_value.enum_value = requested_qos; - qos_value.constant_name = "QOS_CLASS_UNSPECIFIED"; - qos_value.printable_name = "Unspecified"; - break; - } - } - return qos_value; -} |