int
resume_thread(unsigned int thread)
{
int i;
kern_return_t ret;
unsigned int size = THREAD_BASIC_INFO_COUNT;
struct thread_basic_info info;
ret = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t) &info, &size);
if(ret != KERN_SUCCESS)
{
fprintf(stderr, "Failed to get thread info 1, got %d\n", ret);
// return ok for the case when the process is going away return -1;
return 0;
}
for(i = 0; i < info.suspend_count; i++)
{
ret = thread_resume(thread);
if(ret != KERN_SUCCESS)
{
fprintf(stderr, "Failed to get thread info 2, got %d\n", ret);
return -1;
}
}
return 0;
}
void xbt_os_threadtimer_resume(xbt_os_timer_t timer)
{
#if HAVE_POSIX_GETTIME
timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
timer->elapse.tv_nsec += timer->stop.tv_nsec - timer->start.tv_nsec;
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->start));
#elif HAVE_GETTIMEOFDAY && defined(__MACH__) && defined(__APPLE__)
timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t thi_data;
thread_basic_info_t thi = &thi_data;
thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)thi, &count);
timer->start.tv_usec = thi->system_time.microseconds + thi->user_time.microseconds;
timer->start.tv_sec = thi->system_time.seconds + thi->user_time.seconds;
#elif HAVE_GETTIMEOFDAY
timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
gettimeofday(&(timer->start), NULL);
#elif defined(_WIN32)
timer->elapse.tv_sec += timer->stop.tv_sec - timer->start.tv_sec;
timer->elapse.tv_usec += timer->stop.tv_usec - timer->start.tv_usec;
HANDLE h = GetCurrentThread();
FILETIME creationTime, exitTime, kernelTime, userTime;
GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
w32_times_to_timeval(&timer->start, &kernelTime, &userTime);
#endif
}
// Returns the time the current thread has spent executing, in milliseconds.
static inline unsigned getCPUTime()
{
#if OS(DARWIN)
mach_msg_type_number_t infoCount = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info;
// Get thread information
mach_port_t threadPort = mach_thread_self();
thread_info(threadPort, THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(&info), &infoCount);
mach_port_deallocate(mach_task_self(), threadPort);
unsigned time = info.user_time.seconds * 1000 + info.user_time.microseconds / 1000;
time += info.system_time.seconds * 1000 + info.system_time.microseconds / 1000;
return time;
#elif OS(WINDOWS)
union {
FILETIME fileTime;
unsigned long long fileTimeAsLong;
} userTime, kernelTime;
// GetThreadTimes won't accept NULL arguments so we pass these even though
// they're not used.
FILETIME creationTime, exitTime;
GetThreadTimes(GetCurrentThread(), &creationTime, &exitTime, &kernelTime.fileTime, &userTime.fileTime);
return userTime.fileTimeAsLong / 10000 + kernelTime.fileTimeAsLong / 10000;
#else
// FIXME: We should return the time the current thread has spent executing.
return currentTime() * 1000;
#endif
}
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;
}
int thread_cpu_usage(uint64_t* user, uint64_t* system) {
#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info;
kern_return_t err;
mach_port_t port = mach_thread_self();
err = thread_info(port, THREAD_BASIC_INFO, (thread_info_t)&info, &count);
mach_port_deallocate(mach_task_self(), port);
if(err == KERN_SUCCESS) {
*user = (uint64_t) info.user_time.seconds * 1000000 + info.user_time.microseconds;
*system = (uint64_t) info.system_time.seconds * 1000000 + info.system_time.microseconds;
return 0;
}
return -1;
#elif defined(RUSAGE_THREAD)
struct rusage buf;
if(getrusage(RUSAGE_THREAD, &buf)) return -1;
*user = (uint64_t)buf.ru_utime.tv_sec * 1000000 + buf.ru_utime.tv_usec;
*system = (uint64_t)buf.ru_stime.tv_sec * 1000000 + buf.ru_stime.tv_usec;
return 0;
#elif defined(_WIN32)
FILETIME unused, unused2;
FILETIME sys, usr;
GetThreadTimes(GetCurrentThread(), &unused, &unused2, &sys, &user);
*user = (((uint64_t) usr.dwHighDateTime) << 32) + usr.dwLowDateTime;
*system = (((uint64_t) sys.dwHighDateTime) << 32) + sys.dwLowDateTime;
return 0;
#else
return -1;
#endif
}
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;
}
BOOL WINAPI GetThreadTimes (
HANDLE hThread,
LPFILETIME lpCreationTime,
LPFILETIME lpExitTime,
LPFILETIME lpKernelTime,
LPFILETIME lpUserTime
) {
if (!hThread)
return false;
if (!hThread->m_threadValid)
return false;
if (hThread == (HANDLE)-1) {
if (lpCreationTime)
TimeTToFileTime(0,lpCreationTime);
if (lpExitTime)
TimeTToFileTime(time(NULL),lpExitTime);
if (lpKernelTime)
TimeTToFileTime(0,lpKernelTime);
if (lpUserTime)
TimeTToFileTime(0,lpUserTime);
return true;
}
if (lpCreationTime)
TimeTToFileTime(hThread->m_tmCreation,lpCreationTime);
if (lpExitTime)
TimeTToFileTime(time(NULL),lpExitTime);
if (lpKernelTime)
TimeTToFileTime(0,lpKernelTime);
#ifdef __APPLE__
thread_info_data_t threadInfo;
mach_msg_type_number_t threadInfoCount = THREAD_INFO_MAX;
if (hThread->m_machThreadPort == MACH_PORT_NULL)
hThread->m_machThreadPort = pthread_mach_thread_np(hThread->m_hThread);
kern_return_t ret = thread_info(hThread->m_machThreadPort, THREAD_BASIC_INFO, (thread_info_t)threadInfo, &threadInfoCount);
if (ret == KERN_SUCCESS)
{
thread_basic_info_t threadBasicInfo = (thread_basic_info_t)threadInfo;
if (lpUserTime)
{
// User time.
unsigned long long time = ((__int64)threadBasicInfo->user_time.seconds * 10000000L) + threadBasicInfo->user_time.microseconds*10L;
lpUserTime->dwLowDateTime = (time & 0xFFFFFFFF);
lpUserTime->dwHighDateTime = (time >> 32);
}
if (lpKernelTime)
{
// System time.
unsigned long long time = ((__int64)threadBasicInfo->system_time.seconds * 10000000L) + threadBasicInfo->system_time.microseconds*10L;
lpKernelTime->dwLowDateTime = (time & 0xFFFFFFFF);
lpKernelTime->dwHighDateTime = (time >> 32);
}
}
static void
info_mach_thread_command (char *args, int from_tty)
{
union
{
struct thread_basic_info basic;
} thread_info_data;
thread_t thread;
kern_return_t result;
unsigned int info_count;
CHECK_ARGS (_("Thread"), args);
sscanf (args, "0x%x", &thread);
printf_unfiltered (_("THREAD_BASIC_INFO\n"));
info_count = THREAD_BASIC_INFO_COUNT;
result = thread_info (thread,
THREAD_BASIC_INFO,
(thread_info_t) & thread_info_data.basic,
&info_count);
MACH_CHECK_ERROR (result);
#if 0
PRINT_FIELD (&thread_info_data.basic, user_time);
PRINT_FIELD (&thread_info_data.basic, system_time);
#endif
PRINT_FIELD (&thread_info_data.basic, cpu_usage);
PRINT_FIELD (&thread_info_data.basic, run_state);
PRINT_FIELD (&thread_info_data.basic, flags);
PRINT_FIELD (&thread_info_data.basic, suspend_count);
PRINT_FIELD (&thread_info_data.basic, sleep_time);
}
void xbt_os_threadtimer_stop(xbt_os_timer_t timer)
{
#ifdef HAVE_POSIX_GETTIME
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &(timer->stop));
#elif defined(HAVE_GETTIMEOFDAY) && defined(__MACH__) && defined(__APPLE__)
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t thi_data;
thread_basic_info_t thi = &thi_data;
thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)thi, &count);
timer->stop.tv_usec = thi->system_time.microseconds + thi->user_time.microseconds;
timer->stop.tv_sec = thi->system_time.seconds + thi->user_time.seconds;
#elif defined(HAVE_GETTIMEOFDAY)//if nothing else is available, return just time
gettimeofday(&(timer->stop), NULL);
#elif defined(_XBT_WIN32)
# if defined(WIN32_WCE) || (_WIN32_WINNT < 0x0400)
THROW_UNIMPLEMENTED;
# else
HANDLE h = GetCurrentThread();
FILETIME creationTime, exitTime, kernelTime, userTime;
GetThreadTimes(h, &creationTime, &exitTime, &kernelTime, &userTime);
unsigned __int64 ktm, utm;
ktm = (unsigned __int64) kernelTime.dwHighDateTime << 32;
ktm |= kernelTime.dwLowDateTime;
ktm /= 10;
utm = (unsigned __int64) userTime.dwHighDateTime << 32;
utm |= userTime.dwLowDateTime;
utm /= 10;
timer->stop.tv_sec = (long) (ktm / 1000000L) + (long) (utm / 1000000L);
timer->stop.tv_usec = (long) (ktm % 1000000L) + (long) (utm % 1000000L);
# endif /* windows version checker */
#endif
}
void ProcessorMetric::UpdateTimeInt(double &user_time, double &system_time) {
#ifdef RUSAGE_THREAD // RUSAGE_THREAD is Linux-specific.
struct rusage usage;
int ret = getrusage(RUSAGE_THREAD, &usage);
if (ret != 0) {
throw StatException("Error getting resource usage");
}
user_time = GetMilliSec(usage.ru_utime);
system_time = GetMilliSec(usage.ru_stime);
#else // https://stackoverflow.com/questions/13893134/get-current-pthread-cpu-usage-mac-os-x
mach_port_t thread = mach_thread_self();
thread_basic_info_data_t info;
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
kern_return_t kr = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t) &info, &count);
if (kr == KERN_SUCCESS && (info.flags & TH_FLAGS_IDLE) == 0) {
user_time = ((double) info.user_time.microseconds) / 1000;
system_time = ((double) info.system_time.microseconds) / 1000;
}
else {
throw StatException("Error getting resource usage");
}
mach_port_deallocate(mach_task_self(), thread);
#endif
}
void
_dispatch_introspection_init(void)
{
TAILQ_INSERT_TAIL(&_dispatch_introspection_queues,
&_dispatch_main_q, diq_list);
TAILQ_INSERT_TAIL(&_dispatch_introspection_queues,
&_dispatch_mgr_q, diq_list);
#if DISPATCH_ENABLE_PTHREAD_ROOT_QUEUES
TAILQ_INSERT_TAIL(&_dispatch_introspection_queues,
_dispatch_mgr_q.do_targetq, diq_list);
#endif
for (size_t i = 0; i < DISPATCH_ROOT_QUEUE_COUNT; i++) {
TAILQ_INSERT_TAIL(&_dispatch_introspection_queues,
&_dispatch_root_queues[i], diq_list);
}
// Hack to determine queue TSD offset from start of pthread structure
uintptr_t thread = _dispatch_thread_self();
thread_identifier_info_data_t tiid;
mach_msg_type_number_t cnt = THREAD_IDENTIFIER_INFO_COUNT;
kern_return_t kr = thread_info(pthread_mach_thread_np((void*)thread),
THREAD_IDENTIFIER_INFO, (thread_info_t)&tiid, &cnt);
if (!dispatch_assume_zero(kr)) {
_dispatch_introspection_thread_queue_offset =
(void*)(uintptr_t)tiid.dispatch_qaddr - (void*)thread;
}
_dispatch_thread_key_create(&dispatch_introspection_key,
_dispatch_introspection_thread_remove);
_dispatch_introspection_thread_add(); // add main thread
}
long long
tickcount(void)
{
long long rc;
rc = 0;
if (g_clock_type == CPU_CLOCK) {
kern_return_t kr;
thread_basic_info_t tinfo_b;
thread_info_data_t tinfo_d;
mach_msg_type_number_t tinfo_cnt;
tinfo_cnt = THREAD_INFO_MAX;
kr = thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)tinfo_d, &tinfo_cnt);
tinfo_b = (thread_basic_info_t)tinfo_d;
if (!(tinfo_b->flags & TH_FLAGS_IDLE))
{
rc = (tinfo_b->user_time.seconds + tinfo_b->system_time.seconds);
rc = (rc * 1000000) + (tinfo_b->user_time.microseconds + tinfo_b->system_time.microseconds);
}
} else if (g_clock_type == WALL_CLOCK) {
rc = gettimeofday_usec();
}
return rc;
}
bool ksmach_getThreadQueueName(const thread_t thread,
char* const buffer,
size_t bufLength)
{
// WARNING: This implementation is no longer async-safe!
integer_t infoBuffer[THREAD_IDENTIFIER_INFO_COUNT] = {0};
thread_info_t info = infoBuffer;
mach_msg_type_number_t inOutSize = THREAD_IDENTIFIER_INFO_COUNT;
kern_return_t kr = 0;
kr = thread_info(thread, THREAD_IDENTIFIER_INFO, info, &inOutSize);
if(kr != KERN_SUCCESS)
{
KSLOG_TRACE("Error getting thread_info with flavor THREAD_IDENTIFIER_INFO from mach thread : %s", mach_error_string(kr));
return false;
}
thread_identifier_info_t idInfo = (thread_identifier_info_t)info;
dispatch_queue_t* dispatch_queue_ptr = (dispatch_queue_t*)idInfo->dispatch_qaddr;
//thread_handle shouldn't be 0 also, because
//identifier_info->dispatch_qaddr = identifier_info->thread_handle + get_dispatchqueue_offset_from_proc(thread->task->bsd_info);
if(dispatch_queue_ptr == NULL || idInfo->thread_handle == 0 || *dispatch_queue_ptr == NULL)
{
KSLOG_TRACE("This thread doesn't have a dispatch queue attached : %p", thread);
return false;
}
dispatch_queue_t dispatch_queue = *dispatch_queue_ptr;
const char* queue_name = dispatch_queue_get_label(dispatch_queue);
if(queue_name == NULL)
{
KSLOG_TRACE("Error while getting dispatch queue name : %p", dispatch_queue);
return false;
}
KSLOG_TRACE("Dispatch queue name: %s", queue_name);
size_t length = strlen(queue_name);
// Queue label must be a null terminated string.
size_t iLabel;
for(iLabel = 0; iLabel < length + 1; iLabel++)
{
if(queue_name[iLabel] < ' ' || queue_name[iLabel] > '~')
{
break;
}
}
if(queue_name[iLabel] != 0)
{
// Found a non-null, invalid char.
KSLOG_TRACE("Queue label contains invalid chars");
return false;
}
bufLength = MIN(length, bufLength - 1);//just strlen, without null-terminator
strncpy(buffer, queue_name, bufLength);
buffer[bufLength] = 0;//terminate string
KSLOG_TRACE("Queue label = %s", buffer);
return true;
}
/*
* Get system information
*/
int
sys_info(int type, void *buf)
{
struct info_memory infomem;
struct info_timer infotmr;
struct info_thread infothr;
struct info_device infodev;
int err = 0;
if (buf == NULL || !user_area(buf))
return EFAULT;
sched_lock();
switch (type) {
case INFO_KERNEL:
err = umem_copyout(&infokern, buf, sizeof(infokern));
break;
case INFO_MEMORY:
page_info(&infomem);
kpage_info(&infomem);
err = umem_copyout(&infomem, buf, sizeof(infomem));
break;
case INFO_THREAD:
if (umem_copyin(buf, &infothr, sizeof(infothr))) {
err = EFAULT;
break;
}
if ((err = thread_info(&infothr)))
break;
infothr.cookie++;
err = umem_copyout(&infothr, buf, sizeof(infothr));
break;
case INFO_DEVICE:
if (umem_copyin(buf, &infodev, sizeof(infodev))) {
err = EFAULT;
break;
}
if ((err = device_info(&infodev)))
break;
infodev.cookie++;
err = umem_copyout(&infodev, buf, sizeof(infodev));
break;
case INFO_TIMER:
timer_info(&infotmr);
err = umem_copyout(&infotmr, buf, sizeof(infotmr));
break;
default:
err = EINVAL;
break;
}
sched_unlock();
return err;
}
DWORD FileProcessor::Run(LPVOID /*arg*/)
{
if( PP ){
FileEntry entry;
nProcessed = 0;
while( !PP->quitRequested() && (isBackwards ? PP->getBack(entry) : PP->getFront(entry)) ){
// create a scoped lock without closing it immediately
CRITSECTLOCK::Scope scp(PP->ioLock, 0);
scope = &scp;
currentEntry = &entry;
_InterlockedIncrement(&PP->nProcessing);
entry.compress( this, PP );
_InterlockedDecrement(&PP->nProcessing);
_InterlockedIncrement(&PP->nProcessed);
currentEntry = NULL;
nProcessed += 1;
scope = NULL;
runningTotalRaw += entry.fileInfo.st_size;
runningTotalCompressed += (entry.compressedSize > 0)? entry.compressedSize : entry.fileInfo.st_size;
/*if( PP->verbose() > 1 )*/{
#if defined(__MACH__)
mach_port_t thread = mach_thread_self();
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info;
int kr = thread_info(thread, THREAD_BASIC_INFO, (thread_info_t) &info, &count);
if( kr == KERN_SUCCESS ){
userTime = info.user_time.seconds + info.user_time.microseconds * 1e-6;
systemTime = info.system_time.seconds + info.system_time.microseconds * 1e-6;
avCPUUsage += info.cpu_usage * 100.0 / TH_USAGE_SCALE;
threadInfo = info;
hasInfo = true;
}
mach_port_deallocate(mach_task_self(), thread);
#elif defined(linux)
struct rusage rtu;
if (!getrusage(RUSAGE_THREAD, &rtu)) {
const auto ut = rtu.ru_utime.tv_sec + rtu.ru_utime.tv_usec * 1e-6;
const auto st = rtu.ru_stime.tv_sec + rtu.ru_stime.tv_usec * 1e-6;
if (ut >= 0 && st >= 0) {
userTime = ut, systemTime = st, hasInfo = true;
}
}
# ifdef CLOCK_THREAD_CPUTIME_ID
struct timespec ts;
if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) != -1) {
cpuTime = ts.tv_sec + ts.tv_nsec * 1e-9;
double t = userTime + systemTime;
if (cpuTime > 0) {
avCPUUsage += t * 100.0 / cpuTime;
}
}
# endif
#endif
}
}
}
return DWORD(nProcessed);
}
void Message::operator()() {
if ( num % 5 == 0) {
// int j = 1 / (i % 5);
throw boost::enable_current_exception(thread_error()) << thread_info("Whazzup?");
} else {
Logger::log(info, str());
}
}
__private_extern__
kern_return_t chudxnu_thread_info(thread_act_t thr_act,
thread_flavor_t flavor,
thread_info_t thread_info_out,
mach_msg_type_number_t *thread_info_count)
{
return thread_info(thr_act, flavor, thread_info_out, thread_info_count);
}
//------------------------------------------------------------------------------
// Name: open
// Desc:
//------------------------------------------------------------------------------
bool DebuggerCore::open(const QString &path, const QString &cwd, const QList<QByteArray> &args, const QString &tty) {
detach();
pid_t pid;
switch(pid = fork()) {
case 0:
// we are in the child now...
// set ourselves (the child proc) up to be traced
ptrace(PT_TRACE_ME, 0, 0, 0);
// redirect it's I/O
if(!tty.isEmpty()) {
FILE *const std_out = freopen(qPrintable(tty), "r+b", stdout);
FILE *const std_in = freopen(qPrintable(tty), "r+b", stdin);
FILE *const std_err = freopen(qPrintable(tty), "r+b", stderr);
Q_UNUSED(std_out);
Q_UNUSED(std_in);
Q_UNUSED(std_err);
}
// do the actual exec
execute_process(path, cwd, args);
// we should never get here!
abort();
break;
case -1:
// error!
pid_ = 0;
return false;
default:
// parent
do {
threads_.clear();
int status;
if(native::waitpid(pid, &status, 0) == -1) {
return false;
}
// the very first event should be a STOP of type SIGTRAP
if(!WIFSTOPPED(status) || WSTOPSIG(status) != SIGTRAP) {
detach();
return false;
}
// setup the first event data for the primary thread
threads_.insert(pid, thread_info());
pid_ = pid;
active_thread_ = pid;
threads_[pid].status = status;
return true;
} while(0);
break;
}
}
static void thread_parse_child_update_response(protocol_interface_info_entry_t *cur, mle_message_t *mle_msg, mle_security_header_t *security_headers, uint8_t linkMargin)
{
uint8_t mode;
uint32_t timeout;
mle_neigh_table_entry_t *entry_temp;
thread_leader_data_t leaderData = {0};
uint8_t status;
bool leader_data_received;
tr_debug("Child Update Response");
leader_data_received = thread_leader_data_parse(mle_msg->data_ptr, mle_msg->data_length, &leaderData);
entry_temp = mle_class_get_entry_by_ll64(cur->id, linkMargin, mle_msg->packet_src_address, false);
if (mle_tlv_read_8_bit_tlv(MLE_TYPE_STATUS, mle_msg->data_ptr, mle_msg->data_length, &status) &&
status == 1 && thread_check_is_this_my_parent(cur, entry_temp)) {
tr_debug("parent has connection error");
thread_bootstrap_connection_error(cur->id, CON_PARENT_CONNECT_DOWN, NULL);
return;
}
if (!entry_temp) {
tr_debug("Not Neighbor");
mle_tlv_info_t challengeTlv;
mle_tlv_read_tlv(MLE_TYPE_CHALLENGE, mle_msg->data_ptr, mle_msg->data_length, &challengeTlv);
thread_host_bootstrap_child_update_negative_response(cur, mle_msg->packet_src_address, &challengeTlv);
return;
}
if ((security_headers->KeyIdMode == MAC_KEY_ID_MODE_SRC4_IDX)
&& (thread_instance_id_matches(cur, &leaderData))) {
thread_management_key_synch_req(cur->id, common_read_32_bit(security_headers->Keysource));
} else {
tr_debug("Key ID Mode 2 not used; dropped.");
return;
}
if (!mle_tlv_read_8_bit_tlv(MLE_TYPE_MODE, mle_msg->data_ptr, mle_msg->data_length, &mode)) {
tr_debug("No Mode");
return;
}
if (mle_tlv_read_32_bit_tlv(MLE_TYPE_TIMEOUT, mle_msg->data_ptr, mle_msg->data_length, &timeout)) {
entry_temp->holdTime = 90;
tr_debug("Setting child timeout, value=%"PRIu32, timeout);
mle_entry_timeout_update(entry_temp, timeout);
thread_info(cur)->thread_endnode_parent->childUpdateProcessStatus = true;
}
tr_debug("Keep-Alive -->Respond from Parent");
mle_entry_timeout_refresh(entry_temp);
//Save possible new Leader Data
if (leader_data_received) {
thread_save_leader_data(cur, &leaderData);
}
mac_data_poll_protocol_poll_mode_decrement(cur);
}
UInt32 ZKMORHP_ForeignThread::getScheduledPriority(pthread_t inThread, int inPriorityKind)
{
thread_basic_info_data_t threadInfo;
policy_info_data_t thePolicyInfo;
unsigned int count;
if (inThread == NULL)
return 0;
// get basic info
count = THREAD_BASIC_INFO_COUNT;
thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO, (thread_info_t)&threadInfo, &count);
switch (threadInfo.policy) {
case POLICY_TIMESHARE:
count = POLICY_TIMESHARE_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&(thePolicyInfo.ts), &count);
if (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) {
return thePolicyInfo.ts.cur_priority;
}
return thePolicyInfo.ts.base_priority;
break;
case POLICY_FIFO:
count = POLICY_FIFO_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_FIFO_INFO, (thread_info_t)&(thePolicyInfo.fifo), &count);
if ( (thePolicyInfo.fifo.depressed) && (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) ) {
return thePolicyInfo.fifo.depress_priority;
}
return thePolicyInfo.fifo.base_priority;
break;
case POLICY_RR:
count = POLICY_RR_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_RR_INFO, (thread_info_t)&(thePolicyInfo.rr), &count);
if ( (thePolicyInfo.rr.depressed) && (inPriorityKind == CAPTHREAD_SCHEDULED_PRIORITY) ) {
return thePolicyInfo.rr.depress_priority;
}
return thePolicyInfo.rr.base_priority;
break;
}
return 0;
}
static int thread_host_child_update_response_send(protocol_interface_info_entry_t *cur, uint8_t *dst_address, mle_tlv_info_t *challengeTlv, mle_tlv_info_t *requestTlv)
{
uint16_t len = 150 + 64;
uint8_t mode;
uint32_t keySequence;
uint8_t *ptr;
if (!thread_info(cur)) {
return -1;
}
uint16_t bufId = mle_service_msg_allocate(cur->id, len, false, MLE_COMMAND_CHILD_UPDATE_RESPONSE);
if (bufId == 0) {
return -1;
}
tr_debug("MLE Child update response");
thread_management_get_current_keysequence(cur->id, &keySequence);
mle_service_msg_update_security_params(bufId, 5, 2, keySequence);
ptr = mle_service_get_data_pointer(bufId);
mode = thread_mode_get_by_interface_ptr(cur);
//Write Mode Allways
ptr = mle_tlv_write_mode(ptr, mode);
//Set SRC
ptr = mle_general_write_source_address(ptr, cur);
//SET leader data
ptr = thread_leader_data_tlv_write(ptr, cur);
//Set Addresss TLV
if (requestTlv && mle_tlv_requested(requestTlv->dataPtr,requestTlv->tlvLen,MLE_TYPE_ADDRESS_REGISTRATION) &&
(mode & MLE_FFD_DEV) == 0) {
ptr = thread_address_registration_tlv_write(ptr, cur);
}
if (requestTlv && mle_tlv_requested(requestTlv->dataPtr,requestTlv->tlvLen,MLE_TYPE_TIMEOUT)) {
ptr = mle_tlv_write_timeout(ptr, cur->thread_info->host_link_timeout);
}
if (challengeTlv && challengeTlv->tlvLen) {
ptr = mle_tlv_write_response(ptr, challengeTlv->dataPtr, challengeTlv->tlvLen);
ptr = mle_general_write_link_layer_framecounter(ptr, cur);
//SET MLE Frame Counter
ptr = mle_tlv_write_framecounter(ptr, mle_service_security_get_frame_counter(cur->id));
}
if (mle_service_update_length_by_ptr(bufId,ptr)!= 0) {
tr_debug("Buffer overflow at message write");
}
mle_service_set_msg_destination_address(bufId, dst_address);
mle_service_send_message(bufId);
return 0;
}
// Get the messenger from thread information
static messenger_t* get_messenger()
{
messenger_t* msger;
THREAD_INFO* ti = thread_info();
msger = ti->messenger;
if( !msger )
ti->messenger = msger = (messenger_t*)
malloc(sizeof(messenger_t));
return msger;
}
UInt32 _getThreadPriority (pthread_t inThread, int inWhichPriority)
{
thread_basic_info_data_t threadInfo;
policy_info_data_t thePolicyInfo;
unsigned int count;
// get basic info
count = THREAD_BASIC_INFO_COUNT;
thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO, (thread_info_t)&threadInfo, &count);
switch (threadInfo.policy) {
case POLICY_TIMESHARE:
count = POLICY_TIMESHARE_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&(thePolicyInfo.ts), &count);
if (inWhichPriority == THREAD_SCHEDULED_PRIORITY) {
return thePolicyInfo.ts.cur_priority;
} else {
return thePolicyInfo.ts.base_priority;
}
break;
case POLICY_FIFO:
count = POLICY_FIFO_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_FIFO_INFO, (thread_info_t)&(thePolicyInfo.fifo), &count);
if ( (thePolicyInfo.fifo.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) {
return thePolicyInfo.fifo.depress_priority;
}
return thePolicyInfo.fifo.base_priority;
break;
case POLICY_RR:
count = POLICY_RR_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_RR_INFO, (thread_info_t)&(thePolicyInfo.rr), &count);
if ( (thePolicyInfo.rr.depressed) && (inWhichPriority == THREAD_SCHEDULED_PRIORITY) ) {
return thePolicyInfo.rr.depress_priority;
}
return thePolicyInfo.rr.base_priority;
break;
}
return 0;
}
/**
* Get's the priority information for the current thread.
*
* @returns The base priority
*/
static int rtSchedDarwinGetBasePriority(void)
{
/* the base_priority. */
mach_msg_type_number_t Count = POLICY_TIMESHARE_INFO_COUNT;
struct policy_timeshare_info TSInfo = {0,0,0,0,0};
kern_return_t krc;
krc = thread_info(mach_thread_self(), THREAD_SCHED_TIMESHARE_INFO, (thread_info_t)&TSInfo, &Count);
Assert(krc == KERN_SUCCESS);
return TSInfo.base_priority;
}
Seconds CPUTime::forCurrentThread()
{
mach_msg_type_number_t infoCount = THREAD_BASIC_INFO_COUNT;
thread_basic_info_data_t info;
auto threadPort = MachSendRight::adopt(mach_thread_self());
auto ret = thread_info(threadPort.sendRight(), THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(&info), &infoCount);
RELEASE_ASSERT(ret == KERN_SUCCESS);
return Seconds(info.user_time.seconds + info.system_time.seconds) + Seconds::fromMicroseconds(info.user_time.microseconds + info.system_time.microseconds);
}
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;
}
UInt32 FileReaderThread::GetThreadBasePriority (pthread_t inThread)
{
thread_basic_info_data_t threadInfo;
policy_info_data_t thePolicyInfo;
unsigned int count;
// get basic info
count = THREAD_BASIC_INFO_COUNT;
thread_info (pthread_mach_thread_np (inThread), THREAD_BASIC_INFO, (integer_t*)&threadInfo, &count);
switch (threadInfo.policy) {
case POLICY_TIMESHARE:
count = POLICY_TIMESHARE_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_TIMESHARE_INFO, (integer_t*)&(thePolicyInfo.ts), &count);
return thePolicyInfo.ts.base_priority;
break;
case POLICY_FIFO:
count = POLICY_FIFO_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_FIFO_INFO, (integer_t*)&(thePolicyInfo.fifo), &count);
if (thePolicyInfo.fifo.depressed) {
return thePolicyInfo.fifo.depress_priority;
} else {
return thePolicyInfo.fifo.base_priority;
}
break;
case POLICY_RR:
count = POLICY_RR_INFO_COUNT;
thread_info(pthread_mach_thread_np (inThread), THREAD_SCHED_RR_INFO, (integer_t*)&(thePolicyInfo.rr), &count);
if (thePolicyInfo.rr.depressed) {
return thePolicyInfo.rr.depress_priority;
} else {
return thePolicyInfo.rr.base_priority;
}
break;
}
return 0;
}
// If thread t is suspended, start it up again.
// If singlestep is set, only let it execute one instruction.
static int
threadstart(Thread *t, int singlestep)
{
int i;
uint n;
struct thread_basic_info info;
if(!threadstopped(t))
return 0;
// Set or clear the processor single-step flag, as appropriate.
if(mach == &mi386) {
x86_thread_state32_t regs;
n = x86_THREAD_STATE32_COUNT;
if(me(thread_get_state(t->thread, x86_THREAD_STATE32,
(thread_state_t)®s,
&n)) < 0)
return -1;
if(singlestep)
regs.eflags |= FLAGS_TF;
else
regs.eflags &= ~FLAGS_TF;
if(me(thread_set_state(t->thread, x86_THREAD_STATE32,
(thread_state_t)®s,
x86_THREAD_STATE32_COUNT)) < 0)
return -1;
} else {
x86_thread_state64_t regs;
n = x86_THREAD_STATE64_COUNT;
if(me(thread_get_state(t->thread, x86_THREAD_STATE64,
(thread_state_t)®s,
&n)) < 0)
return -1;
if(singlestep)
regs.rflags |= FLAGS_TF;
else
regs.rflags &= ~FLAGS_TF;
if(me(thread_set_state(t->thread, x86_THREAD_STATE64,
(thread_state_t)®s,
x86_THREAD_STATE64_COUNT)) < 0)
return -1;
}
// Run.
n = sizeof info;
if(me(thread_info(t->thread, THREAD_BASIC_INFO, (thread_info_t)&info, &n)) < 0)
return -1;
for(i=0; i<info.suspend_count; i++)
if(me(thread_resume(t->thread)) < 0)
return -1;
return 0;
}
// Is thread t suspended?
static int
threadstopped(Thread *t)
{
struct thread_basic_info info;
uint size;
size = sizeof info;
if(me(thread_info(t->thread, THREAD_BASIC_INFO, (thread_info_t)&info, &size)) < 0){
fprint(2, "threadstopped thread_info %#x: %r\n");
return 1;
}
return info.suspend_count > 0;
}
static bool thread_reed_partitions_merge(protocol_interface_info_entry_t *cur, uint16_t shortAddress, thread_leader_data_t heard_partition_leader_data)
{
if (thread_is_router_addr(shortAddress)) {
return false;
}
if (thread_extension_version_check(thread_info(cur)->version)) {
// lower weighting heard
if (thread_info(cur)->thread_leader_data->weighting > heard_partition_leader_data.weighting) {
return false;
}
// lower/same partition id heard
if (thread_info(cur)->thread_leader_data->weighting == heard_partition_leader_data.weighting &&
thread_info(cur)->thread_leader_data->partitionId >= heard_partition_leader_data.partitionId ) {
return false;
}
} else if (thread_info(cur)->thread_leader_data->partitionId >= heard_partition_leader_data.partitionId){
return false;
}
// can merge to a higher weighting/partition id
thread_bootstrap_connection_error(cur->id, CON_ERROR_PARTITION_MERGE, NULL);
return true;
}
