//----------------------------------------------------------------------
// MachTask::Resume
//----------------------------------------------------------------------
kern_return_t
MachTask::Resume()
{
struct task_basic_info task_info;
task_t task = TaskPort();
if (task == TASK_NULL)
return KERN_INVALID_ARGUMENT;
DNBError err;
err = BasicInfo(task, &task_info);
if (err.Success())
{
// task_resume isn't counted like task_suspend calls are, are, so if the
// task is not suspended, don't try and resume it since it is already
// running
if (task_info.suspend_count > 0)
{
err = ::task_resume (task);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
err.LogThreaded("::task_resume ( target_task = 0x%4.4x )", task);
}
}
return err.Error();
}
//----------------------------------------------------------------------
// MachTask::AllocateMemory
//----------------------------------------------------------------------
nub_addr_t
MachTask::AllocateMemory (size_t size, uint32_t permissions)
{
mach_vm_address_t addr;
task_t task = TaskPort();
if (task == TASK_NULL)
return INVALID_NUB_ADDRESS;
DNBError err;
err = ::mach_vm_allocate (task, &addr, size, TRUE);
if (err.Error() == KERN_SUCCESS)
{
// Set the protections:
vm_prot_t mach_prot = VM_PROT_NONE;
if (permissions & eMemoryPermissionsReadable)
mach_prot |= VM_PROT_READ;
if (permissions & eMemoryPermissionsWritable)
mach_prot |= VM_PROT_WRITE;
if (permissions & eMemoryPermissionsExecutable)
mach_prot |= VM_PROT_EXECUTE;
err = ::mach_vm_protect (task, addr, size, 0, mach_prot);
if (err.Error() == KERN_SUCCESS)
{
m_allocations.insert (std::make_pair(addr, size));
return addr;
}
::mach_vm_deallocate (task, addr, size);
}
return INVALID_NUB_ADDRESS;
}
rnb_err_t
RNBSocket::Write (const void *buffer, size_t length)
{
if (m_fd == -1)
return rnb_err;
DNBError err;
int bytessent = send (m_fd, buffer, length, 0);
if (bytessent < 0)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::send ( socket = %i, buffer = %p, length = %zu, flags = 0 ) => %i", m_fd, buffer, length, bytessent);
if (bytessent < 0)
return rnb_err;
if (bytessent != length)
return rnb_err;
DNBLogThreadedIf(LOG_RNB_PACKETS, "putpkt: %*s", (int)length, (char *)buffer); // All data is string based in debugserver, so this is safe
DNBLogThreadedIf(LOG_RNB_COMM, "sent: %*s", (int)length, (char *)buffer);
return rnb_success;
}
//----------------------------------------------------------------------
// MachTask::BasicInfo
//----------------------------------------------------------------------
kern_return_t
MachTask::BasicInfo(task_t task, struct task_basic_info *info)
{
if (info == NULL)
return KERN_INVALID_ARGUMENT;
DNBError err;
mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
err = ::task_info (task, TASK_BASIC_INFO, (task_info_t)info, &count);
const bool log_process = DNBLogCheckLogBit(LOG_TASK);
if (log_process || err.Fail())
err.LogThreaded("::task_info ( target_task = 0x%4.4x, flavor = TASK_BASIC_INFO, task_info_out => %p, task_info_outCnt => %u )", task, info, count);
if (DNBLogCheckLogBit(LOG_TASK) && DNBLogCheckLogBit(LOG_VERBOSE) && err.Success())
{
float user = (float)info->user_time.seconds + (float)info->user_time.microseconds / 1000000.0f;
float system = (float)info->user_time.seconds + (float)info->user_time.microseconds / 1000000.0f;
DNBLogThreaded ("task_basic_info = { suspend_count = %i, virtual_size = 0x%8.8llx, resident_size = 0x%8.8llx, user_time = %f, system_time = %f }",
info->suspend_count,
(uint64_t)info->virtual_size,
(uint64_t)info->resident_size,
user,
system);
}
return err.Error();
}
kern_return_t
MachTask::ShutDownExcecptionThread()
{
DNBError err;
err = RestoreExceptionPortInfo();
// NULL our our exception port and let our exception thread exit
mach_port_t exception_port = m_exception_port;
m_exception_port = NULL;
err.SetError(::pthread_cancel(m_exception_thread), DNBError::POSIX);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
err.LogThreaded("::pthread_cancel ( thread = %p )", m_exception_thread);
err.SetError(::pthread_join(m_exception_thread, NULL), DNBError::POSIX);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
err.LogThreaded("::pthread_join ( thread = %p, value_ptr = NULL)", m_exception_thread);
// Deallocate our exception port that we used to track our child process
mach_port_t task_self = mach_task_self ();
err = ::mach_port_deallocate (task_self, exception_port);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
err.LogThreaded("::mach_port_deallocate ( task = 0x%4.4x, name = 0x%4.4x )", task_self, exception_port);
exception_port = NULL;
return err.Error();
}
//----------------------------------------------------------------------
// MachTask::Suspend
//----------------------------------------------------------------------
kern_return_t
MachTask::Suspend()
{
DNBError err;
task_t task = TaskPort();
err = ::task_suspend (task);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
err.LogThreaded("::task_suspend ( target_task = 0x%4.4x )", task);
return err.Error();
}
kern_return_t
MachException::PortInfo::Save (task_t task)
{
count = (sizeof (ports) / sizeof (ports[0]));
DNBLogThreadedIf(LOG_EXCEPTIONS | LOG_VERBOSE, "MachException::PortInfo::Save ( task = 0x%4.4x )", task);
DNBError err;
err = ::task_get_exception_ports (task, EXC_MASK_ALL, masks, &count, ports, behaviors, flavors);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
err.LogThreaded("::task_get_exception_ports ( task = 0x%4.4x, mask = 0x%x, maskCnt => %u, ports, behaviors, flavors )", task, EXC_MASK_ALL, count);
if (err.Fail())
count = 0;
return err.Error();
}
kern_return_t
MachException::Message::Receive(mach_port_t port, mach_msg_option_t options, mach_msg_timeout_t timeout, mach_port_t notify_port)
{
DNBError err;
const bool log_exceptions = DNBLogCheckLogBit(LOG_EXCEPTIONS);
mach_msg_timeout_t mach_msg_timeout = options & MACH_RCV_TIMEOUT ? timeout : 0;
if (log_exceptions && ((options & MACH_RCV_TIMEOUT) == 0))
{
// Dump this log message if we have no timeout in case it never returns
DNBLogThreaded("::mach_msg ( msg->{bits = %#x, size = %u remote_port = %#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, option = %#x, send_size = %u, rcv_size = %u, rcv_name = %#x, timeout = %u, notify = %#x)",
exc_msg.hdr.msgh_bits,
exc_msg.hdr.msgh_size,
exc_msg.hdr.msgh_remote_port,
exc_msg.hdr.msgh_local_port,
exc_msg.hdr.msgh_reserved,
exc_msg.hdr.msgh_id,
options,
0,
sizeof (exc_msg.data),
port,
mach_msg_timeout,
notify_port);
}
err = ::mach_msg (&exc_msg.hdr,
options, // options
0, // Send size
sizeof (exc_msg.data), // Receive size
port, // exception port to watch for exception on
mach_msg_timeout, // timeout in msec (obeyed only if MACH_RCV_TIMEOUT is ORed into the options parameter)
notify_port);
// Dump any errors we get
if (log_exceptions)
{
err.LogThreaded("::mach_msg ( msg->{bits = %#x, size = %u remote_port = %#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, option = %#x, send_size = %u, rcv_size = %u, rcv_name = %#x, timeout = %u, notify = %#x)",
exc_msg.hdr.msgh_bits,
exc_msg.hdr.msgh_size,
exc_msg.hdr.msgh_remote_port,
exc_msg.hdr.msgh_local_port,
exc_msg.hdr.msgh_reserved,
exc_msg.hdr.msgh_id,
options,
0,
sizeof (exc_msg.data),
port,
mach_msg_timeout,
notify_port);
}
return err.Error();
}
kern_return_t
MachException::PortInfo::Save (task_t task)
{
DNBLogThreadedIf(LOG_EXCEPTIONS | LOG_VERBOSE, "MachException::PortInfo::Save ( task = 0x%4.4x )", task);
// Be careful to be able to have debugserver built on a newer OS than what
// it is currently running on by being able to start with all exceptions
// and back off to just what is supported on the current system
DNBError err;
mask = EXC_MASK_ALL;
count = (sizeof (ports) / sizeof (ports[0]));
err = ::task_get_exception_ports (task, mask, masks, &count, ports, behaviors, flavors);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
err.LogThreaded("::task_get_exception_ports ( task = 0x%4.4x, mask = 0x%x, maskCnt => %u, ports, behaviors, flavors )", task, mask, count);
if (err.Error() == KERN_INVALID_ARGUMENT && mask != PREV_EXC_MASK_ALL)
{
mask = PREV_EXC_MASK_ALL;
count = (sizeof (ports) / sizeof (ports[0]));
err = ::task_get_exception_ports (task, mask, masks, &count, ports, behaviors, flavors);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
err.LogThreaded("::task_get_exception_ports ( task = 0x%4.4x, mask = 0x%x, maskCnt => %u, ports, behaviors, flavors )", task, mask, count);
}
if (err.Fail())
{
mask = 0;
count = 0;
}
return err.Error();
}
bool
MachThread::SetSuspendCountBeforeResume(bool others_stopped)
{
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", __FUNCTION__);
DNBError err;
if (ThreadIDIsValid(m_tid) == false)
return false;
size_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_tid);
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::thread_resume (%4.4x)", m_tid);
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::RestoreSuspendCount()
{
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", __FUNCTION__);
DNBError err;
if (ThreadIDIsValid(m_tid) == false)
return false;
else if (m_suspendCount > m_basicInfo.suspend_count)
{
while (m_suspendCount > m_basicInfo.suspend_count)
{
err = ::thread_resume (m_tid);
if (err.Success())
--m_suspendCount;
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::thread_resume (%4.4x)", m_tid);
}
}
else if (m_suspendCount < m_basicInfo.suspend_count)
{
while (m_suspendCount < m_basicInfo.suspend_count)
{
err = ::thread_suspend (m_tid);
if (err.Success())
--m_suspendCount;
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::thread_suspend (%4.4x)", m_tid);
}
}
return m_suspendCount == m_basicInfo.suspend_count;
}
bool
MachThread::RestoreSuspendCount()
{
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", __FUNCTION__);
DNBError err;
if (ThreadIDIsValid(m_tid) == false)
return false;
if (m_suspendCount > 0)
{
while (m_suspendCount > 0)
{
err = ::thread_resume (m_tid);
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::thread_resume (%4.4x)", m_tid);
if (err.Success())
--m_suspendCount;
else
{
if (GetBasicInfo())
m_suspendCount = m_basicInfo.suspend_count;
else
m_suspendCount = 0;
return false; // ???
}
}
}
// We don't currently really support resuming a thread that was externally
// suspended. If/when we do, we will need to make the code below work and
// m_suspendCount will need to become signed instead of unsigned.
// else if (m_suspendCount < 0)
// {
// while (m_suspendCount < 0)
// {
// err = ::thread_suspend (m_tid);
// if (err.Success())
// ++m_suspendCount;
// if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
// err.LogThreaded("::thread_suspend (%4.4x)", m_tid);
// }
// }
return true;
}
rnb_err_t
RNBSocket::Read (std::string &p)
{
char buf[1024];
p.clear();
// Note that BUF is on the stack so we must be careful to keep any
// writes to BUF from overflowing or we'll have security issues.
if (m_fd == -1)
return rnb_err;
//DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s calling read()", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__);
DNBError err;
int bytesread = read (m_fd, buf, sizeof (buf));
if (bytesread <= 0)
err.SetError(errno, DNBError::POSIX);
else
p.append(buf, bytesread);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::read ( %i, %p, %zu ) => %i", m_fd, buf, sizeof (buf), bytesread);
// Our port went away - we have to mark this so IsConnected will return the truth.
if (bytesread == 0)
{
m_fd = -1;
return rnb_not_connected;
}
else if (bytesread == -1)
{
m_fd = -1;
return rnb_err;
}
// Strip spaces from the end of the buffer
while (!p.empty() && isspace (p[p.size() - 1]))
p.erase (p.size () - 1);
// Most data in the debugserver packets valid printable characters...
DNBLogThreadedIf(LOG_RNB_COMM, "read: %s", p.c_str());
return rnb_success;
}
bool
MachTask::StartExceptionThread(DNBError &err)
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "MachTask::%s ( )", __FUNCTION__);
task_t task = TaskPortForProcessID(err);
if (MachTask::IsValid(task))
{
// Got the mach port for the current process
mach_port_t task_self = mach_task_self ();
// Allocate an exception port that we will use to track our child process
err = ::mach_port_allocate (task_self, MACH_PORT_RIGHT_RECEIVE, &m_exception_port);
if (err.Fail())
return false;
// Add the ability to send messages on the new exception port
err = ::mach_port_insert_right (task_self, m_exception_port, m_exception_port, MACH_MSG_TYPE_MAKE_SEND);
if (err.Fail())
return false;
// Save the original state of the exception ports for our child process
SaveExceptionPortInfo();
// We weren't able to save the info for our exception ports, we must stop...
if (m_exc_port_info.mask == 0)
{
err.SetErrorString("failed to get exception port info");
return false;
}
// Set the ability to get all exceptions on this port
err = ::task_set_exception_ports (task, m_exc_port_info.mask, m_exception_port, EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
{
err.LogThreaded("::task_set_exception_ports ( task = 0x%4.4x, exception_mask = 0x%8.8x, new_port = 0x%4.4x, behavior = 0x%8.8x, new_flavor = 0x%8.8x )",
task,
m_exc_port_info.mask,
m_exception_port,
(EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES),
THREAD_STATE_NONE);
}
if (err.Fail())
return false;
// Create the exception thread
err = ::pthread_create (&m_exception_thread, NULL, MachTask::ExceptionThread, this);
return err.Success();
}
else
{
DNBLogError("MachTask::%s (): task invalid, exception thread start failed.", __FUNCTION__);
}
return false;
}
nub_addr_t
MachTask::GetDYLDAllImageInfosAddress (DNBError& err)
{
struct hack_task_dyld_info dyld_info;
mach_msg_type_number_t count = TASK_DYLD_INFO_COUNT;
// Make sure that COUNT isn't bigger than our hacked up struct hack_task_dyld_info.
// If it is, then make COUNT smaller to match.
if (count > (sizeof(struct hack_task_dyld_info) / sizeof(natural_t)))
count = (sizeof(struct hack_task_dyld_info) / sizeof(natural_t));
task_t task = TaskPortForProcessID (err);
if (err.Success())
{
err = ::task_info (task, TASK_DYLD_INFO, (task_info_t)&dyld_info, &count);
if (err.Success())
{
// We now have the address of the all image infos structure
return dyld_info.all_image_info_addr;
}
}
return INVALID_NUB_ADDRESS;
}
bool
MachTask::StartExceptionThread(DNBError &err)
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "MachTask::%s ( )", __FUNCTION__);
task_t task = TaskPortForProcessID(err);
if (MachTask::IsValid(task))
{
// Got the mach port for the current process
mach_port_t task_self = mach_task_self ();
// Allocate an exception port that we will use to track our child process
err = ::mach_port_allocate (task_self, MACH_PORT_RIGHT_RECEIVE, &m_exception_port);
if (err.Fail())
return false;
// Add the ability to send messages on the new exception port
err = ::mach_port_insert_right (task_self, m_exception_port, m_exception_port, MACH_MSG_TYPE_MAKE_SEND);
if (err.Fail())
return false;
// Save the original state of the exception ports for our child process
SaveExceptionPortInfo();
// Set the ability to get all exceptions on this port
err = ::task_set_exception_ports (task, EXC_MASK_ALL, m_exception_port, EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES, THREAD_STATE_NONE);
if (err.Fail())
return false;
// Create the exception thread
err = ::pthread_create (&m_exception_thread, NULL, MachTask::ExceptionThread, this);
return err.Success();
}
else
{
DNBLogError("MachTask::%s (): task invalid, exception thread start failed.", __FUNCTION__);
}
return false;
}
rnb_err_t
RNBSocket::OpenFile (const char *path)
{
DNBError err;
m_fd = open (path, O_RDWR);
if (m_fd == -1)
{
err.SetError(errno, DNBError::POSIX);
err.LogThreaded ("can't open file '%s'", path);
return rnb_not_connected;
}
else
{
struct termios stdin_termios;
if (::tcgetattr (m_fd, &stdin_termios) == 0)
{
stdin_termios.c_lflag &= ~ECHO; // Turn off echoing
stdin_termios.c_lflag &= ~ICANON; // Get one char at a time
::tcsetattr (m_fd, TCSANOW, &stdin_termios);
}
}
return rnb_success;
}
kern_return_t
MachException::PortInfo::Restore (task_t task)
{
DNBLogThreadedIf(LOG_EXCEPTIONS | LOG_VERBOSE, "MachException::PortInfo::Restore( task = 0x%4.4x )", task);
uint32_t i = 0;
DNBError err;
if (count > 0)
{
for (i = 0; i < count; i++)
{
err = ::task_set_exception_ports (task, masks[i], ports[i], behaviors[i], flavors[i]);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
{
err.LogThreaded("::task_set_exception_ports ( task = 0x%4.4x, exception_mask = 0x%8.8x, new_port = 0x%4.4x, behavior = 0x%8.8x, new_flavor = 0x%8.8x )", task, masks[i], ports[i], behaviors[i], flavors[i]);
// Bail if we encounter any errors
}
if (err.Fail())
break;
}
}
count = 0;
return err.Error();
}
//----------------------------------------------------------------------
// MachTask::TaskPortForProcessID
//----------------------------------------------------------------------
task_t
MachTask::TaskPortForProcessID (pid_t pid, DNBError &err, uint32_t num_retries, uint32_t usec_interval)
{
if (pid != INVALID_NUB_PROCESS)
{
DNBError err;
mach_port_t task_self = mach_task_self ();
task_t task = TASK_NULL;
for (uint32_t i=0; i<num_retries; i++)
{
err = ::task_for_pid ( task_self, pid, &task);
if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
{
char str[1024];
::snprintf (str,
sizeof(str),
"::task_for_pid ( target_tport = 0x%4.4x, pid = %d, &task ) => err = 0x%8.8x (%s)",
task_self,
pid,
err.Error(),
err.AsString() ? err.AsString() : "success");
if (err.Fail())
err.SetErrorString(str);
err.LogThreaded(str);
}
if (err.Success())
return task;
// Sleep a bit and try again
::usleep (usec_interval);
}
}
return TASK_NULL;
}
bool
MachThread::RestoreSuspendCountAfterStop ()
{
DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE, "MachThread::%s ( )", __FUNCTION__);
DNBError err;
if (ThreadIDIsValid(m_tid) == false)
return false;
if (m_suspend_count > 0)
{
while (m_suspend_count > 0)
{
err = ::thread_resume (m_tid);
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
err.LogThreaded("::thread_resume (%4.4x)", m_tid);
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_tid);
if (err.Success())
++m_suspend_count;
if (DNBLogCheckLogBit(LOG_THREAD) || err.Fail())
{
err.LogThreaded("::thread_suspend (%4.4x)", m_tid);
return false;
}
}
}
return true;
}
std::string
MachTask::GetProfileData (DNBProfileDataScanType scanType)
{
std::string result;
static int32_t numCPU = -1;
struct host_cpu_load_info host_info;
if (scanType & eProfileHostCPU)
{
int32_t mib[] = {CTL_HW, HW_AVAILCPU};
size_t len = sizeof(numCPU);
if (numCPU == -1)
{
if (sysctl(mib, sizeof(mib) / sizeof(int32_t), &numCPU, &len, NULL, 0) != 0)
return result;
}
mach_port_t localHost = mach_host_self();
mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
kern_return_t kr = host_statistics(localHost, HOST_CPU_LOAD_INFO, (host_info_t)&host_info, &count);
if (kr != KERN_SUCCESS)
return result;
}
task_t task = TaskPort();
if (task == TASK_NULL)
return result;
struct task_basic_info task_info;
DNBError err;
err = BasicInfo(task, &task_info);
if (!err.Success())
return result;
uint64_t elapsed_usec = 0;
uint64_t task_used_usec = 0;
if (scanType & eProfileCPU)
{
// Get current used time.
struct timeval current_used_time;
struct timeval tv;
TIME_VALUE_TO_TIMEVAL(&task_info.user_time, ¤t_used_time);
TIME_VALUE_TO_TIMEVAL(&task_info.system_time, &tv);
timeradd(¤t_used_time, &tv, ¤t_used_time);
task_used_usec = current_used_time.tv_sec * 1000000ULL + current_used_time.tv_usec;
struct timeval current_elapsed_time;
int res = gettimeofday(¤t_elapsed_time, NULL);
if (res == 0)
{
elapsed_usec = current_elapsed_time.tv_sec * 1000000ULL + current_elapsed_time.tv_usec;
}
}
std::vector<uint64_t> threads_id;
std::vector<std::string> threads_name;
std::vector<uint64_t> threads_used_usec;
if (scanType & eProfileThreadsCPU)
{
get_threads_profile_data(scanType, task, m_process->ProcessID(), threads_id, threads_name, threads_used_usec);
}
struct vm_statistics vm_stats;
uint64_t physical_memory;
mach_vm_size_t rprvt = 0;
mach_vm_size_t rsize = 0;
mach_vm_size_t vprvt = 0;
mach_vm_size_t vsize = 0;
mach_vm_size_t dirty_size = 0;
mach_vm_size_t purgeable = 0;
mach_vm_size_t anonymous = 0;
if (m_vm_memory.GetMemoryProfile(scanType, task, task_info, m_process->GetCPUType(), m_process->ProcessID(), vm_stats, physical_memory, rprvt, rsize, vprvt, vsize, dirty_size, purgeable, anonymous))
{
std::ostringstream profile_data_stream;
if (scanType & eProfileHostCPU)
{
profile_data_stream << "num_cpu:" << numCPU << ';';
profile_data_stream << "host_user_ticks:" << host_info.cpu_ticks[CPU_STATE_USER] << ';';
profile_data_stream << "host_sys_ticks:" << host_info.cpu_ticks[CPU_STATE_SYSTEM] << ';';
profile_data_stream << "host_idle_ticks:" << host_info.cpu_ticks[CPU_STATE_IDLE] << ';';
}
if (scanType & eProfileCPU)
{
profile_data_stream << "elapsed_usec:" << elapsed_usec << ';';
profile_data_stream << "task_used_usec:" << task_used_usec << ';';
}
if (scanType & eProfileThreadsCPU)
{
int num_threads = threads_id.size();
for (int i=0; i<num_threads; i++)
{
profile_data_stream << "thread_used_id:" << std::hex << threads_id[i] << std::dec << ';';
profile_data_stream << "thread_used_usec:" << threads_used_usec[i] << ';';
if (scanType & eProfileThreadName)
{
profile_data_stream << "thread_used_name:";
int len = threads_name[i].size();
if (len)
{
const char *thread_name = threads_name[i].c_str();
// Make sure that thread name doesn't interfere with our delimiter.
profile_data_stream << RAW_HEXBASE << std::setw(2);
const uint8_t *ubuf8 = (const uint8_t *)(thread_name);
for (int j=0; j<len; j++)
{
profile_data_stream << (uint32_t)(ubuf8[j]);
}
// Reset back to DECIMAL.
profile_data_stream << DECIMAL;
}
profile_data_stream << ';';
}
}
}
if (scanType & eProfileHostMemory)
profile_data_stream << "total:" << physical_memory << ';';
if (scanType & eProfileMemory)
{
static vm_size_t pagesize;
static bool calculated = false;
if (!calculated)
{
calculated = true;
pagesize = PageSize();
}
profile_data_stream << "wired:" << vm_stats.wire_count * pagesize << ';';
profile_data_stream << "active:" << vm_stats.active_count * pagesize << ';';
profile_data_stream << "inactive:" << vm_stats.inactive_count * pagesize << ';';
uint64_t total_used_count = vm_stats.wire_count + vm_stats.inactive_count + vm_stats.active_count;
profile_data_stream << "used:" << total_used_count * pagesize << ';';
profile_data_stream << "free:" << vm_stats.free_count * pagesize << ';';
profile_data_stream << "rprvt:" << rprvt << ';';
profile_data_stream << "rsize:" << rsize << ';';
profile_data_stream << "vprvt:" << vprvt << ';';
profile_data_stream << "vsize:" << vsize << ';';
if (scanType & eProfileMemoryDirtyPage)
profile_data_stream << "dirty:" << dirty_size << ';';
if (scanType & eProfileMemoryAnonymous)
{
profile_data_stream << "purgeable:" << purgeable << ';';
profile_data_stream << "anonymous:" << anonymous << ';';
}
}
profile_data_stream << "--end--;";
result = profile_data_stream.str();
}
return result;
}
rnb_err_t
RNBSocket::Listen (in_port_t port, PortBoundCallback callback, const void *callback_baton)
{
//DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s called", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__);
// Disconnect without saving errno
Disconnect (false);
DNBError err;
int listen_fd = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_fd == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::socket ( domain = AF_INET, type = SOCK_STREAM, protocol = IPPROTO_TCP ) => socket = %i", listen_fd);
if (err.Fail())
return rnb_err;
// enable local address reuse
SetSocketOption (listen_fd, SOL_SOCKET, SO_REUSEADDR, 1);
struct sockaddr_in sa;
::memset (&sa, 0, sizeof sa);
sa.sin_len = sizeof sa;
sa.sin_family = AF_INET;
sa.sin_port = htons (port);
sa.sin_addr.s_addr = htonl (INADDR_ANY);
int error = ::bind (listen_fd, (struct sockaddr *) &sa, sizeof(sa));
if (error == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::bind ( socket = %i, (struct sockaddr *) &sa, sizeof(sa)) )", listen_fd);
if (err.Fail())
{
ClosePort (listen_fd, false);
return rnb_err;
}
if (callback && port == 0)
{
// We were asked to listen on port zero which means we
// must now read the actual port that was given to us
// as port zero is a special code for "find an open port
// for me".
socklen_t sa_len = sizeof (sa);
if (getsockname(listen_fd, (struct sockaddr *)&sa, &sa_len) == 0)
{
port = ntohs (sa.sin_port);
callback (callback_baton, port);
}
}
error = ::listen (listen_fd, 1);
if (error == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::listen ( socket = %i, backlog = 1 )", listen_fd);
if (err.Fail())
{
ClosePort (listen_fd, false);
return rnb_err;
}
m_fd = ::accept (listen_fd, NULL, 0);
if (m_fd == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::accept ( socket = %i, address = NULL, address_len = 0 )", listen_fd);
ClosePort (listen_fd, false);
if (err.Fail())
{
return rnb_err;
}
else
{
// Keep our TCP packets coming without any delays.
SetSocketOption (m_fd, IPPROTO_TCP, TCP_NODELAY, 1);
}
return rnb_success;
}
rnb_err_t
RNBSocket::Listen (const char *listen_host, uint16_t port, PortBoundCallback callback, const void *callback_baton)
{
//DNBLogThreadedIf(LOG_RNB_COMM, "%8u RNBSocket::%s called", (uint32_t)m_timer.ElapsedMicroSeconds(true), __FUNCTION__);
// Disconnect without saving errno
Disconnect (false);
// Now figure out the hostname that will be attaching and palce it into
struct sockaddr_in listen_addr;
::memset (&listen_addr, 0, sizeof listen_addr);
listen_addr.sin_len = sizeof listen_addr;
listen_addr.sin_family = AF_INET;
listen_addr.sin_port = htons (port);
listen_addr.sin_addr.s_addr = INADDR_ANY;
if (!ResolveIPV4HostName(listen_host, listen_addr.sin_addr.s_addr))
{
DNBLogThreaded("error: failed to resolve connecting host '%s'", listen_host);
return rnb_err;
}
DNBError err;
int listen_fd = ::socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listen_fd == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::socket ( domain = AF_INET, type = SOCK_STREAM, protocol = IPPROTO_TCP ) => socket = %i", listen_fd);
if (err.Fail())
return rnb_err;
// enable local address reuse
SetSocketOption (listen_fd, SOL_SOCKET, SO_REUSEADDR, 1);
struct sockaddr_in sa;
::memset (&sa, 0, sizeof sa);
sa.sin_len = sizeof sa;
sa.sin_family = AF_INET;
sa.sin_port = htons (port);
sa.sin_addr.s_addr = INADDR_ANY; // Let incoming connections bind to any host network interface (this is NOT who can connect to us)
int error = ::bind (listen_fd, (struct sockaddr *) &sa, sizeof(sa));
if (error == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::bind ( socket = %i, (struct sockaddr *) &sa, sizeof(sa)) )", listen_fd);
if (err.Fail())
{
ClosePort (listen_fd, false);
return rnb_err;
}
error = ::listen (listen_fd, 5);
if (error == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::listen ( socket = %i, backlog = 1 )", listen_fd);
if (err.Fail())
{
ClosePort (listen_fd, false);
return rnb_err;
}
if (callback)
{
// We were asked to listen on port zero which means we
// must now read the actual port that was given to us
// as port zero is a special code for "find an open port
// for me".
if (port == 0)
{
socklen_t sa_len = sizeof (sa);
if (getsockname(listen_fd, (struct sockaddr *)&sa, &sa_len) == 0)
{
port = ntohs (sa.sin_port);
callback (callback_baton, port);
}
}
else
{
callback (callback_baton, port);
}
}
struct sockaddr_in accept_addr;
::memset (&accept_addr, 0, sizeof accept_addr);
accept_addr.sin_len = sizeof accept_addr;
bool accept_connection = false;
// Loop until we are happy with our connection
while (!accept_connection)
{
socklen_t accept_addr_len = sizeof accept_addr;
m_fd = ::accept (listen_fd, (struct sockaddr *)&accept_addr, &accept_addr_len);
if (m_fd == -1)
err.SetError(errno, DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
err.LogThreaded("::accept ( socket = %i, address = %p, address_len = %u )", listen_fd, &accept_addr, accept_addr_len);
if (err.Fail())
break;
if (listen_addr.sin_addr.s_addr == INADDR_ANY)
accept_connection = true;
else
{
if (accept_addr_len == listen_addr.sin_len &&
accept_addr.sin_addr.s_addr == listen_addr.sin_addr.s_addr)
{
accept_connection = true;
}
else
{
::close (m_fd);
m_fd = -1;
const uint8_t *accept_ip = (const uint8_t *)&accept_addr.sin_addr.s_addr;
const uint8_t *listen_ip = (const uint8_t *)&listen_addr.sin_addr.s_addr;
::fprintf (stderr,
"error: rejecting incoming connection from %u.%u.%u.%u (expecting %u.%u.%u.%u)\n",
accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
DNBLogThreaded ("error: rejecting connection from %u.%u.%u.%u (expecting %u.%u.%u.%u)",
accept_ip[0], accept_ip[1], accept_ip[2], accept_ip[3],
listen_ip[0], listen_ip[1], listen_ip[2], listen_ip[3]);
}
}
}
ClosePort (listen_fd, false);
if (err.Fail())
{
return rnb_err;
}
else
{
// Keep our TCP packets coming without any delays.
SetSocketOption (m_fd, IPPROTO_TCP, TCP_NODELAY, 1);
}
return rnb_success;
}
kern_return_t
MachException::Message::Reply(MachProcess *process, int signal)
{
// Reply to the exception...
DNBError err;
// If we had a soft signal, we need to update the thread first so it can
// continue without signaling
int soft_signal = state.SoftSignal();
if (soft_signal)
{
int state_pid = -1;
if (process->Task().TaskPort() == state.task_port)
{
// This is our task, so we can update the signal to send to it
state_pid = process->ProcessID();
soft_signal = signal;
}
else
{
err = ::pid_for_task(state.task_port, &state_pid);
}
assert (state_pid != -1);
if (state_pid != -1)
{
errno = 0;
if (::ptrace (PT_THUPDATE, state_pid, (caddr_t)state.thread_port, soft_signal) != 0)
err.SetError(errno, DNBError::POSIX);
else
err.Clear();
if (DNBLogCheckLogBit(LOG_EXCEPTIONS) || err.Fail())
err.LogThreaded("::ptrace (request = PT_THUPDATE, pid = 0x%4.4x, tid = 0x%4.4x, signal = %i)", state_pid, state.thread_port, soft_signal);
}
}
DNBLogThreadedIf(LOG_EXCEPTIONS, "::mach_msg ( msg->{bits = %#x, size = %u, remote_port = %#x, local_port = %#x, reserved = 0x%x, id = 0x%x}, option = %#x, send_size = %u, rcv_size = %u, rcv_name = %#x, timeout = %u, notify = %#x)",
reply_msg.hdr.msgh_bits,
reply_msg.hdr.msgh_size,
reply_msg.hdr.msgh_remote_port,
reply_msg.hdr.msgh_local_port,
reply_msg.hdr.msgh_reserved,
reply_msg.hdr.msgh_id,
MACH_SEND_MSG | MACH_SEND_INTERRUPT,
reply_msg.hdr.msgh_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
err = ::mach_msg ( &reply_msg.hdr,
MACH_SEND_MSG | MACH_SEND_INTERRUPT,
reply_msg.hdr.msgh_size,
0,
MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if (err.Fail())
{
if (err.Error() == MACH_SEND_INTERRUPTED)
{
if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
err.LogThreaded("::mach_msg() - send interrupted");
// TODO: keep retrying to reply???
}
else
{
if (state.task_port == process->Task().TaskPort())
{
if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
err.LogThreaded("::mach_msg() - failed (task)");
abort ();
}
else
{
if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
err.LogThreaded("::mach_msg() - failed (child of task)");
}
}
}
return err.Error();
}
void *
MachTask::ExceptionThread (void *arg)
{
if (arg == NULL)
return NULL;
MachTask *mach_task = (MachTask*) arg;
MachProcess *mach_proc = mach_task->Process();
DNBLogThreadedIf(LOG_EXCEPTIONS, "MachTask::%s ( arg = %p ) starting thread...", __FUNCTION__, arg);
// We keep a count of the number of consecutive exceptions received so
// we know to grab all exceptions without a timeout. We do this to get a
// bunch of related exceptions on our exception port so we can process
// then together. When we have multiple threads, we can get an exception
// per thread and they will come in consecutively. The main loop in this
// thread can stop periodically if needed to service things related to this
// process.
// flag set in the options, so we will wait forever for an exception on
// our exception port. After we get one exception, we then will use the
// MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
// exceptions for our process. After we have received the last pending
// exception, we will get a timeout which enables us to then notify
// our main thread that we have an exception bundle avaiable. We then wait
// for the main thread to tell this exception thread to start trying to get
// exceptions messages again and we start again with a mach_msg read with
// infinite timeout.
uint32_t num_exceptions_received = 0;
DNBError err;
task_t task = mach_task->TaskPort();
mach_msg_timeout_t periodic_timeout = 0;
#if defined (__arm__)
mach_msg_timeout_t watchdog_elapsed = 0;
mach_msg_timeout_t watchdog_timeout = 60 * 1000;
pid_t pid = mach_proc->ProcessID();
CFReleaser<SBSWatchdogAssertionRef> watchdog;
if (mach_proc->ProcessUsingSpringBoard())
{
// Request a renewal for every 60 seconds if we attached using SpringBoard
watchdog.reset(::SBSWatchdogAssertionCreateForPID(NULL, pid, 60));
DNBLogThreadedIf(LOG_TASK, "::SBSWatchdogAssertionCreateForPID (NULL, %4.4x, 60 ) => %p", pid, watchdog.get());
if (watchdog.get())
{
::SBSWatchdogAssertionRenew (watchdog.get());
CFTimeInterval watchdogRenewalInterval = ::SBSWatchdogAssertionGetRenewalInterval (watchdog.get());
DNBLogThreadedIf(LOG_TASK, "::SBSWatchdogAssertionGetRenewalInterval ( %p ) => %g seconds", watchdog.get(), watchdogRenewalInterval);
if (watchdogRenewalInterval > 0.0)
{
watchdog_timeout = (mach_msg_timeout_t)watchdogRenewalInterval * 1000;
if (watchdog_timeout > 3000)
watchdog_timeout -= 1000; // Give us a second to renew our timeout
else if (watchdog_timeout > 1000)
watchdog_timeout -= 250; // Give us a quarter of a second to renew our timeout
}
}
if (periodic_timeout == 0 || periodic_timeout > watchdog_timeout)
periodic_timeout = watchdog_timeout;
}
#endif // #if defined (__arm__)
while (mach_task->ExceptionPortIsValid())
{
::pthread_testcancel ();
MachException::Message exception_message;
if (num_exceptions_received > 0)
{
// No timeout, just receive as many exceptions as we can since we already have one and we want
// to get all currently available exceptions for this task
err = exception_message.Receive(mach_task->ExceptionPort(), MACH_RCV_MSG | MACH_RCV_INTERRUPT | MACH_RCV_TIMEOUT, 0);
}
else if (periodic_timeout > 0)
{
// We need to stop periodically in this loop, so try and get a mach message with a valid timeout (ms)
err = exception_message.Receive(mach_task->ExceptionPort(), MACH_RCV_MSG | MACH_RCV_INTERRUPT | MACH_RCV_TIMEOUT, periodic_timeout);
}
else
{
// We don't need to parse all current exceptions or stop periodically,
// just wait for an exception forever.
err = exception_message.Receive(mach_task->ExceptionPort(), MACH_RCV_MSG | MACH_RCV_INTERRUPT, 0);
}
if (err.Error() == MACH_RCV_INTERRUPTED)
{
// If we have no task port we should exit this thread
if (!mach_task->ExceptionPortIsValid())
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "thread cancelled...");
break;
}
// Make sure our task is still valid
if (MachTask::IsValid(task))
{
// Task is still ok
DNBLogThreadedIf(LOG_EXCEPTIONS, "interrupted, but task still valid, continuing...");
continue;
}
else
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
}
}
else if (err.Error() == MACH_RCV_TIMED_OUT)
{
if (num_exceptions_received > 0)
{
// We were receiving all current exceptions with a timeout of zero
// it is time to go back to our normal looping mode
num_exceptions_received = 0;
// Notify our main thread we have a complete exception message
// bundle available.
mach_proc->ExceptionMessageBundleComplete();
// in case we use a timeout value when getting exceptions...
// Make sure our task is still valid
if (MachTask::IsValid(task))
{
// Task is still ok
DNBLogThreadedIf(LOG_EXCEPTIONS, "got a timeout, continuing...");
continue;
}
else
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "task has exited...");
mach_proc->SetState(eStateExited);
// Our task has died, exit the thread.
break;
}
continue;
}
#if defined (__arm__)
if (watchdog.get())
{
watchdog_elapsed += periodic_timeout;
if (watchdog_elapsed >= watchdog_timeout)
{
DNBLogThreadedIf(LOG_TASK, "SBSWatchdogAssertionRenew ( %p )", watchdog.get());
::SBSWatchdogAssertionRenew (watchdog.get());
watchdog_elapsed = 0;
}
}
#endif
}
else if (err.Error() != KERN_SUCCESS)
{
DNBLogThreadedIf(LOG_EXCEPTIONS, "got some other error, do something about it??? nah, continuing for now...");
// TODO: notify of error?
}
else
{
if (exception_message.CatchExceptionRaise())
{
++num_exceptions_received;
mach_proc->ExceptionMessageReceived(exception_message);
}
}
}
#if defined (__arm__)
if (watchdog.get())
{
// TODO: change SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel when we
// all are up and running on systems that support it. The SBS framework has a #define
// that will forward SBSWatchdogAssertionRelease to SBSWatchdogAssertionCancel for now
// so it should still build either way.
DNBLogThreadedIf(LOG_TASK, "::SBSWatchdogAssertionRelease(%p)", watchdog.get());
::SBSWatchdogAssertionRelease (watchdog.get());
}
#endif // #if defined (__arm__)
DNBLogThreadedIf(LOG_EXCEPTIONS, "MachTask::%s (%p): thread exiting...", __FUNCTION__, arg);
return NULL;
}
