thread.cpp@ 78052

Last change on this file since 78052 was 77982, checked in by vboxsync, 6 years ago
IPRT: Addressed todo in rtSchedNativeCheckThreadTypes (sched-linux.cpp) about limiting the transition checking to thread types that are actually in use. bugref:7929
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 49.3 KB

Line
1	/* $Id: thread.cpp 77982 2019-04-02 10:23:09Z vboxsync $ */
2	/** @file
3	* IPRT - Threads, common routines.
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 <iprt/thread.h>
33	#include "internal/iprt.h"
34
35	#include <iprt/log.h>
36	#include <iprt/avl.h>
37	#include <iprt/alloc.h>
38	#include <iprt/assert.h>
39	#include <iprt/lockvalidator.h>
40	#include <iprt/semaphore.h>
41	#ifdef IN_RING0
42	# include <iprt/spinlock.h>
43	#endif
44	#include <iprt/asm.h>
45	#include <iprt/err.h>
46	#include <iprt/string.h>
47	#include "internal/magics.h"
48	#include "internal/thread.h"
49	#include "internal/sched.h"
50	#include "internal/process.h"
51	#ifdef RT_WITH_ICONV_CACHE
52	# include "internal/string.h"
53	#endif
54
55
56	/*********************************************************************************************************************************
57	* Defined Constants And Macros *
58	*********************************************************************************************************************************/
59	#ifdef IN_RING0
60	# define RT_THREAD_LOCK_RW() RTSpinlockAcquire(g_ThreadSpinlock)
61	# define RT_THREAD_UNLOCK_RW() RTSpinlockRelease(g_ThreadSpinlock)
62	# define RT_THREAD_LOCK_RD() RTSpinlockAcquire(g_ThreadSpinlock)
63	# define RT_THREAD_UNLOCK_RD() RTSpinlockRelease(g_ThreadSpinlock)
64	#else
65	# define RT_THREAD_LOCK_RW() rtThreadLockRW()
66	# define RT_THREAD_UNLOCK_RW() rtThreadUnLockRW()
67	# define RT_THREAD_LOCK_RD() rtThreadLockRD()
68	# define RT_THREAD_UNLOCK_RD() rtThreadUnLockRD()
69	#endif
70
71
72	/*********************************************************************************************************************************
73	* Global Variables *
74	*********************************************************************************************************************************/
75	/** Indicates whether we've been initialized or not. */
76	static bool g_frtThreadInitialized;
77	#ifdef IN_RING3
78	/** The RW lock protecting the tree. */
79	static RTSEMRW g_ThreadRWSem = NIL_RTSEMRW;
80	#else
81	/** The spinlocks protecting the tree. */
82	static RTSPINLOCK g_ThreadSpinlock = NIL_RTSPINLOCK;
83	#endif
84	/** The AVL thread containing the threads. */
85	static PAVLPVNODECORE g_ThreadTree;
86	/** The number of threads in the tree (for ring-0 termination kludge). */
87	static uint32_t volatile g_cThreadInTree;
88	/** Counters for each thread type. */
89	DECLHIDDEN(uint32_t volatile) g_acRTThreadTypeStats[RTTHREADTYPE_END];
90
91
92	/*********************************************************************************************************************************
93	* Internal Functions *
94	*********************************************************************************************************************************/
95	static void rtThreadDestroy(PRTTHREADINT pThread);
96	#ifdef IN_RING3
97	static int rtThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, uint32_t fIntFlags, const char *pszName);
98	#endif
99	static void rtThreadRemoveLocked(PRTTHREADINT pThread);
100	static PRTTHREADINT rtThreadAlloc(RTTHREADTYPE enmType, unsigned fFlags, uint32_t fIntFlags, const char *pszName);
101
102
103	/** @page pg_rt_thread IPRT Thread Internals
104	*
105	* IPRT provides interface to whatever native threading that the host provides,
106	* preferably using a CRT level interface to better integrate with other libraries.
107	*
108	* Internally IPRT keeps track of threads by means of the RTTHREADINT structure.
109	* All the RTTHREADINT structures are kept in a AVL tree which is protected by a
110	* read/write lock for efficient access. A thread is inserted into the tree in
111	* three places in the code. The main thread is 'adopted' by IPRT on rtR3Init()
112	* by rtThreadAdopt(). When creating a new thread there the child and the parent
113	* race inserting the thread, this is rtThreadMain() and RTThreadCreate.
114	*
115	* RTTHREADINT objects are using reference counting as a mean of sticking around
116	* till no-one needs them any longer. Waitable threads is created with one extra
117	* reference so they won't go away until they are waited on. This introduces a
118	* major problem if we use the host thread identifier as key in the AVL tree - the
119	* host may reuse the thread identifier before the thread was waited on. So, on
120	* most platforms we are using the RTTHREADINT pointer as key and not the
121	* thread id. RTThreadSelf() then have to be implemented using a pointer stored
122	* in thread local storage (TLS).
123	*
124	* In Ring-0 we only try keep track of kernel threads created by RTThreadCreate
125	* at the moment. There we really only need the 'join' feature, but doing things
126	* the same way allow us to name threads and similar stuff.
127	*/
128
129
130	/**
131	* Initializes the thread database.
132	*
133	* @returns iprt status code.
134	*/
135	DECLHIDDEN(int) rtThreadInit(void)
136	{
137	#ifdef IN_RING3
138	int rc = VINF_ALREADY_INITIALIZED;
139	if (g_ThreadRWSem == NIL_RTSEMRW)
140	{
141	/*
142	* We assume the caller is the 1st thread, which we'll call 'main'.
143	* But first, we'll create the semaphore.
144	*/
145	rc = RTSemRWCreateEx(&g_ThreadRWSem, RTSEMRW_FLAGS_NO_LOCK_VAL, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
146	if (RT_SUCCESS(rc))
147	{
148	rc = rtThreadNativeInit();
149	if (RT_SUCCESS(rc))
150	rc = rtThreadAdopt(RTTHREADTYPE_DEFAULT, 0, RTTHREADINT_FLAGS_MAIN, "main");
151	if (RT_SUCCESS(rc))
152	rc = rtSchedNativeCalcDefaultPriority(RTTHREADTYPE_DEFAULT);
153	if (RT_SUCCESS(rc))
154	{
155	g_frtThreadInitialized = true;
156	return VINF_SUCCESS;
157	}
158
159	/* failed, clear out */
160	RTSemRWDestroy(g_ThreadRWSem);
161	g_ThreadRWSem = NIL_RTSEMRW;
162	}
163	}
164
165	#elif defined(IN_RING0)
166	int rc;
167	/*
168	* Create the spinlock and to native init.
169	*/
170	Assert(g_ThreadSpinlock == NIL_RTSPINLOCK);
171	rc = RTSpinlockCreate(&g_ThreadSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "RTThread");
172	if (RT_SUCCESS(rc))
173	{
174	rc = rtThreadNativeInit();
175	if (RT_SUCCESS(rc))
176	{
177	g_frtThreadInitialized = true;
178	return VINF_SUCCESS;
179	}
180
181	/* failed, clear out */
182	RTSpinlockDestroy(g_ThreadSpinlock);
183	g_ThreadSpinlock = NIL_RTSPINLOCK;
184	}
185	#else
186	# error "!IN_RING0 && !IN_RING3"
187	#endif
188	return rc;
189	}
190
191
192	#ifdef IN_RING3
193	/**
194	* Called when IPRT was first initialized in unobtrusive mode and later changed
195	* to obtrustive.
196	*
197	* This is only applicable in ring-3.
198	*/
199	DECLHIDDEN(void) rtThreadReInitObtrusive(void)
200	{
201	rtThreadNativeReInitObtrusive();
202	}
203	#endif
204
205
206	/**
207	* Terminates the thread database.
208	*/
209	DECLHIDDEN(void) rtThreadTerm(void)
210	{
211	#ifdef IN_RING3
212	/* we don't cleanup here yet */
213
214	#elif defined(IN_RING0)
215	/* just destroy the spinlock and assume the thread is fine... */
216	RTSpinlockDestroy(g_ThreadSpinlock);
217	g_ThreadSpinlock = NIL_RTSPINLOCK;
218	if (g_ThreadTree != NULL)
219	RTAssertMsg2Weak("WARNING: g_ThreadTree=%p\n", g_ThreadTree);
220	#endif
221	}
222
223
224	#ifdef IN_RING3
225
226	DECLINLINE(void) rtThreadLockRW(void)
227	{
228	if (g_ThreadRWSem == NIL_RTSEMRW)
229	rtThreadInit();
230	int rc = RTSemRWRequestWrite(g_ThreadRWSem, RT_INDEFINITE_WAIT);
231	AssertReleaseRC(rc);
232	}
233
234
235	DECLINLINE(void) rtThreadLockRD(void)
236	{
237	if (g_ThreadRWSem == NIL_RTSEMRW)
238	rtThreadInit();
239	int rc = RTSemRWRequestRead(g_ThreadRWSem, RT_INDEFINITE_WAIT);
240	AssertReleaseRC(rc);
241	}
242
243
244	DECLINLINE(void) rtThreadUnLockRW(void)
245	{
246	int rc = RTSemRWReleaseWrite(g_ThreadRWSem);
247	AssertReleaseRC(rc);
248	}
249
250
251	DECLINLINE(void) rtThreadUnLockRD(void)
252	{
253	int rc = RTSemRWReleaseRead(g_ThreadRWSem);
254	AssertReleaseRC(rc);
255	}
256
257
258	/**
259	* Adopts the calling thread.
260	* No locks are taken or released by this function.
261	*/
262	static int rtThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, uint32_t fIntFlags, const char *pszName)
263	{
264	int rc;
265	PRTTHREADINT pThread;
266	Assert(!(fFlags & RTTHREADFLAGS_WAITABLE));
267	fFlags &= ~RTTHREADFLAGS_WAITABLE;
268
269	/*
270	* Allocate and insert the thread.
271	* (It is vital that rtThreadNativeAdopt updates the TLS before
272	* we try inserting the thread because of locking.)
273	*/
274	rc = VERR_NO_MEMORY;
275	pThread = rtThreadAlloc(enmType, fFlags, RTTHREADINT_FLAGS_ALIEN \| fIntFlags, pszName);
276	if (pThread)
277	{
278	RTNATIVETHREAD NativeThread = RTThreadNativeSelf();
279	rc = rtThreadNativeAdopt(pThread);
280	if (RT_SUCCESS(rc))
281	{
282	rtThreadInsert(pThread, NativeThread);
283	rtThreadSetState(pThread, RTTHREADSTATE_RUNNING);
284	rtThreadRelease(pThread);
285	}
286	else
287	rtThreadDestroy(pThread);
288	}
289	return rc;
290	}
291
292	/**
293	* Adopts a non-IPRT thread.
294	*
295	* @returns IPRT status code.
296	* @param enmType The thread type.
297	* @param fFlags The thread flags. RTTHREADFLAGS_WAITABLE is not currently allowed.
298	* @param pszName The thread name. Optional.
299	* @param pThread Where to store the thread handle. Optional.
300	*/
301	RTDECL(int) RTThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, const char *pszName, PRTTHREAD pThread)
302	{
303	int rc;
304	RTTHREAD Thread;
305
306	AssertReturn(!(fFlags & RTTHREADFLAGS_WAITABLE), VERR_INVALID_PARAMETER);
307	AssertReturn(!pszName \|\| VALID_PTR(pszName), VERR_INVALID_POINTER);
308	AssertReturn(!pThread \|\| VALID_PTR(pThread), VERR_INVALID_POINTER);
309
310	rc = VINF_SUCCESS;
311	Thread = RTThreadSelf();
312	if (Thread == NIL_RTTHREAD)
313	{
314	/* generate a name if none was given. */
315	char szName[RTTHREAD_NAME_LEN];
316	if (!pszName \|\| !*pszName)
317	{
318	static uint32_t s_i32AlienId = 0;
319	uint32_t i32Id = ASMAtomicIncU32(&s_i32AlienId);
320	RTStrPrintf(szName, sizeof(szName), "ALIEN-%RX32", i32Id);
321	pszName = szName;
322	}
323
324	/* try adopt it */
325	rc = rtThreadAdopt(enmType, fFlags, 0, pszName);
326	Thread = RTThreadSelf();
327	Log(("RTThreadAdopt: %RTthrd %RTnthrd '%s' enmType=%d fFlags=%#x rc=%Rrc\n",
328	Thread, RTThreadNativeSelf(), pszName, enmType, fFlags, rc));
329	}
330	else
331	Log(("RTThreadAdopt: %RTthrd %RTnthrd '%s' enmType=%d fFlags=%#x - already adopted!\n",
332	Thread, RTThreadNativeSelf(), pszName, enmType, fFlags));
333
334	if (pThread)
335	*pThread = Thread;
336	return rc;
337	}
338	RT_EXPORT_SYMBOL(RTThreadAdopt);
339
340
341	/**
342	* Get the thread handle of the current thread, automatically adopting alien
343	* threads.
344	*
345	* @returns Thread handle.
346	*/
347	RTDECL(RTTHREAD) RTThreadSelfAutoAdopt(void)
348	{
349	RTTHREAD hSelf = RTThreadSelf();
350	if (RT_UNLIKELY(hSelf == NIL_RTTHREAD))
351	RTThreadAdopt(RTTHREADTYPE_DEFAULT, 0, NULL, &hSelf);
352	return hSelf;
353	}
354	RT_EXPORT_SYMBOL(RTThreadSelfAutoAdopt);
355
356	#endif /* IN_RING3 */
357
358	/**
359	* Allocates a per thread data structure and initializes the basic fields.
360	*
361	* @returns Pointer to per thread data structure.
362	* This is reference once.
363	* @returns NULL on failure.
364	* @param enmType The thread type.
365	* @param fFlags The thread flags.
366	* @param fIntFlags The internal thread flags.
367	* @param pszName Pointer to the thread name.
368	*/
369	PRTTHREADINT rtThreadAlloc(RTTHREADTYPE enmType, unsigned fFlags, uint32_t fIntFlags, const char *pszName)
370	{
371	PRTTHREADINT pThread = (PRTTHREADINT)RTMemAllocZ(sizeof(RTTHREADINT));
372	if (pThread)
373	{
374	size_t cchName;
375	int rc;
376
377	pThread->Core.Key = (void*)NIL_RTTHREAD;
378	pThread->u32Magic = RTTHREADINT_MAGIC;
379	cchName = strlen(pszName);
380	if (cchName >= RTTHREAD_NAME_LEN)
381	cchName = RTTHREAD_NAME_LEN - 1;
382	memcpy(pThread->szName, pszName, cchName);
383	pThread->szName[cchName] = '\0';
384	pThread->cRefs = 2 + !!(fFlags & RTTHREADFLAGS_WAITABLE); /* And extra reference if waitable. */
385	pThread->rc = VERR_PROCESS_RUNNING; /** @todo get a better error code! */
386	pThread->enmType = enmType;
387	pThread->fFlags = fFlags;
388	pThread->fIntFlags = fIntFlags;
389	pThread->enmState = RTTHREADSTATE_INITIALIZING;
390	pThread->fReallySleeping = false;
391	#ifdef IN_RING3
392	rtLockValidatorInitPerThread(&pThread->LockValidator);
393	#endif
394	#ifdef RT_WITH_ICONV_CACHE
395	rtStrIconvCacheInit(pThread);
396	#endif
397	rc = RTSemEventMultiCreate(&pThread->EventUser);
398	if (RT_SUCCESS(rc))
399	{
400	rc = RTSemEventMultiCreate(&pThread->EventTerminated);
401	if (RT_SUCCESS(rc))
402	return pThread;
403	RTSemEventMultiDestroy(pThread->EventUser);
404	}
405	RTMemFree(pThread);
406	}
407	return NULL;
408	}
409
410
411	/**
412	* Insert the per thread data structure into the tree.
413	*
414	* This can be called from both the thread it self and the parent,
415	* thus it must handle insertion failures in a nice manner.
416	*
417	* @param pThread Pointer to thread structure allocated by rtThreadAlloc().
418	* @param NativeThread The native thread id.
419	*/
420	DECLHIDDEN(void) rtThreadInsert(PRTTHREADINT pThread, RTNATIVETHREAD NativeThread)
421	{
422	Assert(pThread);
423	Assert(pThread->u32Magic == RTTHREADINT_MAGIC);
424
425	{
426	RT_THREAD_LOCK_RW();
427
428	/*
429	* Do not insert a terminated thread.
430	*
431	* This may happen if the thread finishes before the RTThreadCreate call
432	* gets this far. Since the OS may quickly reuse the native thread ID
433	* it should not be reinserted at this point.
434	*/
435	if (rtThreadGetState(pThread) != RTTHREADSTATE_TERMINATED)
436	{
437	/*
438	* Before inserting we must check if there is a thread with this id
439	* in the tree already. We're racing parent and child on insert here
440	* so that the handle is valid in both ends when they return / start.
441	*
442	* If it's not ourself we find, it's a dead alien thread and we will
443	* unlink it from the tree. Alien threads will be released at this point.
444	*/
445	PRTTHREADINT pThreadOther = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
446	if (pThreadOther != pThread)
447	{
448	bool fRc;
449	/* remove dead alien if any */
450	if (pThreadOther)
451	{
452	AssertMsg(pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN, ("%p:%s; %p:%s\n", pThread, pThread->szName, pThreadOther, pThreadOther->szName));
453	ASMAtomicBitClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT);
454	rtThreadRemoveLocked(pThreadOther);
455	if (pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
456	rtThreadRelease(pThreadOther);
457	}
458
459	/* insert the thread */
460	ASMAtomicWritePtr(&pThread->Core.Key, (void *)NativeThread);
461	fRc = RTAvlPVInsert(&g_ThreadTree, &pThread->Core);
462	ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE);
463	if (fRc)
464	{
465	ASMAtomicIncU32(&g_cThreadInTree);
466	ASMAtomicIncU32(&g_acRTThreadTypeStats[pThread->enmType]);
467	}
468
469	AssertReleaseMsg(fRc, ("Lock problem? %p (%RTnthrd) %s\n", pThread, NativeThread, pThread->szName));
470	NOREF(fRc);
471	}
472	}
473
474	RT_THREAD_UNLOCK_RW();
475	}
476	}
477
478
479	/**
480	* Removes the thread from the AVL tree, call owns the tree lock
481	* and has cleared the RTTHREADINT_FLAG_IN_TREE bit.
482	*
483	* @param pThread The thread to remove.
484	*/
485	static void rtThreadRemoveLocked(PRTTHREADINT pThread)
486	{
487	PRTTHREADINT pThread2 = (PRTTHREADINT)RTAvlPVRemove(&g_ThreadTree, pThread->Core.Key);
488	AssertMsg(pThread2 == pThread, ("%p(%s) != %p (%p/%s)\n", pThread2, pThread2 ? pThread2->szName : "<null>",
489	pThread, pThread->Core.Key, pThread->szName));
490	if (pThread2)
491	{
492	ASMAtomicDecU32(&g_cThreadInTree);
493	ASMAtomicDecU32(&g_acRTThreadTypeStats[pThread->enmType]);
494	}
495	}
496
497
498	/**
499	* Removes the thread from the AVL tree.
500	*
501	* @param pThread The thread to remove.
502	*/
503	static void rtThreadRemove(PRTTHREADINT pThread)
504	{
505	RT_THREAD_LOCK_RW();
506	if (ASMAtomicBitTestAndClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT))
507	rtThreadRemoveLocked(pThread);
508	RT_THREAD_UNLOCK_RW();
509	}
510
511
512	/**
513	* Checks if a thread is alive or not.
514	*
515	* @returns true if the thread is alive (or we don't really know).
516	* @returns false if the thread has surely terminate.
517	*/
518	DECLINLINE(bool) rtThreadIsAlive(PRTTHREADINT pThread)
519	{
520	return !(pThread->fIntFlags & RTTHREADINT_FLAGS_TERMINATED);
521	}
522
523
524	/**
525	* Gets a thread by it's native ID.
526	*
527	* @returns pointer to the thread structure.
528	* @returns NULL if not a thread IPRT knows.
529	* @param NativeThread The native thread id.
530	*/
531	DECLHIDDEN(PRTTHREADINT) rtThreadGetByNative(RTNATIVETHREAD NativeThread)
532	{
533	PRTTHREADINT pThread;
534	/*
535	* Simple tree lookup.
536	*/
537	RT_THREAD_LOCK_RD();
538	pThread = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
539	RT_THREAD_UNLOCK_RD();
540	return pThread;
541	}
542
543
544	/**
545	* Gets the per thread data structure for a thread handle.
546	*
547	* @returns Pointer to the per thread data structure for Thread.
548	* The caller must release the thread using rtThreadRelease().
549	* @returns NULL if Thread was not found.
550	* @param Thread Thread id which structure is to be returned.
551	*/
552	DECLHIDDEN(PRTTHREADINT) rtThreadGet(RTTHREAD Thread)
553	{
554	if ( Thread != NIL_RTTHREAD
555	&& VALID_PTR(Thread))
556	{
557	PRTTHREADINT pThread = (PRTTHREADINT)Thread;
558	if ( pThread->u32Magic == RTTHREADINT_MAGIC
559	&& pThread->cRefs > 0)
560	{
561	ASMAtomicIncU32(&pThread->cRefs);
562	return pThread;
563	}
564	}
565
566	AssertMsgFailed(("Thread=%RTthrd\n", Thread));
567	return NULL;
568	}
569
570	/**
571	* Release a per thread data structure.
572	*
573	* @returns New reference count.
574	* @param pThread The thread structure to release.
575	*/
576	DECLHIDDEN(uint32_t) rtThreadRelease(PRTTHREADINT pThread)
577	{
578	uint32_t cRefs;
579
580	Assert(pThread);
581	if (pThread->cRefs >= 1)
582	{
583	cRefs = ASMAtomicDecU32(&pThread->cRefs);
584	if (!cRefs)
585	rtThreadDestroy(pThread);
586	}
587	else
588	{
589	cRefs = 0;
590	AssertFailed();
591	}
592	return cRefs;
593	}
594
595
596	/**
597	* Destroys the per thread data.
598	*
599	* @param pThread The thread to destroy.
600	*/
601	static void rtThreadDestroy(PRTTHREADINT pThread)
602	{
603	RTSEMEVENTMULTI hEvt1, hEvt2;
604	/*
605	* Remove it from the tree and mark it as dead.
606	*
607	* Threads that has seen rtThreadTerminate and should already have been
608	* removed from the tree. There is probably no thread that should
609	* require removing here. However, be careful making sure that cRefs
610	* isn't 0 if we do or we'll blow up because the strict locking code
611	* will be calling us back.
612	*/
613	if (ASMBitTest(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT))
614	{
615	ASMAtomicIncU32(&pThread->cRefs);
616	rtThreadRemove(pThread);
617	ASMAtomicDecU32(&pThread->cRefs);
618	}
619
620	/*
621	* Invalidate the thread structure.
622	*/
623	#ifdef IN_RING3
624	rtLockValidatorSerializeDestructEnter();
625
626	rtLockValidatorDeletePerThread(&pThread->LockValidator);
627	#endif
628	#ifdef RT_WITH_ICONV_CACHE
629	rtStrIconvCacheDestroy(pThread);
630	#endif
631	ASMAtomicXchgU32(&pThread->u32Magic, RTTHREADINT_MAGIC_DEAD);
632	ASMAtomicWritePtr(&pThread->Core.Key, (void *)NIL_RTTHREAD);
633	pThread->enmType = RTTHREADTYPE_INVALID;
634	hEvt1 = pThread->EventUser;
635	pThread->EventUser = NIL_RTSEMEVENTMULTI;
636	hEvt2 = pThread->EventTerminated;
637	pThread->EventTerminated = NIL_RTSEMEVENTMULTI;
638
639	#ifdef IN_RING3
640	rtLockValidatorSerializeDestructLeave();
641	#endif
642
643	/*
644	* Destroy semaphore resources and free the bugger.
645	*/
646	RTSemEventMultiDestroy(hEvt1);
647	if (hEvt2 != NIL_RTSEMEVENTMULTI)
648	RTSemEventMultiDestroy(hEvt2);
649
650	rtThreadNativeDestroy(pThread);
651	RTMemFree(pThread);
652	}
653
654
655	/**
656	* Terminates the thread.
657	* Called by the thread wrapper function when the thread terminates.
658	*
659	* @param pThread The thread structure.
660	* @param rc The thread result code.
661	*/
662	DECLHIDDEN(void) rtThreadTerminate(PRTTHREADINT pThread, int rc)
663	{
664	Assert(pThread->cRefs >= 1);
665
666	#ifdef IPRT_WITH_GENERIC_TLS
667	/*
668	* Destroy TLS entries.
669	*/
670	rtThreadTlsDestruction(pThread);
671	#endif /* IPRT_WITH_GENERIC_TLS */
672
673	/*
674	* Set the rc, mark it terminated and signal anyone waiting.
675	*/
676	pThread->rc = rc;
677	rtThreadSetState(pThread, RTTHREADSTATE_TERMINATED);
678	ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAGS_TERMINATED);
679	if (pThread->EventTerminated != NIL_RTSEMEVENTMULTI)
680	RTSemEventMultiSignal(pThread->EventTerminated);
681
682	/*
683	* Remove the thread from the tree so that there will be no
684	* key clashes in the AVL tree and release our reference to ourself.
685	*/
686	rtThreadRemove(pThread);
687	rtThreadRelease(pThread);
688	}
689
690
691	/**
692	* The common thread main function.
693	* This is called by rtThreadNativeMain().
694	*
695	* @returns The status code of the thread.
696	* pThread is dereference by the thread before returning!
697	* @param pThread The thread structure.
698	* @param NativeThread The native thread id.
699	* @param pszThreadName The name of the thread (purely a dummy for backtrace).
700	*/
701	DECLCALLBACK(DECLHIDDEN(int)) rtThreadMain(PRTTHREADINT pThread, RTNATIVETHREAD NativeThread, const char *pszThreadName)
702	{
703	int rc;
704	NOREF(pszThreadName);
705	rtThreadInsert(pThread, NativeThread);
706	Log(("rtThreadMain: Starting: pThread=%p NativeThread=%RTnthrd Name=%s pfnThread=%p pvUser=%p\n",
707	pThread, NativeThread, pThread->szName, pThread->pfnThread, pThread->pvUser));
708
709	/*
710	* Change the priority.
711	*/
712	rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
713	#ifdef IN_RING3
714	AssertMsgRC(rc, ("Failed to set priority of thread %p (%RTnthrd / %s) to enmType=%d enmPriority=%d rc=%Rrc\n",
715	pThread, NativeThread, pThread->szName, pThread->enmType, g_enmProcessPriority, rc));
716	#else
717	AssertMsgRC(rc, ("Failed to set priority of thread %p (%RTnthrd / %s) to enmType=%d rc=%Rrc\n",
718	pThread, NativeThread, pThread->szName, pThread->enmType, rc));
719	#endif
720
721	/*
722	* Call thread function and terminate when it returns.
723	*/
724	rtThreadSetState(pThread, RTTHREADSTATE_RUNNING);
725	rc = pThread->pfnThread(pThread, pThread->pvUser);
726
727	/*
728	* Paranoia checks for leftover resources.
729	*/
730	#ifdef RTSEMRW_STRICT
731	int32_t cWrite = ASMAtomicReadS32(&pThread->cWriteLocks);
732	Assert(!cWrite);
733	int32_t cRead = ASMAtomicReadS32(&pThread->cReadLocks);
734	Assert(!cRead);
735	#endif
736
737	Log(("rtThreadMain: Terminating: rc=%d pThread=%p NativeThread=%RTnthrd Name=%s pfnThread=%p pvUser=%p\n",
738	rc, pThread, NativeThread, pThread->szName, pThread->pfnThread, pThread->pvUser));
739	rtThreadTerminate(pThread, rc);
740	return rc;
741	}
742
743
744	/**
745	* Create a new thread.
746	*
747	* @returns iprt status code.
748	* @param pThread Where to store the thread handle to the new thread. (optional)
749	* @param pfnThread The thread function.
750	* @param pvUser User argument.
751	* @param cbStack The size of the stack for the new thread.
752	* Use 0 for the default stack size.
753	* @param enmType The thread type. Used for deciding scheduling attributes
754	* of the thread.
755	* @param fFlags Flags of the RTTHREADFLAGS type (ORed together).
756	* @param pszName Thread name.
757	*/
758	RTDECL(int) RTThreadCreate(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
759	RTTHREADTYPE enmType, unsigned fFlags, const char *pszName)
760	{
761	int rc;
762	PRTTHREADINT pThreadInt;
763
764	LogFlow(("RTThreadCreate: pThread=%p pfnThread=%p pvUser=%p cbStack=%#x enmType=%d fFlags=%#x pszName=%p:{%s}\n",
765	pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszName, pszName));
766
767	/*
768	* Validate input.
769	*/
770	if (!VALID_PTR(pThread) && pThread)
771	{
772	Assert(VALID_PTR(pThread));
773	return VERR_INVALID_PARAMETER;
774	}
775	if (!VALID_PTR(pfnThread))
776	{
777	Assert(VALID_PTR(pfnThread));
778	return VERR_INVALID_PARAMETER;
779	}
780	if (!pszName \|\| !*pszName \|\| strlen(pszName) >= RTTHREAD_NAME_LEN)
781	{
782	AssertMsgFailed(("pszName=%s (max len is %d because of logging)\n", pszName, RTTHREAD_NAME_LEN - 1));
783	return VERR_INVALID_PARAMETER;
784	}
785	if (fFlags & ~RTTHREADFLAGS_MASK)
786	{
787	AssertMsgFailed(("fFlags=%#x\n", fFlags));
788	return VERR_INVALID_PARAMETER;
789	}
790
791	/*
792	* Allocate thread argument.
793	*/
794	pThreadInt = rtThreadAlloc(enmType, fFlags, 0, pszName);
795	if (pThreadInt)
796	{
797	RTNATIVETHREAD NativeThread;
798
799	pThreadInt->pfnThread = pfnThread;
800	pThreadInt->pvUser = pvUser;
801	pThreadInt->cbStack = cbStack;
802
803	rc = rtThreadNativeCreate(pThreadInt, &NativeThread);
804	if (RT_SUCCESS(rc))
805	{
806	rtThreadInsert(pThreadInt, NativeThread);
807	rtThreadRelease(pThreadInt);
808	Log(("RTThreadCreate: Created thread %p (%p) %s\n", pThreadInt, NativeThread, pszName));
809	if (pThread)
810	*pThread = pThreadInt;
811	return VINF_SUCCESS;
812	}
813
814	pThreadInt->cRefs = 1;
815	rtThreadRelease(pThreadInt);
816	}
817	else
818	rc = VERR_NO_TMP_MEMORY;
819	LogFlow(("RTThreadCreate: Failed to create thread, rc=%Rrc\n", rc));
820	AssertReleaseRC(rc);
821	return rc;
822	}
823	RT_EXPORT_SYMBOL(RTThreadCreate);
824
825
826	/**
827	* Create a new thread.
828	*
829	* Same as RTThreadCreate except the name is given in the RTStrPrintfV form.
830	*
831	* @returns iprt status code.
832	* @param pThread See RTThreadCreate.
833	* @param pfnThread See RTThreadCreate.
834	* @param pvUser See RTThreadCreate.
835	* @param cbStack See RTThreadCreate.
836	* @param enmType See RTThreadCreate.
837	* @param fFlags See RTThreadCreate.
838	* @param pszNameFmt Thread name format.
839	* @param va Format arguments.
840	*/
841	RTDECL(int) RTThreadCreateV(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
842	RTTHREADTYPE enmType, uint32_t fFlags, const char *pszNameFmt, va_list va)
843	{
844	char szName[RTTHREAD_NAME_LEN * 2];
845	RTStrPrintfV(szName, sizeof(szName), pszNameFmt, va);
846	return RTThreadCreate(pThread, pfnThread, pvUser, cbStack, enmType, fFlags, szName);
847	}
848	RT_EXPORT_SYMBOL(RTThreadCreateV);
849
850
851	/**
852	* Create a new thread.
853	*
854	* Same as RTThreadCreate except the name is given in the RTStrPrintf form.
855	*
856	* @returns iprt status code.
857	* @param pThread See RTThreadCreate.
858	* @param pfnThread See RTThreadCreate.
859	* @param pvUser See RTThreadCreate.
860	* @param cbStack See RTThreadCreate.
861	* @param enmType See RTThreadCreate.
862	* @param fFlags See RTThreadCreate.
863	* @param pszNameFmt Thread name format.
864	* @param ... Format arguments.
865	*/
866	RTDECL(int) RTThreadCreateF(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
867	RTTHREADTYPE enmType, uint32_t fFlags, const char *pszNameFmt, ...)
868	{
869	va_list va;
870	int rc;
871	va_start(va, pszNameFmt);
872	rc = RTThreadCreateV(pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszNameFmt, va);
873	va_end(va);
874	return rc;
875	}
876	RT_EXPORT_SYMBOL(RTThreadCreateF);
877
878
879	/**
880	* Gets the native thread id of a IPRT thread.
881	*
882	* @returns The native thread id.
883	* @param Thread The IPRT thread.
884	*/
885	RTDECL(RTNATIVETHREAD) RTThreadGetNative(RTTHREAD Thread)
886	{
887	PRTTHREADINT pThread = rtThreadGet(Thread);
888	if (pThread)
889	{
890	RTNATIVETHREAD NativeThread = (RTNATIVETHREAD)pThread->Core.Key;
891	rtThreadRelease(pThread);
892	return NativeThread;
893	}
894	return NIL_RTNATIVETHREAD;
895	}
896	RT_EXPORT_SYMBOL(RTThreadGetNative);
897
898
899	/**
900	* Gets the IPRT thread of a native thread.
901	*
902	* @returns The IPRT thread handle
903	* @returns NIL_RTTHREAD if not a thread known to IPRT.
904	* @param NativeThread The native thread handle/id.
905	*/
906	RTDECL(RTTHREAD) RTThreadFromNative(RTNATIVETHREAD NativeThread)
907	{
908	PRTTHREADINT pThread = rtThreadGetByNative(NativeThread);
909	if (pThread)
910	return pThread;
911	return NIL_RTTHREAD;
912	}
913	RT_EXPORT_SYMBOL(RTThreadFromNative);
914
915
916	/**
917	* Gets the name of the current thread thread.
918	*
919	* @returns Pointer to readonly name string.
920	* @returns NULL on failure.
921	*/
922	RTDECL(const char *) RTThreadSelfName(void)
923	{
924	RTTHREAD Thread = RTThreadSelf();
925	if (Thread != NIL_RTTHREAD)
926	{
927	PRTTHREADINT pThread = rtThreadGet(Thread);
928	if (pThread)
929	{
930	const char *szName = pThread->szName;
931	rtThreadRelease(pThread);
932	return szName;
933	}
934	}
935	return NULL;
936	}
937	RT_EXPORT_SYMBOL(RTThreadSelfName);
938
939
940	/**
941	* Gets the name of a thread.
942	*
943	* @returns Pointer to readonly name string.
944	* @returns NULL on failure.
945	* @param Thread Thread handle of the thread to query the name of.
946	*/
947	RTDECL(const char *) RTThreadGetName(RTTHREAD Thread)
948	{
949	PRTTHREADINT pThread;
950	if (Thread == NIL_RTTHREAD)
951	return NULL;
952	pThread = rtThreadGet(Thread);
953	if (pThread)
954	{
955	const char *szName = pThread->szName;
956	rtThreadRelease(pThread);
957	return szName;
958	}
959	return NULL;
960	}
961	RT_EXPORT_SYMBOL(RTThreadGetName);
962
963
964	/**
965	* Sets the name of a thread.
966	*
967	* @returns iprt status code.
968	* @param Thread Thread handle of the thread to query the name of.
969	* @param pszName The thread name.
970	*/
971	RTDECL(int) RTThreadSetName(RTTHREAD Thread, const char *pszName)
972	{
973	/*
974	* Validate input.
975	*/
976	PRTTHREADINT pThread;
977	size_t cchName = strlen(pszName);
978	if (cchName >= RTTHREAD_NAME_LEN)
979	{
980	AssertMsgFailed(("pszName=%s is too long, max is %d\n", pszName, RTTHREAD_NAME_LEN - 1));
981	return VERR_INVALID_PARAMETER;
982	}
983	pThread = rtThreadGet(Thread);
984	if (!pThread)
985	return VERR_INVALID_HANDLE;
986
987	/*
988	* Update the name.
989	*/
990	pThread->szName[cchName] = '\0'; /* paranoia */
991	memcpy(pThread->szName, pszName, cchName);
992	rtThreadRelease(pThread);
993	return VINF_SUCCESS;
994	}
995	RT_EXPORT_SYMBOL(RTThreadSetName);
996
997
998	/**
999	* Checks if the specified thread is the main thread.
1000	*
1001	* @returns true if it is, false if it isn't.
1002	*
1003	* @param hThread The thread handle.
1004	*
1005	* @remarks This function may not return the correct value when rtR3Init was
1006	* called on a thread of the than the main one. This could for
1007	* instance happen when the DLL/DYLIB/SO containing IPRT is dynamically
1008	* loaded at run time by a different thread.
1009	*/
1010	RTDECL(bool) RTThreadIsMain(RTTHREAD hThread)
1011	{
1012	PRTTHREADINT pThread = rtThreadGet(hThread);
1013	if (pThread)
1014	{
1015	bool fRc = !!(pThread->fIntFlags & RTTHREADINT_FLAGS_MAIN);
1016	rtThreadRelease(pThread);
1017	return fRc;
1018	}
1019	return false;
1020	}
1021	RT_EXPORT_SYMBOL(RTThreadIsMain);
1022
1023
1024	RTDECL(bool) RTThreadIsSelfAlive(void)
1025	{
1026	if (g_frtThreadInitialized)
1027	{
1028	RTTHREAD hSelf = RTThreadSelf();
1029	if (hSelf != NIL_RTTHREAD)
1030	{
1031	/*
1032	* Inspect the thread state. ASSUMES thread state order.
1033	*/
1034	RTTHREADSTATE enmState = rtThreadGetState(hSelf);
1035	if ( enmState >= RTTHREADSTATE_RUNNING
1036	&& enmState <= RTTHREADSTATE_END)
1037	return true;
1038	}
1039	}
1040	return false;
1041	}
1042	RT_EXPORT_SYMBOL(RTThreadIsSelfAlive);
1043
1044
1045	RTDECL(bool) RTThreadIsSelfKnown(void)
1046	{
1047	if (g_frtThreadInitialized)
1048	{
1049	RTTHREAD hSelf = RTThreadSelf();
1050	if (hSelf != NIL_RTTHREAD)
1051	return true;
1052	}
1053	return false;
1054	}
1055	RT_EXPORT_SYMBOL(RTThreadIsSelfKnown);
1056
1057
1058	RTDECL(bool) RTThreadIsInitialized(void)
1059	{
1060	return g_frtThreadInitialized;
1061	}
1062	RT_EXPORT_SYMBOL(RTThreadIsInitialized);
1063
1064
1065	/**
1066	* Signal the user event.
1067	*
1068	* @returns iprt status code.
1069	*/
1070	RTDECL(int) RTThreadUserSignal(RTTHREAD Thread)
1071	{
1072	int rc;
1073	PRTTHREADINT pThread = rtThreadGet(Thread);
1074	if (pThread)
1075	{
1076	rc = RTSemEventMultiSignal(pThread->EventUser);
1077	rtThreadRelease(pThread);
1078	}
1079	else
1080	rc = VERR_INVALID_HANDLE;
1081	return rc;
1082	}
1083	RT_EXPORT_SYMBOL(RTThreadUserSignal);
1084
1085
1086	/**
1087	* Wait for the user event, resume on interruption.
1088	*
1089	* @returns iprt status code.
1090	* @param Thread The thread to wait for.
1091	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
1092	* an indefinite wait.
1093	*/
1094	RTDECL(int) RTThreadUserWait(RTTHREAD Thread, RTMSINTERVAL cMillies)
1095	{
1096	int rc;
1097	PRTTHREADINT pThread = rtThreadGet(Thread);
1098	if (pThread)
1099	{
1100	rc = RTSemEventMultiWait(pThread->EventUser, cMillies);
1101	rtThreadRelease(pThread);
1102	}
1103	else
1104	rc = VERR_INVALID_HANDLE;
1105	return rc;
1106	}
1107	RT_EXPORT_SYMBOL(RTThreadUserWait);
1108
1109
1110	/**
1111	* Wait for the user event, return on interruption.
1112	*
1113	* @returns iprt status code.
1114	* @param Thread The thread to wait for.
1115	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
1116	* an indefinite wait.
1117	*/
1118	RTDECL(int) RTThreadUserWaitNoResume(RTTHREAD Thread, RTMSINTERVAL cMillies)
1119	{
1120	int rc;
1121	PRTTHREADINT pThread = rtThreadGet(Thread);
1122	if (pThread)
1123	{
1124	rc = RTSemEventMultiWaitNoResume(pThread->EventUser, cMillies);
1125	rtThreadRelease(pThread);
1126	}
1127	else
1128	rc = VERR_INVALID_HANDLE;
1129	return rc;
1130	}
1131	RT_EXPORT_SYMBOL(RTThreadUserWaitNoResume);
1132
1133
1134	/**
1135	* Reset the user event.
1136	*
1137	* @returns iprt status code.
1138	* @param Thread The thread to reset.
1139	*/
1140	RTDECL(int) RTThreadUserReset(RTTHREAD Thread)
1141	{
1142	int rc;
1143	PRTTHREADINT pThread = rtThreadGet(Thread);
1144	if (pThread)
1145	{
1146	rc = RTSemEventMultiReset(pThread->EventUser);
1147	rtThreadRelease(pThread);
1148	}
1149	else
1150	rc = VERR_INVALID_HANDLE;
1151	return rc;
1152	}
1153	RT_EXPORT_SYMBOL(RTThreadUserReset);
1154
1155
1156	/**
1157	* Wait for the thread to terminate.
1158	*
1159	* @returns iprt status code.
1160	* @param Thread The thread to wait for.
1161	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
1162	* an indefinite wait.
1163	* @param prc Where to store the return code of the thread. Optional.
1164	* @param fAutoResume Whether or not to resume the wait on VERR_INTERRUPTED.
1165	*/
1166	static int rtThreadWait(RTTHREAD Thread, RTMSINTERVAL cMillies, int *prc, bool fAutoResume)
1167	{
1168	int rc = VERR_INVALID_HANDLE;
1169	if (Thread != NIL_RTTHREAD)
1170	{
1171	PRTTHREADINT pThread = rtThreadGet(Thread);
1172	if (pThread)
1173	{
1174	if (pThread->fFlags & RTTHREADFLAGS_WAITABLE)
1175	{
1176	#if defined(IN_RING3) && defined(RT_OS_WINDOWS)
1177	if (RT_LIKELY(rtThreadNativeIsAliveKludge(pThread)))
1178	#endif
1179	{
1180	if (fAutoResume)
1181	rc = RTSemEventMultiWait(pThread->EventTerminated, cMillies);
1182	else
1183	rc = RTSemEventMultiWaitNoResume(pThread->EventTerminated, cMillies);
1184	}
1185	#if defined(IN_RING3) && defined(RT_OS_WINDOWS)
1186	else
1187	{
1188	rc = VINF_SUCCESS;
1189	if (pThread->rc == VERR_PROCESS_RUNNING)
1190	pThread->rc = VERR_THREAD_IS_DEAD;
1191	}
1192	#endif
1193	if (RT_SUCCESS(rc))
1194	{
1195	if (prc)
1196	*prc = pThread->rc;
1197
1198	/*
1199	* If the thread is marked as waitable, we'll do one additional
1200	* release in order to free up the thread structure (see how we
1201	* init cRef in rtThreadAlloc()).
1202	*/
1203	if (ASMAtomicBitTestAndClear(&pThread->fFlags, RTTHREADFLAGS_WAITABLE_BIT))
1204	{
1205	rtThreadRelease(pThread);
1206	#ifdef IN_RING0
1207	/*
1208	* IPRT termination kludge. Call native code to make sure
1209	* the last thread is really out of IPRT to prevent it from
1210	* crashing after we destroyed the spinlock in rtThreadTerm.
1211	*/
1212	if ( ASMAtomicReadU32(&g_cThreadInTree) == 1
1213	&& ASMAtomicReadU32(&pThread->cRefs) > 1)
1214	rtThreadNativeWaitKludge(pThread);
1215	#endif
1216	}
1217	}
1218	}
1219	else
1220	{
1221	rc = VERR_THREAD_NOT_WAITABLE;
1222	AssertRC(rc);
1223	}
1224	rtThreadRelease(pThread);
1225	}
1226	}
1227	return rc;
1228	}
1229
1230
1231	/**
1232	* Wait for the thread to terminate, resume on interruption.
1233	*
1234	* @returns iprt status code.
1235	* Will not return VERR_INTERRUPTED.
1236	* @param Thread The thread to wait for.
1237	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
1238	* an indefinite wait.
1239	* @param prc Where to store the return code of the thread. Optional.
1240	*/
1241	RTDECL(int) RTThreadWait(RTTHREAD Thread, RTMSINTERVAL cMillies, int *prc)
1242	{
1243	int rc = rtThreadWait(Thread, cMillies, prc, true);
1244	Assert(rc != VERR_INTERRUPTED);
1245	return rc;
1246	}
1247	RT_EXPORT_SYMBOL(RTThreadWait);
1248
1249
1250	/**
1251	* Wait for the thread to terminate, return on interruption.
1252	*
1253	* @returns iprt status code.
1254	* @param Thread The thread to wait for.
1255	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
1256	* an indefinite wait.
1257	* @param prc Where to store the return code of the thread. Optional.
1258	*/
1259	RTDECL(int) RTThreadWaitNoResume(RTTHREAD Thread, RTMSINTERVAL cMillies, int *prc)
1260	{
1261	return rtThreadWait(Thread, cMillies, prc, false);
1262	}
1263	RT_EXPORT_SYMBOL(RTThreadWaitNoResume);
1264
1265
1266	/**
1267	* Changes the type of the specified thread.
1268	*
1269	* @returns iprt status code.
1270	* @param Thread The thread which type should be changed.
1271	* @param enmType The new thread type.
1272	*/
1273	RTDECL(int) RTThreadSetType(RTTHREAD Thread, RTTHREADTYPE enmType)
1274	{
1275	/*
1276	* Validate input.
1277	*/
1278	int rc;
1279	if ( enmType > RTTHREADTYPE_INVALID
1280	&& enmType < RTTHREADTYPE_END)
1281	{
1282	PRTTHREADINT pThread = rtThreadGet(Thread);
1283	if (pThread)
1284	{
1285	if (rtThreadIsAlive(pThread))
1286	{
1287	/*
1288	* Do the job.
1289	*/
1290	RT_THREAD_LOCK_RW();
1291	rc = rtThreadNativeSetPriority(pThread, enmType);
1292	if (RT_SUCCESS(rc))
1293	ASMAtomicXchgSize(&pThread->enmType, enmType);
1294	RT_THREAD_UNLOCK_RW();
1295	if (RT_FAILURE(rc))
1296	Log(("RTThreadSetType: failed on thread %p (%s), rc=%Rrc!!!\n", Thread, pThread->szName, rc));
1297	}
1298	else
1299	rc = VERR_THREAD_IS_DEAD;
1300	rtThreadRelease(pThread);
1301	}
1302	else
1303	rc = VERR_INVALID_HANDLE;
1304	}
1305	else
1306	{
1307	AssertMsgFailed(("enmType=%d\n", enmType));
1308	rc = VERR_INVALID_PARAMETER;
1309	}
1310	return rc;
1311	}
1312	RT_EXPORT_SYMBOL(RTThreadSetType);
1313
1314
1315	/**
1316	* Gets the type of the specified thread.
1317	*
1318	* @returns The thread type.
1319	* @returns RTTHREADTYPE_INVALID if the thread handle is invalid.
1320	* @param Thread The thread in question.
1321	*/
1322	RTDECL(RTTHREADTYPE) RTThreadGetType(RTTHREAD Thread)
1323	{
1324	RTTHREADTYPE enmType = RTTHREADTYPE_INVALID;
1325	PRTTHREADINT pThread = rtThreadGet(Thread);
1326	if (pThread)
1327	{
1328	enmType = pThread->enmType;
1329	rtThreadRelease(pThread);
1330	}
1331	return enmType;
1332	}
1333	RT_EXPORT_SYMBOL(RTThreadGetType);
1334
1335	#ifdef IN_RING3
1336
1337	/**
1338	* Recalculates scheduling attributes for the default process
1339	* priority using the specified priority type for the calling thread.
1340	*
1341	* The scheduling attributes are targeted at threads and they are protected
1342	* by the thread read-write semaphore, that's why RTProc is forwarding the
1343	* operation to RTThread.
1344	*
1345	* @returns iprt status code.
1346	* @remarks Will only work for strict builds.
1347	*/
1348	int rtThreadDoCalcDefaultPriority(RTTHREADTYPE enmType)
1349	{
1350	RT_THREAD_LOCK_RW();
1351	int rc = rtSchedNativeCalcDefaultPriority(enmType);
1352	RT_THREAD_UNLOCK_RW();
1353	return rc;
1354	}
1355
1356
1357	/**
1358	* Thread enumerator - sets the priority of one thread.
1359	*
1360	* @returns 0 to continue.
1361	* @returns !0 to stop. In our case a VERR_ code.
1362	* @param pNode The thread node.
1363	* @param pvUser The new priority.
1364	*/
1365	static DECLCALLBACK(int) rtThreadSetPriorityOne(PAVLPVNODECORE pNode, void *pvUser)
1366	{
1367	PRTTHREADINT pThread = (PRTTHREADINT)pNode;
1368	if (!rtThreadIsAlive(pThread))
1369	return VINF_SUCCESS;
1370	int rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
1371	if (RT_SUCCESS(rc)) /* hide any warnings */
1372	return VINF_SUCCESS;
1373	NOREF(pvUser);
1374	return rc;
1375	}
1376
1377
1378	/**
1379	* Attempts to alter the priority of the current process.
1380	*
1381	* The scheduling attributes are targeted at threads and they are protected
1382	* by the thread read-write semaphore, that's why RTProc is forwarding the
1383	* operation to RTThread. This operation also involves updating all thread
1384	* which is much faster done from RTThread.
1385	*
1386	* @returns iprt status code.
1387	* @param enmPriority The new priority.
1388	*/
1389	DECLHIDDEN(int) rtThreadDoSetProcPriority(RTPROCPRIORITY enmPriority)
1390	{
1391	LogFlow(("rtThreadDoSetProcPriority: enmPriority=%d\n", enmPriority));
1392
1393	/*
1394	* First validate that we're allowed by the OS to use all the
1395	* scheduling attributes defined by the specified process priority.
1396	*/
1397	RT_THREAD_LOCK_RW();
1398	int rc = rtProcNativeSetPriority(enmPriority);
1399	if (RT_SUCCESS(rc))
1400	{
1401	/*
1402	* Update the priority of existing thread.
1403	*/
1404	rc = RTAvlPVDoWithAll(&g_ThreadTree, true, rtThreadSetPriorityOne, NULL);
1405	if (RT_SUCCESS(rc))
1406	ASMAtomicXchgSize(&g_enmProcessPriority, enmPriority);
1407	else
1408	{
1409	/*
1410	* Failed, restore the priority.
1411	*/
1412	rtProcNativeSetPriority(g_enmProcessPriority);
1413	RTAvlPVDoWithAll(&g_ThreadTree, true, rtThreadSetPriorityOne, NULL);
1414	}
1415	}
1416	RT_THREAD_UNLOCK_RW();
1417	LogFlow(("rtThreadDoSetProcPriority: returns %Rrc\n", rc));
1418	return rc;
1419	}
1420
1421
1422	/**
1423	* Change the thread state to blocking.
1424	*
1425	* @param hThread The current thread.
1426	* @param enmState The sleep state.
1427	* @param fReallySleeping Really going to sleep now.
1428	*/
1429	RTDECL(void) RTThreadBlocking(RTTHREAD hThread, RTTHREADSTATE enmState, bool fReallySleeping)
1430	{
1431	Assert(RTTHREAD_IS_SLEEPING(enmState));
1432	PRTTHREADINT pThread = hThread;
1433	if (pThread != NIL_RTTHREAD)
1434	{
1435	Assert(pThread == RTThreadSelf());
1436	if (rtThreadGetState(pThread) == RTTHREADSTATE_RUNNING)
1437	rtThreadSetState(pThread, enmState);
1438	ASMAtomicWriteBool(&pThread->fReallySleeping, fReallySleeping);
1439	}
1440	}
1441	RT_EXPORT_SYMBOL(RTThreadBlocking);
1442
1443
1444	/**
1445	* Unblocks a thread.
1446	*
1447	* This function is paired with rtThreadBlocking.
1448	*
1449	* @param hThread The current thread.
1450	* @param enmCurState The current state, used to check for nested blocking.
1451	* The new state will be running.
1452	*/
1453	RTDECL(void) RTThreadUnblocked(RTTHREAD hThread, RTTHREADSTATE enmCurState)
1454	{
1455	PRTTHREADINT pThread = hThread;
1456	if (pThread != NIL_RTTHREAD)
1457	{
1458	Assert(pThread == RTThreadSelf());
1459	ASMAtomicWriteBool(&pThread->fReallySleeping, false);
1460
1461	RTTHREADSTATE enmActualState = rtThreadGetState(pThread);
1462	if (enmActualState == enmCurState)
1463	{
1464	rtThreadSetState(pThread, RTTHREADSTATE_RUNNING);
1465	if ( pThread->LockValidator.pRec
1466	&& pThread->LockValidator.enmRecState == enmCurState)
1467	ASMAtomicWriteNullPtr(&pThread->LockValidator.pRec);
1468	}
1469	/* This is a bit ugly... :-/ */
1470	else if ( ( enmActualState == RTTHREADSTATE_TERMINATED
1471	\|\| enmActualState == RTTHREADSTATE_INITIALIZING)
1472	&& pThread->LockValidator.pRec)
1473	ASMAtomicWriteNullPtr(&pThread->LockValidator.pRec);
1474	Assert( pThread->LockValidator.pRec == NULL
1475	\|\| RTTHREAD_IS_SLEEPING(enmActualState));
1476	}
1477	}
1478	RT_EXPORT_SYMBOL(RTThreadUnblocked);
1479
1480
1481	/**
1482	* Get the current thread state.
1483	*
1484	* @returns The thread state.
1485	* @param hThread The thread.
1486	*/
1487	RTDECL(RTTHREADSTATE) RTThreadGetState(RTTHREAD hThread)
1488	{
1489	RTTHREADSTATE enmState = RTTHREADSTATE_INVALID;
1490	PRTTHREADINT pThread = rtThreadGet(hThread);
1491	if (pThread)
1492	{
1493	enmState = rtThreadGetState(pThread);
1494	rtThreadRelease(pThread);
1495	}
1496	return enmState;
1497	}
1498	RT_EXPORT_SYMBOL(RTThreadGetState);
1499
1500
1501	RTDECL(RTTHREADSTATE) RTThreadGetReallySleeping(RTTHREAD hThread)
1502	{
1503	RTTHREADSTATE enmState = RTTHREADSTATE_INVALID;
1504	PRTTHREADINT pThread = rtThreadGet(hThread);
1505	if (pThread)
1506	{
1507	enmState = rtThreadGetState(pThread);
1508	if (!ASMAtomicUoReadBool(&pThread->fReallySleeping))
1509	enmState = RTTHREADSTATE_RUNNING;
1510	rtThreadRelease(pThread);
1511	}
1512	return enmState;
1513	}
1514	RT_EXPORT_SYMBOL(RTThreadGetReallySleeping);
1515
1516
1517	/**
1518	* Translate a thread state into a string.
1519	*
1520	* @returns Pointer to a read-only string containing the state name.
1521	* @param enmState The state.
1522	*/
1523	RTDECL(const char *) RTThreadStateName(RTTHREADSTATE enmState)
1524	{
1525	switch (enmState)
1526	{
1527	case RTTHREADSTATE_INVALID: return "INVALID";
1528	case RTTHREADSTATE_INITIALIZING: return "INITIALIZING";
1529	case RTTHREADSTATE_TERMINATED: return "TERMINATED";
1530	case RTTHREADSTATE_RUNNING: return "RUNNING";
1531	case RTTHREADSTATE_CRITSECT: return "CRITSECT";
1532	case RTTHREADSTATE_EVENT: return "EVENT";
1533	case RTTHREADSTATE_EVENT_MULTI: return "EVENT_MULTI";
1534	case RTTHREADSTATE_FAST_MUTEX: return "FAST_MUTEX";
1535	case RTTHREADSTATE_MUTEX: return "MUTEX";
1536	case RTTHREADSTATE_RW_READ: return "RW_READ";
1537	case RTTHREADSTATE_RW_WRITE: return "RW_WRITE";
1538	case RTTHREADSTATE_SLEEP: return "SLEEP";
1539	case RTTHREADSTATE_SPIN_MUTEX: return "SPIN_MUTEX";
1540	default: return "UnknownThreadState";
1541	}
1542	}
1543	RT_EXPORT_SYMBOL(RTThreadStateName);
1544
1545	#endif /* IN_RING3 */
1546	#ifdef IPRT_WITH_GENERIC_TLS
1547
1548	/**
1549	* Thread enumerator - clears a TLS entry.
1550	*
1551	* @returns 0.
1552	* @param pNode The thread node.
1553	* @param pvUser The TLS index.
1554	*/
1555	static DECLCALLBACK(int) rtThreadClearTlsEntryCallback(PAVLPVNODECORE pNode, void *pvUser)
1556	{
1557	PRTTHREADINT pThread = (PRTTHREADINT)pNode;
1558	RTTLS iTls = (RTTLS)(uintptr_t)pvUser;
1559	ASMAtomicWriteNullPtr(&pThread->apvTlsEntries[iTls]);
1560	return 0;
1561	}
1562
1563
1564	/**
1565	* Helper for the generic TLS implementation that clears a given TLS
1566	* entry on all threads.
1567	*
1568	* @param iTls The TLS entry. (valid)
1569	*/
1570	DECLHIDDEN(void) rtThreadClearTlsEntry(RTTLS iTls)
1571	{
1572	RT_THREAD_LOCK_RD();
1573	RTAvlPVDoWithAll(&g_ThreadTree, true /* fFromLeft/, rtThreadClearTlsEntryCallback, (void )(uintptr_t)iTls);
1574	RT_THREAD_UNLOCK_RD();
1575	}
1576
1577	#endif /* IPRT_WITH_GENERIC_TLS */
1578
1579
1580	#if defined(RT_OS_WINDOWS) && defined(IN_RING3)
1581
1582	/**
1583	* Thread enumeration callback for RTThreadNameThreads
1584	*/
1585	static DECLCALLBACK(int) rtThreadNameThreadCallback(PAVLPVNODECORE pNode, void *pvUser)
1586	{
1587	PRTTHREADINT pThread = (PRTTHREADINT)pNode;
1588	rtThreadNativeInformDebugger(pThread);
1589	RT_NOREF_PV(pvUser);
1590	return 0;
1591	}
1592
1593	/**
1594	* A function that can be called from the windows debugger to get the names of
1595	* all threads when attaching to a process.
1596	*
1597	* Usage: .call VBoxRT!RTThreadNameThreads()
1598	*
1599	* @returns 0
1600	* @remarks Do not call from source code as it skips locks.
1601	*/
1602	extern "C" RTDECL(int) RTThreadNameThreads(void);
1603	RTDECL(int) RTThreadNameThreads(void)
1604	{
1605	return RTAvlPVDoWithAll(&g_ThreadTree, true /* fFromLeft*/, rtThreadNameThreadCallback, NULL);
1606	}
1607
1608	#endif

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

source: vbox/trunk/src/VBox/Runtime/common/misc/thread.cpp@ 78052

Download in other formats: