/** @todo move this into platform specific files. */
RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t *pKernelTime, uint64_t *pUserTime)
{
#if defined(RT_OS_SOLARIS)
struct rusage ts;
int rc = getrusage(RUSAGE_LWP, &ts);
if (rc)
return RTErrConvertFromErrno(rc);
*pKernelTime = ts.ru_stime.tv_sec * 1000 + ts.ru_stime.tv_usec / 1000;
*pUserTime = ts.ru_utime.tv_sec * 1000 + ts.ru_utime.tv_usec / 1000;
return VINF_SUCCESS;
#elif defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD)
/* on Linux, getrusage(RUSAGE_THREAD, ...) is available since 2.6.26 */
struct timespec ts;
int rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
if (rc)
return RTErrConvertFromErrno(rc);
*pKernelTime = 0;
*pUserTime = (uint64_t)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
return VINF_SUCCESS;
#elif defined(RT_OS_DARWIN)
thread_basic_info ThreadInfo;
mach_msg_type_number_t Count = THREAD_BASIC_INFO_COUNT;
kern_return_t krc = thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)&ThreadInfo, &Count);
AssertReturn(krc == KERN_SUCCESS, RTErrConvertFromDarwinKern(krc));
*pKernelTime = ThreadInfo.system_time.seconds * 1000 + ThreadInfo.system_time.microseconds / 1000;
*pUserTime = ThreadInfo.user_time.seconds * 1000 + ThreadInfo.user_time.microseconds / 1000;
return VINF_SUCCESS;
#elif defined(RT_OS_HAIKU)
thread_info ThreadInfo;
status_t status = get_thread_info(find_thread(NULL), &ThreadInfo);
AssertReturn(status == B_OK, RTErrConvertFromErrno(status));
*pKernelTime = ThreadInfo.kernel_time / 1000;
*pUserTime = ThreadInfo.user_time / 1000;
return VINF_SUCCESS;
#else
return VERR_NOT_IMPLEMENTED;
#endif
}
int CollectorDarwin::getRawHostCpuLoad(uint64_t *user, uint64_t *kernel, uint64_t *idle)
{
kern_return_t krc;
mach_msg_type_number_t count;
host_cpu_load_info_data_t info;
count = HOST_CPU_LOAD_INFO_COUNT;
krc = host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&info, &count);
if (krc != KERN_SUCCESS)
{
Log(("host_statistics() -> %s", mach_error_string(krc)));
return RTErrConvertFromDarwinKern(krc);
}
*user = (uint64_t)info.cpu_ticks[CPU_STATE_USER]
+ info.cpu_ticks[CPU_STATE_NICE];
*kernel = (uint64_t)info.cpu_ticks[CPU_STATE_SYSTEM];
*idle = (uint64_t)info.cpu_ticks[CPU_STATE_IDLE];
return VINF_SUCCESS;
}
USBLIB_DECL(int) USBLibInit(void)
{
/*
* Already open?
* This isn't properly serialized, but we'll be fine with the current usage.
*/
if (g_cUsers)
{
ASMAtomicIncU32(&g_cUsers);
return VINF_SUCCESS;
}
/*
* Finding the VBoxUSB service.
*/
mach_port_t MasterPort;
kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort);
if (kr != kIOReturnSuccess)
{
LogRel(("USBLib: IOMasterPort -> %#x\n", kr));
return RTErrConvertFromDarwinKern(kr);
}
CFDictionaryRef ClassToMatch = IOServiceMatching(IOCLASS_NAME);
if (!ClassToMatch)
{
LogRel(("USBLib: IOServiceMatching(\"%s\") failed.\n", IOCLASS_NAME));
return VERR_GENERAL_FAILURE;
}
/* Create an io_iterator_t for all instances of our drivers class that exist in the IORegistry. */
io_iterator_t Iterator;
kr = IOServiceGetMatchingServices(g_MasterPort, ClassToMatch, &Iterator);
if (kr != kIOReturnSuccess)
{
LogRel(("USBLib: IOServiceGetMatchingServices returned %#x\n", kr));
return RTErrConvertFromDarwinKern(kr);
}
/* Get the first item in the iterator and release it. */
io_service_t ServiceObject = IOIteratorNext(Iterator);
IOObjectRelease(Iterator);
if (!ServiceObject)
{
LogRel(("USBLib: Couldn't find any matches.\n"));
return VERR_GENERAL_FAILURE;
}
/*
* Open the service.
* This will cause the user client class in VBoxUSB.cpp to be instantiated.
*/
kr = IOServiceOpen(ServiceObject, mach_task_self(), VBOXUSB_DARWIN_IOSERVICE_COOKIE, &g_Connection);
IOObjectRelease(ServiceObject);
if (kr != kIOReturnSuccess)
{
LogRel(("USBLib: IOServiceOpen returned %#x\n", kr));
return RTErrConvertFromDarwinKern(kr);
}
ASMAtomicIncU32(&g_cUsers);
return VINF_SUCCESS;
}
