thread.cpp@ 11836

Last change on this file since 11836 was 11596, checked in by vboxsync, 16 years ago
iprt: Added RTThreadCreateV and RTThreadCreateF which takes a format string and arguments for the thread name.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 47.3 KB

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

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

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

Download in other formats: