thread-posix.cpp@ 79010

Last change on this file since 79010 was 77910, checked in by vboxsync, 6 years ago
Main: bugref:7929: Added ability to change the priority of the VM process
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 20.9 KB

Line
1	/* $Id: thread-posix.cpp 77910 2019-03-27 11:33:01Z vboxsync $ */
2	/** @file
3	* IPRT - Threads, POSIX.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP RTLOGGROUP_THREAD
32	#include <errno.h>
33	#include <pthread.h>
34	#include <signal.h>
35	#include <stdlib.h>
36	#if defined(RT_OS_LINUX)
37	# include <unistd.h>
38	# include <sys/syscall.h>
39	#endif
40	#if defined(RT_OS_SOLARIS)
41	# include <sched.h>
42	# include <sys/resource.h>
43	#endif
44	#if defined(RT_OS_DARWIN)
45	# include <mach/thread_act.h>
46	# include <mach/thread_info.h>
47	# include <mach/host_info.h>
48	# include <mach/mach_init.h>
49	# include <mach/mach_host.h>
50	#endif
51	#if defined(RT_OS_DARWIN) /\|\| defined(RT_OS_FREEBSD) - later / \
52	\|\| (defined(RT_OS_LINUX) && !defined(IN_RT_STATIC) /* static + dlsym = trouble */) \
53	\|\| defined(IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP)
54	# define IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP
55	# include <dlfcn.h>
56	#endif
57	#if defined(RT_OS_HAIKU)
58	# include <OS.h>
59	#endif
60
61	#include <iprt/thread.h>
62	#include <iprt/log.h>
63	#include <iprt/assert.h>
64	#include <iprt/asm.h>
65	#include <iprt/err.h>
66	#include <iprt/initterm.h>
67	#include <iprt/string.h>
68	#include <iprt/semaphore.h>
69	#include <iprt/list.h>
70	#include <iprt/once.h>
71	#include <iprt/critsect.h>
72	#include <iprt/req.h>
73	#include "internal/thread.h"
74
75
76	/*********************************************************************************************************************************
77	* Defined Constants And Macros *
78	*********************************************************************************************************************************/
79	#ifndef IN_GUEST
80	/** Includes RTThreadPoke. */
81	# define RTTHREAD_POSIX_WITH_POKE
82	#endif
83
84
85	/*********************************************************************************************************************************
86	* Global Variables *
87	*********************************************************************************************************************************/
88	/** The pthread key in which we store the pointer to our own PRTTHREAD structure. */
89	static pthread_key_t g_SelfKey;
90	#ifdef RTTHREAD_POSIX_WITH_POKE
91	/** The signal we use for poking threads.
92	* This is set to -1 if no available signal was found. */
93	static int g_iSigPokeThread = -1;
94	#endif
95
96	#ifdef IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP
97	# if defined(RT_OS_DARWIN)
98	/**
99	* The Mac OS X (10.6 and later) variant of pthread_setname_np.
100	*
101	* @returns errno.h
102	* @param pszName The new thread name.
103	*/
104	typedef int (PFNPTHREADSETNAME)(const char pszName);
105	# else
106	/**
107	* The variant of pthread_setname_np most other unix-like systems implement.
108	*
109	* @returns errno.h
110	* @param hThread The thread.
111	* @param pszName The new thread name.
112	*/
113	typedef int (PFNPTHREADSETNAME)(pthread_t hThread, const char pszName);
114	# endif
115
116	/** Pointer to pthread_setname_np if found. */
117	static PFNPTHREADSETNAME g_pfnThreadSetName = NULL;
118	#endif /* IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP */
119
120	#ifdef RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY
121	/** Atomic indicator of whether the priority proxy thread has been (attempted) started.
122	*
123	* The priority proxy thread is started under these circumstances:
124	* - RTThreadCreate
125	* - RTThreadSetType
126	* - RTProcSetPriority
127	*
128	* Which means that we'll be single threaded when this is modified.
129	*
130	* Speical values:
131	* - VERR_TRY_AGAIN: Not yet started.
132	* - VERR_WRONG_ORDER: Starting.
133	* - VINF_SUCCESS: Started successfully.
134	* - VERR_PROCESS_NOT_FOUND: Stopping or stopped
135	* - Other error status if failed to start.
136	*
137	* @note We could potentially optimize this by only start it when we lower the
138	* priority of ourselves, the process, or a newly created thread. But
139	* that would means we would need to take multi-threading into account, so
140	* let's not do that for now.
141	*/
142	static int32_t volatile g_rcPriorityProxyThreadStart = VERR_TRY_AGAIN;
143	/** The IPRT thread handle for the priority proxy. */
144	static RTTHREAD g_hRTThreadPosixPriorityProxyThread = NIL_RTTHREAD;
145	/** The priority proxy queue. */
146	static RTREQQUEUE g_hRTThreadPosixPriorityProxyQueue = NIL_RTREQQUEUE;
147	#endif /* RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY */
148
149
150	/*********************************************************************************************************************************
151	* Internal Functions *
152	*********************************************************************************************************************************/
153	static void rtThreadNativeMain(void pvArgs);
154	static void rtThreadKeyDestruct(void *pvValue);
155	#ifdef RTTHREAD_POSIX_WITH_POKE
156	static void rtThreadPosixPokeSignal(int iSignal);
157	#endif
158
159
160	#ifdef RTTHREAD_POSIX_WITH_POKE
161	/**
162	* Try register the dummy signal handler for RTThreadPoke.
163	*/
164	static void rtThreadPosixSelectPokeSignal(void)
165	{
166	/*
167	* Note! Avoid SIGRTMIN thru SIGRTMIN+2 because of LinuxThreads.
168	*/
169	static const int s_aiSigCandidates[] =
170	{
171	# ifdef SIGRTMAX
172	SIGRTMAX-3,
173	SIGRTMAX-2,
174	SIGRTMAX-1,
175	# endif
176	# ifndef RT_OS_SOLARIS
177	SIGUSR2,
178	# endif
179	SIGWINCH
180	};
181
182	g_iSigPokeThread = -1;
183	if (!RTR3InitIsUnobtrusive())
184	{
185	for (unsigned iSig = 0; iSig < RT_ELEMENTS(s_aiSigCandidates); iSig++)
186	{
187	struct sigaction SigActOld;
188	if (!sigaction(s_aiSigCandidates[iSig], NULL, &SigActOld))
189	{
190	if ( SigActOld.sa_handler == SIG_DFL
191	\|\| SigActOld.sa_handler == rtThreadPosixPokeSignal)
192	{
193	struct sigaction SigAct;
194	RT_ZERO(SigAct);
195	SigAct.sa_handler = rtThreadPosixPokeSignal;
196	SigAct.sa_flags = 0;
197	sigfillset(&SigAct.sa_mask);
198
199	/* ASSUMES no sigaction race... (lazy bird) */
200	if (!sigaction(s_aiSigCandidates[iSig], &SigAct, NULL))
201	{
202	g_iSigPokeThread = s_aiSigCandidates[iSig];
203	break;
204	}
205	AssertMsgFailed(("rc=%Rrc errno=%d\n", RTErrConvertFromErrno(errno), errno));
206	}
207	}
208	else
209	AssertMsgFailed(("rc=%Rrc errno=%d\n", RTErrConvertFromErrno(errno), errno));
210	}
211	}
212	}
213	#endif /* RTTHREAD_POSIX_WITH_POKE */
214
215
216	DECLHIDDEN(int) rtThreadNativeInit(void)
217	{
218	/*
219	* Allocate the TLS (key in posix terms) where we store the pointer to
220	* a threads RTTHREADINT structure.
221	*/
222	int rc = pthread_key_create(&g_SelfKey, rtThreadKeyDestruct);
223	if (rc)
224	return VERR_NO_TLS_FOR_SELF;
225
226	#ifdef RTTHREAD_POSIX_WITH_POKE
227	rtThreadPosixSelectPokeSignal();
228	#endif
229
230	#ifdef IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP
231	if (RT_SUCCESS(rc))
232	g_pfnThreadSetName = (PFNPTHREADSETNAME)(uintptr_t)dlsym(RTLD_DEFAULT, "pthread_setname_np");
233	#endif
234	return rc;
235	}
236
237	static void rtThreadPosixBlockSignals(void)
238	{
239	/*
240	* Block SIGALRM - required for timer-posix.cpp.
241	* This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
242	* It will not help much if someone creates threads directly using pthread_create. :/
243	*/
244	if (!RTR3InitIsUnobtrusive())
245	{
246	sigset_t SigSet;
247	sigemptyset(&SigSet);
248	sigaddset(&SigSet, SIGALRM);
249	sigprocmask(SIG_BLOCK, &SigSet, NULL);
250	}
251	#ifdef RTTHREAD_POSIX_WITH_POKE
252	if (g_iSigPokeThread != -1)
253	siginterrupt(g_iSigPokeThread, 1);
254	#endif
255	}
256
257	DECLHIDDEN(void) rtThreadNativeReInitObtrusive(void)
258	{
259	#ifdef RTTHREAD_POSIX_WITH_POKE
260	Assert(!RTR3InitIsUnobtrusive());
261	rtThreadPosixSelectPokeSignal();
262	#endif
263	rtThreadPosixBlockSignals();
264	}
265
266
267	/**
268	* Destructor called when a thread terminates.
269	* @param pvValue The key value. PRTTHREAD in our case.
270	*/
271	static void rtThreadKeyDestruct(void *pvValue)
272	{
273	/*
274	* Deal with alien threads.
275	*/
276	PRTTHREADINT pThread = (PRTTHREADINT)pvValue;
277	if (pThread->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
278	{
279	pthread_setspecific(g_SelfKey, pThread);
280	rtThreadTerminate(pThread, 0);
281	pthread_setspecific(g_SelfKey, NULL);
282	}
283	}
284
285
286	#ifdef RTTHREAD_POSIX_WITH_POKE
287	/**
288	* Dummy signal handler for the poke signal.
289	*
290	* @param iSignal The signal number.
291	*/
292	static void rtThreadPosixPokeSignal(int iSignal)
293	{
294	Assert(iSignal == g_iSigPokeThread);
295	NOREF(iSignal);
296	}
297	#endif
298
299
300	/**
301	* Adopts a thread, this is called immediately after allocating the
302	* thread structure.
303	*
304	* @param pThread Pointer to the thread structure.
305	*/
306	DECLHIDDEN(int) rtThreadNativeAdopt(PRTTHREADINT pThread)
307	{
308	rtThreadPosixBlockSignals();
309
310	int rc = pthread_setspecific(g_SelfKey, pThread);
311	if (!rc)
312	return VINF_SUCCESS;
313	return VERR_FAILED_TO_SET_SELF_TLS;
314	}
315
316
317	DECLHIDDEN(void) rtThreadNativeDestroy(PRTTHREADINT pThread)
318	{
319	if (pThread == (PRTTHREADINT)pthread_getspecific(g_SelfKey))
320	pthread_setspecific(g_SelfKey, NULL);
321	}
322
323
324	/**
325	* Wrapper which unpacks the params and calls thread function.
326	*/
327	static void rtThreadNativeMain(void pvArgs)
328	{
329	PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
330	pthread_t Self = pthread_self();
331	Assert((uintptr_t)Self != NIL_RTNATIVETHREAD);
332	Assert(Self == (pthread_t)(RTNATIVETHREAD)Self);
333
334	#if defined(RT_OS_LINUX)
335	/*
336	* Set the TID.
337	*/
338	pThread->tid = syscall(__NR_gettid);
339	ASMMemoryFence();
340	#endif
341
342	rtThreadPosixBlockSignals();
343
344	/*
345	* Set the TLS entry and, if possible, the thread name.
346	*/
347	int rc = pthread_setspecific(g_SelfKey, pThread);
348	AssertReleaseMsg(!rc, ("failed to set self TLS. rc=%d thread '%s'\n", rc, pThread->szName));
349
350	#ifdef IPRT_MAY_HAVE_PTHREAD_SET_NAME_NP
351	if (g_pfnThreadSetName)
352	# ifdef RT_OS_DARWIN
353	g_pfnThreadSetName(pThread->szName);
354	# else
355	g_pfnThreadSetName(Self, pThread->szName);
356	# endif
357	#endif
358
359	/*
360	* Call common main.
361	*/
362	rc = rtThreadMain(pThread, (uintptr_t)Self, &pThread->szName[0]);
363
364	pthread_setspecific(g_SelfKey, NULL);
365	pthread_exit((void *)(intptr_t)rc);
366	return (void *)(intptr_t)rc;
367	}
368
369	#ifdef RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY
370
371	/**
372	* @callback_method_impl{FNRTTHREAD,
373	* Priority proxy thread that services g_hRTThreadPosixPriorityProxyQueue.}
374	*/
375	static DECLCALLBACK(int) rtThreadPosixPriorityProxyThread(PRTTHREADINT, void *)
376	{
377	for (;;)
378	{
379	RTREQQUEUE hReqQueue = g_hRTThreadPosixPriorityProxyQueue;
380	if (hReqQueue != NIL_RTREQQUEUE)
381	RTReqQueueProcess(hReqQueue, RT_INDEFINITE_WAIT);
382	else
383	break;
384
385	int32_t rc = ASMAtomicUoReadS32(&g_rcPriorityProxyThreadStart);
386	if (rc != VINF_SUCCESS && rc != VERR_WRONG_ORDER)
387	break;
388	}
389
390	return VINF_SUCCESS;
391	}
392
393
394	/**
395	* Just returns a non-success status codes to force the thread to re-evaluate
396	* the global shutdown variable.
397	*/
398	static DECLCALLBACK(int) rtThreadPosixPriorityProxyStopper(void)
399	{
400	return VERR_CANCELLED;
401	}
402
403
404	/**
405	* An atexit() callback that stops the proxy creation/priority thread.
406	*/
407	static void rtThreadStopProxyThread(void)
408	{
409	/*
410	* Signal to the thread that it's time to shut down.
411	*/
412	int32_t rc = ASMAtomicXchgS32(&g_rcPriorityProxyThreadStart, VERR_PROCESS_NOT_FOUND);
413	if (RT_SUCCESS(rc))
414	{
415	/*
416	* Grab the associated handles.
417	*/
418	RTTHREAD hThread = g_hRTThreadPosixPriorityProxyThread;
419	RTREQQUEUE hQueue = g_hRTThreadPosixPriorityProxyQueue;
420	g_hRTThreadPosixPriorityProxyQueue = NIL_RTREQQUEUE;
421	g_hRTThreadPosixPriorityProxyThread = NIL_RTTHREAD;
422	ASMCompilerBarrier(); /* paranoia */
423
424	AssertReturnVoid(hThread != NIL_RTTHREAD);
425	AssertReturnVoid(hQueue != NIL_RTREQQUEUE);
426
427	/*
428	* Kick the thread so it gets out of any pending RTReqQueueProcess call ASAP.
429	*/
430	rc = RTReqQueueCallEx(hQueue, NULL, 0 /cMillies/, RTREQFLAGS_IPRT_STATUS \| RTREQFLAGS_NO_WAIT,
431	(PFNRT)rtThreadPosixPriorityProxyStopper, 0);
432
433	/*
434	* Wait for the thread to complete.
435	*/
436	rc = RTThreadWait(hThread, RT_SUCCESS(rc) ? RT_MS_1SEC * 5 : 32, NULL);
437	if (RT_SUCCESS(rc))
438	RTReqQueueDestroy(hQueue);
439	/* else: just leak the stuff, we're exitting, so nobody cares... */
440	}
441	}
442
443
444	/**
445	* Ensure that the proxy priority proxy thread has been started.
446	*
447	* Since we will always start a proxy thread when asked to create a thread,
448	* there is no need for serialization here.
449	*
450	* @retval true if started
451	* @retval false if it failed to start (caller must handle this scenario).
452	*/
453	DECLHIDDEN(bool) rtThreadPosixPriorityProxyStart(void)
454	{
455	/*
456	* Read the result.
457	*/
458	int rc = ASMAtomicUoReadS32(&g_rcPriorityProxyThreadStart);
459	if (rc != VERR_TRY_AGAIN)
460	return RT_SUCCESS(rc);
461
462	/* If this triggers then there is a very unexpected race somewhere. It
463	should be harmless though. */
464	AssertReturn(ASMAtomicCmpXchgS32(&g_rcPriorityProxyThreadStart, VERR_WRONG_ORDER, VERR_TRY_AGAIN), false);
465
466	/*
467	* Not yet started, so do that.
468	*/
469	rc = RTReqQueueCreate(&g_hRTThreadPosixPriorityProxyQueue);
470	if (RT_SUCCESS(rc))
471	{
472	rc = RTThreadCreate(&g_hRTThreadPosixPriorityProxyThread, rtThreadPosixPriorityProxyThread, NULL, 0 /cbStack/,
473	RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "RTThrdPP");
474	if (RT_SUCCESS(rc))
475	{
476	ASMAtomicWriteS32(&g_rcPriorityProxyThreadStart, VINF_SUCCESS);
477
478	atexit(rtThreadStopProxyThread);
479	return true;
480	}
481	RTReqQueueCreate(&g_hRTThreadPosixPriorityProxyQueue);
482	}
483	ASMAtomicWriteS32(&g_rcPriorityProxyThreadStart, rc != VERR_WRONG_ORDER ? rc : VERR_PROCESS_NOT_FOUND);
484	return false;
485	}
486
487
488	/**
489	* Calls @a pfnFunction from the priority proxy thread.
490	*
491	* Caller must have called rtThreadPosixStartProxy() to check that the priority
492	* proxy thread is running.
493	*
494	* @returns
495	* @param pTargetThread The target thread, NULL if not applicable. This is
496	* so we can skip calls pertaining to the priority
497	* proxy thread itself.
498	* @param pfnFunction The function to call. Must return IPRT status code.
499	* @param cArgs Number of arguments (see also RTReqQueueCall).
500	* @param ... Arguments (see also RTReqQueueCall).
501	*/
502	DECLHIDDEN(int) rtThreadPosixPriorityProxyCall(PRTTHREADINT pTargetThread, PFNRT pfnFunction, int cArgs, ...)
503	{
504	int rc;
505	if ( !pTargetThread
506	\|\| pTargetThread->pfnThread != rtThreadPosixPriorityProxyThread)
507	{
508	va_list va;
509	va_start(va, cArgs);
510	PRTREQ pReq;
511	rc = RTReqQueueCallV(g_hRTThreadPosixPriorityProxyQueue, &pReq, RT_INDEFINITE_WAIT, RTREQFLAGS_IPRT_STATUS,
512	pfnFunction, cArgs, va);
513	va_end(va);
514	RTReqRelease(pReq);
515	}
516	else
517	rc = VINF_SUCCESS;
518	return rc;
519	}
520
521	#endif /* !RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY */
522
523	/**
524	* Worker for rtThreadNativeCreate that's either called on the priority proxy
525	* thread or directly on the calling thread depending on the proxy state.
526	*/
527	static DECLCALLBACK(int) rtThreadNativeInternalCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
528	{
529	/*
530	* Set the default stack size.
531	*/
532	if (!pThread->cbStack)
533	pThread->cbStack = 512*1024;
534
535	#ifdef RT_OS_LINUX
536	pThread->tid = -1;
537	#endif
538
539	/*
540	* Setup thread attributes.
541	*/
542	pthread_attr_t ThreadAttr;
543	int rc = pthread_attr_init(&ThreadAttr);
544	if (!rc)
545	{
546	rc = pthread_attr_setdetachstate(&ThreadAttr, PTHREAD_CREATE_DETACHED);
547	if (!rc)
548	{
549	rc = pthread_attr_setstacksize(&ThreadAttr, pThread->cbStack);
550	if (!rc)
551	{
552	/*
553	* Create the thread.
554	*/
555	pthread_t ThreadId;
556	rc = pthread_create(&ThreadId, &ThreadAttr, rtThreadNativeMain, pThread);
557	if (!rc)
558	{
559	pthread_attr_destroy(&ThreadAttr);
560	*pNativeThread = (uintptr_t)ThreadId;
561	return VINF_SUCCESS;
562	}
563	}
564	}
565	pthread_attr_destroy(&ThreadAttr);
566	}
567	return RTErrConvertFromErrno(rc);
568	}
569
570
571	DECLHIDDEN(int) rtThreadNativeCreate(PRTTHREADINT pThread, PRTNATIVETHREAD pNativeThread)
572	{
573	#ifdef RTTHREAD_POSIX_WITH_CREATE_PRIORITY_PROXY
574	/*
575	* If we have a priority proxy thread, use it. Make sure to ignore the
576	* staring of the proxy thread itself.
577	*/
578	if ( pThread->pfnThread != rtThreadPosixPriorityProxyThread
579	&& rtThreadPosixPriorityProxyStart())
580	{
581	PRTREQ pReq;
582	int rc = RTReqQueueCall(g_hRTThreadPosixPriorityProxyQueue, &pReq, RT_INDEFINITE_WAIT,
583	(PFNRT)rtThreadNativeInternalCreate, 2, pThread, pNativeThread);
584	RTReqRelease(pReq);
585	return rc;
586	}
587
588	/*
589	* Fall back on creating it directly without regard to priority proxying.
590	*/
591	#endif
592	return rtThreadNativeInternalCreate(pThread, pNativeThread);
593	}
594
595
596	RTDECL(RTTHREAD) RTThreadSelf(void)
597	{
598	PRTTHREADINT pThread = (PRTTHREADINT)pthread_getspecific(g_SelfKey);
599	/** @todo import alien threads? */
600	return pThread;
601	}
602
603
604	#ifdef RTTHREAD_POSIX_WITH_POKE
605	RTDECL(int) RTThreadPoke(RTTHREAD hThread)
606	{
607	AssertReturn(hThread != RTThreadSelf(), VERR_INVALID_PARAMETER);
608	PRTTHREADINT pThread = rtThreadGet(hThread);
609	AssertReturn(pThread, VERR_INVALID_HANDLE);
610
611	int rc;
612	if (g_iSigPokeThread != -1)
613	{
614	rc = pthread_kill((pthread_t)(uintptr_t)pThread->Core.Key, g_iSigPokeThread);
615	rc = RTErrConvertFromErrno(rc);
616	}
617	else
618	rc = VERR_NOT_SUPPORTED;
619
620	rtThreadRelease(pThread);
621	return rc;
622	}
623	#endif
624
625	/** @todo move this into platform specific files. */
626	RTR3DECL(int) RTThreadGetExecutionTimeMilli(uint64_t pKernelTime, uint64_t pUserTime)
627	{
628	#if defined(RT_OS_SOLARIS)
629	struct rusage ts;
630	int rc = getrusage(RUSAGE_LWP, &ts);
631	if (rc)
632	return RTErrConvertFromErrno(rc);
633
634	pKernelTime = ts.ru_stime.tv_sec 1000 + ts.ru_stime.tv_usec / 1000;
635	pUserTime = ts.ru_utime.tv_sec 1000 + ts.ru_utime.tv_usec / 1000;
636	return VINF_SUCCESS;
637
638	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_FREEBSD)
639	/* on Linux, getrusage(RUSAGE_THREAD, ...) is available since 2.6.26 */
640	struct timespec ts;
641	int rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
642	if (rc)
643	return RTErrConvertFromErrno(rc);
644
645	*pKernelTime = 0;
646	pUserTime = (uint64_t)ts.tv_sec 1000 + ts.tv_nsec / 1000000;
647	return VINF_SUCCESS;
648
649	#elif defined(RT_OS_DARWIN)
650	thread_basic_info ThreadInfo;
651	mach_msg_type_number_t Count = THREAD_BASIC_INFO_COUNT;
652	kern_return_t krc = thread_info(mach_thread_self(), THREAD_BASIC_INFO, (thread_info_t)&ThreadInfo, &Count);
653	AssertReturn(krc == KERN_SUCCESS, RTErrConvertFromDarwinKern(krc));
654
655	pKernelTime = ThreadInfo.system_time.seconds 1000 + ThreadInfo.system_time.microseconds / 1000;
656	pUserTime = ThreadInfo.user_time.seconds 1000 + ThreadInfo.user_time.microseconds / 1000;
657
658	return VINF_SUCCESS;
659	#elif defined(RT_OS_HAIKU)
660	thread_info ThreadInfo;
661	status_t status = get_thread_info(find_thread(NULL), &ThreadInfo);
662	AssertReturn(status == B_OK, RTErrConvertFromErrno(status));
663
664	*pKernelTime = ThreadInfo.kernel_time / 1000;
665	*pUserTime = ThreadInfo.user_time / 1000;
666
667	return VINF_SUCCESS;
668	#else
669	return VERR_NOT_IMPLEMENTED;
670	#endif
671	}
672

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/posix/thread-posix.cpp@ 79010

Download in other formats: