nub_size_t MachThreadList::SetRegisterContext(nub_thread_t tid, const void *buf,
size_t buf_len) {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->SetRegisterContext(buf, buf_len);
return 0;
}
void
MachThreadList::DumpThreadStoppedReason (nub_thread_t tid) const
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
thread_sp->GetStopException().DumpStopReason();
}
bool MachThreadList::GetThreadStoppedReason(
nub_thread_t tid, struct DNBThreadStopInfo *stop_info) const {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->GetStopException().GetStopInfo(stop_info);
return false;
}
/* function opens an existing process using its id */
BOOL Process::Open(DWORD _id)
{
/* buffering variable */
HANDLE lhProcess = OpenProcess(PROCESS_ALL_ACCESS, false, _id);
if (lhProcess != nullptr)
{
if (hProcess != nullptr)
Destroy();
hProcess = lhProcess;
hThread = GetThreadByID(_id);
/* register new 'exit' callback for new process */
RegisterExitCallback(exitCallback);
/* get the command line of the process */
szCmdLine = GetCommandLine(hProcess);
id = _id;
/* call 'process started' */
OnStarted();
return TRUE;
}
return FALSE;
}
const char *
MachThreadList::GetName (thread_t tid)
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->GetName();
return NULL;
}
bool
MachThreadList::RestoreRegisterState (nub_thread_t tid, uint32_t save_id)
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->RestoreRegisterState (save_id);
return 0;
}
uint32_t
MachThreadList::SaveRegisterState (nub_thread_t tid)
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->SaveRegisterState ();
return 0;
}
nub_thread_t MachThreadList::SetCurrentThread(nub_thread_t tid) {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp) {
m_current_thread = thread_sp;
return tid;
}
return INVALID_NUB_THREAD;
}
const char *
MachThreadList::GetThreadInfo (nub_thread_t tid) const
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->GetBasicInfoAsString();
return NULL;
}
ThreadInfo::QoS MachThreadList::GetRequestedQoS(nub_thread_t tid,
nub_addr_t tsd,
uint64_t dti_qos_class_index) {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->GetRequestedQoS(tsd, dti_qos_class_index);
return ThreadInfo::QoS();
}
nub_state_t
MachThreadList::GetState(thread_t tid)
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->GetState();
return eStateInvalid;
}
bool
MachThreadList::SetRegisterValue ( nub_thread_t tid, uint32_t reg_set_idx, uint32_t reg_idx, const DNBRegisterValue *reg_value ) const
{
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
return thread_sp->SetRegisterValue(reg_set_idx, reg_idx, reg_value);
return false;
}
bool MachThreadList::GetRegisterValue(nub_thread_t tid, uint32_t set,
uint32_t reg,
DNBRegisterValue *reg_value) const {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->GetRegisterValue(set, reg, reg_value);
return false;
}
nub_addr_t MachThreadList::GetTSDAddressForThread(
nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset,
uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size) {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->GetTSDAddressForThread(
plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset,
plo_pthread_tsd_entry_size);
return INVALID_NUB_ADDRESS;
}
bool
MachThreadList::DisableHardwareBreakpoint (const DNBBreakpoint* bp) const
{
if (bp != NULL)
{
MachThreadSP thread_sp (GetThreadByID (bp->ThreadID()));
if (thread_sp)
return thread_sp->DisableHardwareBreakpoint(bp);
}
return false;
}
uint32_t
MachThreadList::EnableHardwareBreakpoint (const DNBBreakpoint* bp) const
{
if (bp != NULL)
{
MachThreadSP thread_sp (GetThreadByID (bp->ThreadID()));
if (thread_sp)
return thread_sp->EnableHardwareBreakpoint(bp);
}
return INVALID_NUB_HW_INDEX;
}
bool
MachThreadList::NotifyException(MachException::Data& exc)
{
MachThreadSP thread_sp (GetThreadByID (exc.thread_port));
if (thread_sp)
{
thread_sp->NotifyException(exc);
return true;
}
return false;
}
nub_addr_t MachThreadList::GetDispatchQueueT(nub_thread_t tid) {
MachThreadSP thread_sp(GetThreadByID(tid));
if (thread_sp)
return thread_sp->GetDispatchQueueT();
return INVALID_NUB_ADDRESS;
}
uint32_t
MachThreadList::UpdateThreadList(MachProcess *process, bool update, MachThreadList::collection *new_threads)
{
// locker will keep a mutex locked until it goes out of scope
DNBLogThreadedIf (LOG_THREAD, "MachThreadList::UpdateThreadList (pid = %4.4x, update = %u) process stop count = %u", process->ProcessID(), update, process->StopCount());
PTHREAD_MUTEX_LOCKER (locker, m_threads_mutex);
#if defined (__i386__) || defined (__x86_64__)
if (process->StopCount() == 0)
{
int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, process->ProcessID() };
struct kinfo_proc processInfo;
size_t bufsize = sizeof(processInfo);
bool is_64_bit = false;
if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo, &bufsize, NULL, 0) == 0 && bufsize > 0)
{
if (processInfo.kp_proc.p_flag & P_LP64)
is_64_bit = true;
}
if (is_64_bit)
DNBArchProtocol::SetArchitecture(CPU_TYPE_X86_64);
else
DNBArchProtocol::SetArchitecture(CPU_TYPE_I386);
}
#endif
if (m_threads.empty() || update)
{
thread_array_t thread_list = NULL;
mach_msg_type_number_t thread_list_count = 0;
task_t task = process->Task().TaskPort();
DNBError err(::task_threads (task, &thread_list, &thread_list_count), DNBError::MachKernel);
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::task_threads ( task = 0x%4.4x, thread_list => %p, thread_list_count => %u )", task, thread_list, thread_list_count);
if (err.Error() == KERN_SUCCESS && thread_list_count > 0)
{
MachThreadList::collection currThreads;
size_t idx;
// Iterator through the current thread list and see which threads
// we already have in our list (keep them), which ones we don't
// (add them), and which ones are not around anymore (remove them).
for (idx = 0; idx < thread_list_count; ++idx)
{
const thread_t tid = thread_list[idx];
MachThreadSP thread_sp (GetThreadByID (tid));
if (thread_sp)
{
// Keep the existing thread class
currThreads.push_back(thread_sp);
}
else
{
// We don't have this thread, lets add it.
thread_sp.reset(new MachThread(process, tid));
// Add the new thread regardless of its is user ready state...
// Make sure the thread is ready to be displayed and shown to users
// before we add this thread to our list...
if (thread_sp->IsUserReady())
{
if (new_threads)
new_threads->push_back(thread_sp);
currThreads.push_back(thread_sp);
}
}
}
m_threads.swap(currThreads);
m_current_thread.reset();
// Free the vm memory given to us by ::task_threads()
vm_size_t thread_list_size = (vm_size_t) (thread_list_count * sizeof (thread_t));
::vm_deallocate (::mach_task_self(),
(vm_address_t)thread_list,
thread_list_size);
}
}
return m_threads.size();
}
