| //===-- 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) == false) |
| 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) == false) |
| 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; |
| } |
