thread.cpp@ 8155

Last change on this file since 8155 was 8155, checked in by vboxsync, 17 years ago
The Big Sun Rebranding Header Change
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 41.6 KB

Line
1	/* $Id: thread.cpp 8155 2008-04-18 15:16:47Z vboxsync $ */
2	/** @file
3	* innotek Portable Runtime - 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 RTCreateThread
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	inline 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	inline 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	inline void rtThreadUnLockRW(void)
220	{
221	int rc = RTSemRWReleaseWrite(g_ThreadRWSem);
222	AssertReleaseRC(rc);
223	}
224
225
226	inline 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	*/
247	int rc = VERR_NO_MEMORY;
248	PRTTHREADINT pThread = rtThreadAlloc(enmType, fFlags, RTTHREADINT_FLAGS_ALIEN, pszName);
249	if (pThread)
250	{
251	RTNATIVETHREAD NativeThread = RTThreadNativeSelf();
252	rc = rtThreadNativeAdopt(pThread);
253	if (RT_SUCCESS(rc))
254	{
255	rtThreadInsert(pThread, NativeThread);
256	pThread->enmState = RTTHREADSTATE_RUNNING;
257	rtThreadRelease(pThread);
258	}
259	}
260	return rc;
261	}
262
263
264	/**
265	* Adopts a non-IPRT thread.
266	*
267	* @returns IPRT status code.
268	* @param enmType The thread type.
269	* @param fFlags The thread flags. RTTHREADFLAGS_WAITABLE is not currently allowed.
270	* @param pszName The thread name. Optional.
271	* @param pThread Where to store the thread handle. Optional.
272	*/
273	RTDECL(int) RTThreadAdopt(RTTHREADTYPE enmType, unsigned fFlags, const char *pszName, PRTTHREAD pThread)
274	{
275	AssertReturn(!(fFlags & RTTHREADFLAGS_WAITABLE), VERR_INVALID_PARAMETER);
276	AssertReturn(!pszName \|\| VALID_PTR(pszName), VERR_INVALID_POINTER);
277	AssertReturn(!pThread \|\| VALID_PTR(pThread), VERR_INVALID_POINTER);
278
279	int rc = VINF_SUCCESS;
280	RTTHREAD Thread = RTThreadSelf();
281	if (Thread == NIL_RTTHREAD)
282	{
283	/* generate a name if none was given. */
284	char szName[RTTHREAD_NAME_LEN];
285	if (!pszName \|\| !*pszName)
286	{
287	static uint32_t s_i32AlienId = 0;
288	uint32_t i32Id = ASMAtomicIncU32(&s_i32AlienId);
289	RTStrPrintf(szName, sizeof(szName), "ALIEN-%RX32", i32Id);
290	pszName = szName;
291	}
292
293	/* try adopt it */
294	rc = rtThreadAdopt(enmType, fFlags, pszName);
295	Thread = RTThreadSelf();
296	Log(("RTThreadAdopt: %RTthrd %RTnthrd '%s' enmType=%d fFlags=%#x rc=%Rrc\n",
297	Thread, RTThreadNativeSelf(), pszName, enmType, fFlags, rc));
298	}
299	else
300	Log(("RTThreadAdopt: %RTthrd %RTnthrd '%s' enmType=%d fFlags=%#x - already adopted!\n",
301	Thread, RTThreadNativeSelf(), pszName, enmType, fFlags));
302
303	if (pThread)
304	*pThread = Thread;
305	return rc;
306	}
307
308
309	/**
310	* Allocates a per thread data structure and initializes the basic fields.
311	*
312	* @returns Pointer to per thread data structure.
313	* This is reference once.
314	* @returns NULL on failure.
315	* @param enmType The thread type.
316	* @param fFlags The thread flags.
317	* @param fIntFlags The internal thread flags.
318	* @param pszName Pointer to the thread name.
319	*/
320	PRTTHREADINT rtThreadAlloc(RTTHREADTYPE enmType, unsigned fFlags, unsigned fIntFlags, const char *pszName)
321	{
322	PRTTHREADINT pThread = (PRTTHREADINT)RTMemAllocZ(sizeof(RTTHREADINT));
323	if (pThread)
324	{
325	pThread->Core.Key = (void*)NIL_RTTHREAD;
326	pThread->u32Magic = RTTHREADINT_MAGIC;
327	size_t cchName = strlen(pszName);
328	if (cchName >= RTTHREAD_NAME_LEN)
329	cchName = RTTHREAD_NAME_LEN - 1;
330	memcpy(pThread->szName, pszName, cchName);
331	pThread->szName[cchName] = '\0';
332	pThread->cRefs = 2 + !!(fFlags & RTTHREADFLAGS_WAITABLE); /* And extra reference if waitable. */
333	pThread->rc = VERR_PROCESS_RUNNING; /** @todo get a better error code! */
334	pThread->enmType = enmType;
335	pThread->fFlags = fFlags;
336	pThread->fIntFlags = fIntFlags;
337	pThread->enmState = RTTHREADSTATE_INITIALIZING;
338	int rc = RTSemEventMultiCreate(&pThread->EventUser);
339	if (RT_SUCCESS(rc))
340	{
341	rc = RTSemEventMultiCreate(&pThread->EventTerminated);
342	if (RT_SUCCESS(rc))
343	return pThread;
344	RTSemEventMultiDestroy(pThread->EventUser);
345	}
346	RTMemFree(pThread);
347	}
348	return NULL;
349	}
350
351
352	/**
353	* Insert the per thread data structure into the tree.
354	*
355	* This can be called from both the thread it self and the parent,
356	* thus it must handle insertion failures in a nice manner.
357	*
358	* @param pThread Pointer to thread structure allocated by rtThreadAlloc().
359	* @param NativeThread The native thread id.
360	*/
361	void rtThreadInsert(PRTTHREADINT pThread, RTNATIVETHREAD NativeThread)
362	{
363	Assert(pThread);
364	Assert(pThread->u32Magic == RTTHREADINT_MAGIC);
365
366	RT_THREAD_LOCK_TMP(Tmp);
367	RT_THREAD_LOCK_RW(Tmp);
368
369	/*
370	* Before inserting we must check if there is a thread with this id
371	* in the tree already. We're racing parent and child on insert here
372	* so that the handle is valid in both ends when they return / start.
373	*
374	* If it's not ourself we find, it's a dead alien thread and we will
375	* unlink it from the tree. Alien threads will be released at this point.
376	*/
377	PRTTHREADINT pThreadOther = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
378	if (pThreadOther != pThread)
379	{
380	/* remove dead alien if any */
381	if (pThreadOther)
382	{
383	Assert(pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN);
384	ASMAtomicBitClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT);
385	rtThreadRemoveLocked(pThreadOther);
386	if (pThreadOther->fIntFlags & RTTHREADINT_FLAGS_ALIEN)
387	rtThreadRelease(pThreadOther);
388	}
389
390	/* insert the thread */
391	pThread->Core.Key = (void *)NativeThread;
392	bool fRc = RTAvlPVInsert(&g_ThreadTree, &pThread->Core);
393	ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE);
394
395	AssertReleaseMsg(fRc, ("Lock problem? %p (%RTnthrd) %s\n", pThread, NativeThread, pThread->szName));
396	NOREF(fRc);
397	}
398
399	RT_THREAD_UNLOCK_RW(Tmp);
400	}
401
402
403	/**
404	* Removes the thread from the AVL tree, call owns the tree lock
405	* and has cleared the RTTHREADINT_FLAG_IN_TREE bit.
406	*
407	* @param pThread The thread to remove.
408	*/
409	static void rtThreadRemoveLocked(PRTTHREADINT pThread)
410	{
411	PRTTHREADINT pThread2 = (PRTTHREADINT)RTAvlPVRemove(&g_ThreadTree, pThread->Core.Key);
412	AssertMsg(pThread2 == pThread, ("%p(%s) != %p (%p/%s)\n", pThread2, pThread2 ? pThread2->szName : "<null>",
413	pThread, pThread->Core.Key, pThread->szName));
414	NOREF(pThread2);
415	}
416
417
418	/**
419	* Removes the thread from the AVL tree.
420	*
421	* @param pThread The thread to remove.
422	*/
423	static void rtThreadRemove(PRTTHREADINT pThread)
424	{
425	RT_THREAD_LOCK_TMP(Tmp);
426	RT_THREAD_LOCK_RW(Tmp);
427	if (ASMAtomicBitTestAndClear(&pThread->fIntFlags, RTTHREADINT_FLAG_IN_TREE_BIT))
428	rtThreadRemoveLocked(pThread);
429	RT_THREAD_UNLOCK_RW(Tmp);
430	}
431
432
433	/**
434	* Checks if a thread is alive or not.
435	*
436	* @returns true if the thread is alive (or we don't really know).
437	* @returns false if the thread has surely terminate.
438	*/
439	DECLINLINE(bool) rtThreadIsAlive(PRTTHREADINT pThread)
440	{
441	return !(pThread->fIntFlags & RTTHREADINT_FLAGS_TERMINATED);
442	}
443
444
445	/**
446	* Gets a thread by it's native ID.
447	*
448	* @returns pointer to the thread structure.
449	* @returns NULL if not a thread IPRT knows.
450	* @param NativeThread The native thread id.
451	*/
452	PRTTHREADINT rtThreadGetByNative(RTNATIVETHREAD NativeThread)
453	{
454	/*
455	* Simple tree lookup.
456	*/
457	RT_THREAD_LOCK_TMP(Tmp);
458	RT_THREAD_LOCK_RD(Tmp);
459	PRTTHREADINT pThread = (PRTTHREADINT)RTAvlPVGet(&g_ThreadTree, (void *)NativeThread);
460	RT_THREAD_UNLOCK_RD(Tmp);
461	return pThread;
462	}
463
464
465	/**
466	* Gets the per thread data structure for a thread handle.
467	*
468	* @returns Pointer to the per thread data structure for Thread.
469	* The caller must release the thread using rtThreadRelease().
470	* @returns NULL if Thread was not found.
471	* @param Thread Thread id which structure is to be returned.
472	*/
473	PRTTHREADINT rtThreadGet(RTTHREAD Thread)
474	{
475	if ( Thread != NIL_RTTHREAD
476	&& VALID_PTR(Thread))
477	{
478	PRTTHREADINT pThread = (PRTTHREADINT)Thread;
479	if ( pThread->u32Magic == RTTHREADINT_MAGIC
480	&& pThread->cRefs > 0)
481	{
482	ASMAtomicIncU32(&pThread->cRefs);
483	return pThread;
484	}
485	}
486
487	AssertMsgFailed(("Thread=%RTthrd\n", Thread));
488	return NULL;
489	}
490
491
492	/**
493	* Release a per thread data structure.
494	*
495	* @returns New reference count.
496	* @param pThread The thread structure to release.
497	*/
498	uint32_t rtThreadRelease(PRTTHREADINT pThread)
499	{
500	Assert(pThread);
501	uint32_t cRefs;
502	if (pThread->cRefs >= 1)
503	{
504	cRefs = ASMAtomicDecU32(&pThread->cRefs);
505	if (!cRefs)
506	rtThreadDestroy(pThread);
507	}
508	else
509	cRefs = 0;
510	return cRefs;
511	}
512
513
514	/**
515	* Destroys the per thread data.
516	*
517	* @param pThread The thread to destroy.
518	*/
519	static void rtThreadDestroy(PRTTHREADINT pThread)
520	{
521	/*
522	* Mark it dead and remove it from the tree.
523	*/
524	ASMAtomicXchgU32(&pThread->u32Magic, RTTHREADINT_MAGIC_DEAD);
525	rtThreadRemove(pThread);
526
527	/*
528	* Free resources.
529	*/
530	pThread->Core.Key = (void *)NIL_RTTHREAD;
531	pThread->enmType = RTTHREADTYPE_INVALID;
532	RTSemEventMultiDestroy(pThread->EventUser);
533	pThread->EventUser = NIL_RTSEMEVENTMULTI;
534	if (pThread->EventTerminated != NIL_RTSEMEVENTMULTI)
535	{
536	RTSemEventMultiDestroy(pThread->EventTerminated);
537	pThread->EventTerminated = NIL_RTSEMEVENTMULTI;
538	}
539	RTMemFree(pThread);
540	}
541
542
543	/**
544	* Terminates the thread.
545	* Called by the thread wrapper function when the thread terminates.
546	*
547	* @param pThread The thread structure.
548	* @param rc The thread result code.
549	*/
550	void rtThreadTerminate(PRTTHREADINT pThread, int rc)
551	{
552	Assert(pThread->cRefs >= 1);
553
554	#ifdef IPRT_WITH_GENERIC_TLS
555	/*
556	* Destroy TLS entries.
557	*/
558	rtThreadTlsDestruction(pThread);
559	#endif /* IPRT_WITH_GENERIC_TLS */
560
561	/*
562	* Set the rc, mark it terminated and signal anyone waiting.
563	*/
564	pThread->rc = rc;
565	ASMAtomicXchgSize(&pThread->enmState, RTTHREADSTATE_TERMINATED);
566	ASMAtomicOrU32(&pThread->fIntFlags, RTTHREADINT_FLAGS_TERMINATED);
567	if (pThread->EventTerminated != NIL_RTSEMEVENTMULTI)
568	RTSemEventMultiSignal(pThread->EventTerminated);
569
570	/*
571	* Remove the thread from the tree so that there will be no
572	* key clashes in the AVL tree and release our reference to ourself.
573	*/
574	rtThreadRemove(pThread);
575	rtThreadRelease(pThread);
576	}
577
578
579	/**
580	* The common thread main function.
581	* This is called by rtThreadNativeMain().
582	*
583	* @returns The status code of the thread.
584	* pThread is dereference by the thread before returning!
585	* @param pThread The thread structure.
586	* @param NativeThread The native thread id.
587	* @param pszThreadName The name of the thread (purely a dummy for backtrace).
588	*/
589	int rtThreadMain(PRTTHREADINT pThread, RTNATIVETHREAD NativeThread, const char *pszThreadName)
590	{
591	NOREF(pszThreadName);
592	rtThreadInsert(pThread, NativeThread);
593	Log(("rtThreadMain: Starting: pThread=%p NativeThread=%RTnthrd Name=%s pfnThread=%p pvUser=%p\n",
594	pThread, NativeThread, pThread->szName, pThread->pfnThread, pThread->pvUser));
595
596	/*
597	* Change the priority.
598	*/
599	int rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
600	#ifdef IN_RING3
601	AssertMsgRC(rc, ("Failed to set priority of thread %p (%RTnthrd / %s) to enmType=%d enmPriority=%d rc=%Vrc\n",
602	pThread, NativeThread, pThread->szName, pThread->enmType, g_enmProcessPriority, rc));
603	#else
604	AssertMsgRC(rc, ("Failed to set priority of thread %p (%RTnthrd / %s) to enmType=%d rc=%Vrc\n",
605	pThread, NativeThread, pThread->szName, pThread->enmType, rc));
606	#endif
607
608	/*
609	* Call thread function and terminate when it returns.
610	*/
611	pThread->enmState = RTTHREADSTATE_RUNNING;
612	rc = pThread->pfnThread(pThread, pThread->pvUser);
613
614	Log(("rtThreadMain: Terminating: rc=%d pThread=%p NativeThread=%RTnthrd Name=%s pfnThread=%p pvUser=%p\n",
615	rc, pThread, NativeThread, pThread->szName, pThread->pfnThread, pThread->pvUser));
616	rtThreadTerminate(pThread, rc);
617	return rc;
618	}
619
620
621	/**
622	* Create a new thread.
623	*
624	* @returns iprt status code.
625	* @param pThread Where to store the thread handle to the new thread. (optional)
626	* @param pfnThread The thread function.
627	* @param pvUser User argument.
628	* @param cbStack The size of the stack for the new thread.
629	* Use 0 for the default stack size.
630	* @param enmType The thread type. Used for deciding scheduling attributes
631	* of the thread.
632	* @param fFlags Flags of the RTTHREADFLAGS type (ORed together).
633	* @param pszName Thread name.
634	*/
635	RTDECL(int) RTThreadCreate(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack,
636	RTTHREADTYPE enmType, unsigned fFlags, const char *pszName)
637	{
638	LogFlow(("RTThreadCreate: pThread=%p pfnThread=%p pvUser=%p cbStack=%#x enmType=%d fFlags=%#x pszName=%p:{%s}\n",
639	pThread, pfnThread, pvUser, cbStack, enmType, fFlags, pszName, pszName));
640
641	/*
642	* Validate input.
643	*/
644	if (!VALID_PTR(pThread) && pThread)
645	{
646	Assert(VALID_PTR(pThread));
647	return VERR_INVALID_PARAMETER;
648	}
649	if (!VALID_PTR(pfnThread))
650	{
651	Assert(VALID_PTR(pfnThread));
652	return VERR_INVALID_PARAMETER;
653	}
654	if (!pszName \|\| !*pszName \|\| strlen(pszName) >= RTTHREAD_NAME_LEN)
655	{
656	AssertMsgFailed(("pszName=%s (max len is %d because of logging)\n", pszName, RTTHREAD_NAME_LEN - 1));
657	return VERR_INVALID_PARAMETER;
658	}
659	if (fFlags & ~RTTHREADFLAGS_MASK)
660	{
661	AssertMsgFailed(("fFlags=%#x\n", fFlags));
662	return VERR_INVALID_PARAMETER;
663	}
664
665	/*
666	* Allocate thread argument.
667	*/
668	int rc;
669	PRTTHREADINT pThreadInt = rtThreadAlloc(enmType, fFlags, 0, pszName);
670	if (pThreadInt)
671	{
672	pThreadInt->pfnThread = pfnThread;
673	pThreadInt->pvUser = pvUser;
674	pThreadInt->cbStack = cbStack;
675
676	RTNATIVETHREAD NativeThread;
677	rc = rtThreadNativeCreate(pThreadInt, &NativeThread);
678	if (RT_SUCCESS(rc))
679	{
680	rtThreadInsert(pThreadInt, NativeThread);
681	rtThreadRelease(pThreadInt);
682	Log(("RTThreadCreate: Created thread %p (%p) %s\n", pThreadInt, NativeThread, pszName));
683	if (pThread)
684	*pThread = pThreadInt;
685	return VINF_SUCCESS;
686	}
687
688	pThreadInt->cRefs = 1;
689	rtThreadRelease(pThreadInt);
690	}
691	else
692	rc = VERR_NO_TMP_MEMORY;
693	LogFlow(("RTThreadCreate: Failed to create thread, rc=%Vrc\n", rc));
694	AssertReleaseRC(rc);
695	return rc;
696	}
697
698
699	/**
700	* Gets the native thread id of a IPRT thread.
701	*
702	* @returns The native thread id.
703	* @param Thread The IPRT thread.
704	*/
705	RTDECL(RTNATIVETHREAD) RTThreadGetNative(RTTHREAD Thread)
706	{
707	PRTTHREADINT pThread = rtThreadGet(Thread);
708	if (pThread)
709	{
710	RTNATIVETHREAD NativeThread = (RTNATIVETHREAD)pThread->Core.Key;
711	rtThreadRelease(pThread);
712	return NativeThread;
713	}
714	return NIL_RTNATIVETHREAD;
715	}
716
717
718	/**
719	* Gets the IPRT thread of a native thread.
720	*
721	* @returns The IPRT thread handle
722	* @returns NIL_RTTHREAD if not a thread known to IPRT.
723	* @param NativeThread The native thread handle/id.
724	*/
725	RTDECL(RTTHREAD) RTThreadFromNative(RTNATIVETHREAD NativeThread)
726	{
727	PRTTHREADINT pThread = rtThreadGetByNative(NativeThread);
728	if (pThread)
729	return pThread;
730	return NIL_RTTHREAD;
731	}
732
733
734	/**
735	* Gets the name of the current thread thread.
736	*
737	* @returns Pointer to readonly name string.
738	* @returns NULL on failure.
739	*/
740	RTDECL(const char *) RTThreadSelfName(void)
741	{
742	RTTHREAD Thread = RTThreadSelf();
743	if (Thread != NIL_RTTHREAD)
744	{
745	PRTTHREADINT pThread = rtThreadGet(Thread);
746	if (pThread)
747	{
748	const char *szName = pThread->szName;
749	rtThreadRelease(pThread);
750	return szName;
751	}
752	}
753	return NULL;
754	}
755
756
757	/**
758	* Gets the name of a thread.
759	*
760	* @returns Pointer to readonly name string.
761	* @returns NULL on failure.
762	* @param Thread Thread handle of the thread to query the name of.
763	*/
764	RTDECL(const char *) RTThreadGetName(RTTHREAD Thread)
765	{
766	if (Thread == NIL_RTTHREAD)
767	return NULL;
768	PRTTHREADINT pThread = rtThreadGet(Thread);
769	if (pThread)
770	{
771	const char *szName = pThread->szName;
772	rtThreadRelease(pThread);
773	return szName;
774	}
775	return NULL;
776	}
777
778
779	/**
780	* Sets the name of a thread.
781	*
782	* @returns iprt status code.
783	* @param Thread Thread handle of the thread to query the name of.
784	* @param pszName The thread name.
785	*/
786	RTDECL(int) RTThreadSetName(RTTHREAD Thread, const char *pszName)
787	{
788	/*
789	* Validate input.
790	*/
791	size_t cchName = strlen(pszName);
792	if (cchName >= RTTHREAD_NAME_LEN)
793	{
794	AssertMsgFailed(("pszName=%s is too long, max is %d\n", pszName, RTTHREAD_NAME_LEN - 1));
795	return VERR_INVALID_PARAMETER;
796	}
797	PRTTHREADINT pThread = rtThreadGet(Thread);
798	if (!pThread)
799	return VERR_INVALID_HANDLE;
800
801	/*
802	* Update the name.
803	*/
804	pThread->szName[cchName] = '\0'; /* paranoia */
805	memcpy(pThread->szName, pszName, cchName);
806	rtThreadRelease(pThread);
807	return VINF_SUCCESS;
808	}
809
810
811	/**
812	* Signal the user event.
813	*
814	* @returns iprt status code.
815	*/
816	RTDECL(int) RTThreadUserSignal(RTTHREAD Thread)
817	{
818	int rc;
819	PRTTHREADINT pThread = rtThreadGet(Thread);
820	if (pThread)
821	{
822	rc = RTSemEventMultiSignal(pThread->EventUser);
823	rtThreadRelease(pThread);
824	}
825	else
826	rc = VERR_INVALID_HANDLE;
827	return rc;
828	}
829
830
831	/**
832	* Wait for the user event, resume on interruption.
833	*
834	* @returns iprt status code.
835	* @param Thread The thread to wait for.
836	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
837	* an indefinite wait.
838	*/
839	RTDECL(int) RTThreadUserWait(RTTHREAD Thread, unsigned cMillies)
840	{
841	int rc;
842	PRTTHREADINT pThread = rtThreadGet(Thread);
843	if (pThread)
844	{
845	rc = RTSemEventMultiWait(pThread->EventUser, cMillies);
846	rtThreadRelease(pThread);
847	}
848	else
849	rc = VERR_INVALID_HANDLE;
850	return rc;
851	}
852
853
854	/**
855	* Wait for the user event, return on interruption.
856	*
857	* @returns iprt status code.
858	* @param Thread The thread to wait for.
859	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
860	* an indefinite wait.
861	*/
862	RTDECL(int) RTThreadUserWaitNoResume(RTTHREAD Thread, unsigned cMillies)
863	{
864	int rc;
865	PRTTHREADINT pThread = rtThreadGet(Thread);
866	if (pThread)
867	{
868	rc = RTSemEventMultiWaitNoResume(pThread->EventUser, cMillies);
869	rtThreadRelease(pThread);
870	}
871	else
872	rc = VERR_INVALID_HANDLE;
873	return rc;
874	}
875
876
877	/**
878	* Reset the user event.
879	*
880	* @returns iprt status code.
881	* @param Thread The thread to reset.
882	*/
883	RTDECL(int) RTThreadUserReset(RTTHREAD Thread)
884	{
885	int rc;
886	PRTTHREADINT pThread = rtThreadGet(Thread);
887	if (pThread)
888	{
889	rc = RTSemEventMultiReset(pThread->EventUser);
890	rtThreadRelease(pThread);
891	}
892	else
893	rc = VERR_INVALID_HANDLE;
894	return rc;
895	}
896
897
898	/**
899	* Wait for the thread to terminate.
900	*
901	* @returns iprt status code.
902	* @param Thread The thread to wait for.
903	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
904	* an indefinite wait.
905	* @param prc Where to store the return code of the thread. Optional.
906	* @param fAutoResume Whether or not to resume the wait on VERR_INTERRUPTED.
907	*/
908	static int rtThreadWait(RTTHREAD Thread, unsigned cMillies, int *prc, bool fAutoResume)
909	{
910	int rc = VERR_INVALID_HANDLE;
911	if (Thread != NIL_RTTHREAD)
912	{
913	PRTTHREADINT pThread = rtThreadGet(Thread);
914	if (pThread)
915	{
916	if (pThread->fFlags & RTTHREADFLAGS_WAITABLE)
917	{
918	if (fAutoResume)
919	rc = RTSemEventMultiWait(pThread->EventTerminated, cMillies);
920	else
921	rc = RTSemEventMultiWaitNoResume(pThread->EventTerminated, cMillies);
922	if (RT_SUCCESS(rc))
923	{
924	if (prc)
925	*prc = pThread->rc;
926
927	/*
928	* If the thread is marked as waitable, we'll do one additional
929	* release in order to free up the thread structure (see how we
930	* init cRef in rtThreadAlloc()).
931	*/
932	if (ASMAtomicBitTestAndClear(&pThread->fFlags, RTTHREADFLAGS_WAITABLE_BIT))
933	rtThreadRelease(pThread);
934	}
935	}
936	else
937	{
938	rc = VERR_THREAD_NOT_WAITABLE;
939	AssertRC(rc);
940	}
941	rtThreadRelease(pThread);
942	}
943	}
944	return rc;
945	}
946
947
948	/**
949	* Wait for the thread to terminate, resume on interruption.
950	*
951	* @returns iprt status code.
952	* Will not return VERR_INTERRUPTED.
953	* @param Thread The thread to wait for.
954	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
955	* an indefinite wait.
956	* @param prc Where to store the return code of the thread. Optional.
957	*/
958	RTDECL(int) RTThreadWait(RTTHREAD Thread, unsigned cMillies, int *prc)
959	{
960	int rc = rtThreadWait(Thread, cMillies, prc, true);
961	Assert(rc != VERR_INTERRUPTED);
962	return rc;
963	}
964
965
966	/**
967	* Wait for the thread to terminate, return on interruption.
968	*
969	* @returns iprt status code.
970	* @param Thread The thread to wait for.
971	* @param cMillies The number of milliseconds to wait. Use RT_INDEFINITE_WAIT for
972	* an indefinite wait.
973	* @param prc Where to store the return code of the thread. Optional.
974	*/
975	RTDECL(int) RTThreadWaitNoResume(RTTHREAD Thread, unsigned cMillies, int *prc)
976	{
977	return rtThreadWait(Thread, cMillies, prc, false);
978	}
979
980
981	/**
982	* Changes the type of the specified thread.
983	*
984	* @returns iprt status code.
985	* @param Thread The thread which type should be changed.
986	* @param enmType The new thread type.
987	*/
988	RTDECL(int) RTThreadSetType(RTTHREAD Thread, RTTHREADTYPE enmType)
989	{
990	/*
991	* Validate input.
992	*/
993	int rc;
994	if ( enmType > RTTHREADTYPE_INVALID
995	&& enmType < RTTHREADTYPE_END)
996	{
997	PRTTHREADINT pThread = rtThreadGet(Thread);
998	if (pThread)
999	{
1000	if (rtThreadIsAlive(pThread))
1001	{
1002	/*
1003	* Do the job.
1004	*/
1005	RT_THREAD_LOCK_TMP(Tmp);
1006	RT_THREAD_LOCK_RW(Tmp);
1007	rc = rtThreadNativeSetPriority(pThread, enmType);
1008	if (RT_SUCCESS(rc))
1009	ASMAtomicXchgSize(&pThread->enmType, enmType);
1010	RT_THREAD_UNLOCK_RW(Tmp);
1011	if (RT_FAILURE(rc))
1012	Log(("RTThreadSetType: failed on thread %p (%s), rc=%Vrc!!!\n", Thread, pThread->szName, rc));
1013	}
1014	else
1015	rc = VERR_THREAD_IS_DEAD;
1016	rtThreadRelease(pThread);
1017	}
1018	else
1019	rc = VERR_INVALID_HANDLE;
1020	}
1021	else
1022	{
1023	AssertMsgFailed(("enmType=%d\n", enmType));
1024	rc = VERR_INVALID_PARAMETER;
1025	}
1026	return rc;
1027	}
1028
1029
1030	/**
1031	* Gets the type of the specified thread.
1032	*
1033	* @returns The thread type.
1034	* @returns RTTHREADTYPE_INVALID if the thread handle is invalid.
1035	* @param Thread The thread in question.
1036	*/
1037	RTDECL(RTTHREADTYPE) RTThreadGetType(RTTHREAD Thread)
1038	{
1039	RTTHREADTYPE enmType = RTTHREADTYPE_INVALID;
1040	PRTTHREADINT pThread = rtThreadGet(Thread);
1041	if (pThread)
1042	{
1043	enmType = pThread->enmType;
1044	rtThreadRelease(pThread);
1045	}
1046	return enmType;
1047	}
1048
1049
1050	#ifdef IN_RING3
1051
1052	/**
1053	* Recalculates scheduling attributes for the the default process
1054	* priority using the specified priority type for the calling thread.
1055	*
1056	* The scheduling attributes are targeted at threads and they are protected
1057	* by the thread read-write semaphore, that's why RTProc is forwarding the
1058	* operation to RTThread.
1059	*
1060	* @returns iprt status code.
1061	*/
1062	int rtThreadDoCalcDefaultPriority(RTTHREADTYPE enmType)
1063	{
1064	RT_THREAD_LOCK_TMP(Tmp);
1065	RT_THREAD_LOCK_RW(Tmp);
1066	int rc = rtSchedNativeCalcDefaultPriority(enmType);
1067	RT_THREAD_UNLOCK_RW(Tmp);
1068	return rc;
1069	}
1070
1071
1072	/**
1073	* Thread enumerator - sets the priority of one thread.
1074	*
1075	* @returns 0 to continue.
1076	* @returns !0 to stop. In our case a VERR_ code.
1077	* @param pNode The thread node.
1078	* @param pvUser The new priority.
1079	*/
1080	static DECLCALLBACK(int) rtThreadSetPriorityOne(PAVLPVNODECORE pNode, void *pvUser)
1081	{
1082	PRTTHREADINT pThread = (PRTTHREADINT)pNode;
1083	if (!rtThreadIsAlive(pThread))
1084	return VINF_SUCCESS;
1085	int rc = rtThreadNativeSetPriority(pThread, pThread->enmType);
1086	if (RT_SUCCESS(rc)) /* hide any warnings */
1087	return VINF_SUCCESS;
1088	return rc;
1089	}
1090
1091
1092	/**
1093	* Attempts to alter the priority of the current process.
1094	*
1095	* The scheduling attributes are targeted at threads and they are protected
1096	* by the thread read-write semaphore, that's why RTProc is forwarding the
1097	* operation to RTThread. This operation also involves updating all thread
1098	* which is much faster done from RTThread.
1099	*
1100	* @returns iprt status code.
1101	* @param enmPriority The new priority.
1102	*/
1103	int rtThreadDoSetProcPriority(RTPROCPRIORITY enmPriority)
1104	{
1105	LogFlow(("rtThreadDoSetProcPriority: enmPriority=%d\n", enmPriority));
1106
1107	/*
1108	* First validate that we're allowed by the OS to use all the
1109	* scheduling attributes defined by the specified process priority.
1110	*/
1111	RT_THREAD_LOCK_TMP(Tmp);
1112	RT_THREAD_LOCK_RW(Tmp);
1113	int rc = rtProcNativeSetPriority(enmPriority);
1114	if (RT_SUCCESS(rc))
1115	{
1116	/*
1117	* Update the priority of existing thread.
1118	*/
1119	rc = RTAvlPVDoWithAll(&g_ThreadTree, true, rtThreadSetPriorityOne, NULL);
1120	if (RT_SUCCESS(rc))
1121	ASMAtomicXchgSize(&g_enmProcessPriority, enmPriority);
1122	else
1123	{
1124	/*
1125	* Failed, restore the priority.
1126	*/
1127	rtProcNativeSetPriority(g_enmProcessPriority);
1128	RTAvlPVDoWithAll(&g_ThreadTree, true, rtThreadSetPriorityOne, NULL);
1129	}
1130	}
1131	RT_THREAD_UNLOCK_RW(Tmp);
1132	LogFlow(("rtThreadDoSetProcPriority: returns %Vrc\n", rc));
1133	return rc;
1134	}
1135
1136
1137	/**
1138	* Bitch about a deadlock.
1139	*
1140	* @param pThread This thread.
1141	* @param pCur The thread we're deadlocking with.
1142	* @param enmState The sleep state.
1143	* @param u64Block The block data. A pointer or handle.
1144	* @param pszFile Where we are gonna block.
1145	* @param uLine Where we are gonna block.
1146	* @param uId Where we are gonna block.
1147	*/
1148	static void rtThreadDeadlock(PRTTHREADINT pThread, PRTTHREADINT pCur, RTTHREADSTATE enmState, uint64_t u64Block,
1149	const char *pszFile, unsigned uLine, RTUINTPTR uId)
1150	{
1151	AssertMsg1(pCur == pThread ? "!!Deadlock detected!!" : "!!Deadlock exists!!", uLine, pszFile, "");
1152
1153	/*
1154	* Print the threads and locks involved.
1155	*/
1156	PRTTHREADINT apSeenThreads[8] = {0,0,0,0,0,0,0,0};
1157	unsigned iSeenThread = 0;
1158	pCur = pThread;
1159	for (unsigned iEntry = 0; pCur && iEntry < 256; iEntry++)
1160	{
1161	/*
1162	* Print info on pCur. Determin next while doing so.
1163	*/
1164	AssertMsg2(" #%d: %RTthrd/%RTnthrd %s: %s(%u) %RTptr\n",
1165	iEntry, pCur, pCur->Core.Key, pCur->szName,
1166	pCur->pszBlockFile, pCur->uBlockLine, pCur->uBlockId);
1167	PRTTHREADINT pNext = NULL;
1168	switch (pCur->enmState)
1169	{
1170	case RTTHREADSTATE_CRITSECT:
1171	{
1172	PRTCRITSECT pCritSect = pCur->Block.pCritSect;
1173	if (pCur->enmState != RTTHREADSTATE_CRITSECT)
1174	{
1175	AssertMsg2("Impossible!!!\n");
1176	break;
1177	}
1178	if (VALID_PTR(pCritSect) && RTCritSectIsInitialized(pCritSect))
1179	{
1180	AssertMsg2(" Waiting on CRITSECT %p: Entered %s(%u) %RTptr\n",
1181	pCritSect, pCritSect->Strict.pszEnterFile,
1182	pCritSect->Strict.u32EnterLine, pCritSect->Strict.uEnterId);
1183	pNext = pCritSect->Strict.ThreadOwner;
1184	}
1185	else
1186	AssertMsg2(" Waiting on CRITSECT %p: invalid pointer or uninitialized critsect\n", pCritSect);
1187	break;
1188	}
1189
1190	default:
1191	AssertMsg2(" Impossible!!! enmState=%d\n", pCur->enmState);
1192	break;
1193	}
1194
1195	/*
1196	* Check for cycle.
1197	*/
1198	if (iEntry && pCur == pThread)
1199	break;
1200	for (unsigned i = 0; i < ELEMENTS(apSeenThreads); i++)
1201	if (apSeenThreads[i] == pCur)
1202	{
1203	AssertMsg2(" Cycle!\n");
1204	pNext = NULL;
1205	break;
1206	}
1207
1208	/*
1209	* Advance to the next thread.
1210	*/
1211	iSeenThread = (iSeenThread + 1) % ELEMENTS(apSeenThreads);
1212	apSeenThreads[iSeenThread] = pCur;
1213	pCur = pNext;
1214	}
1215	AssertBreakpoint();
1216	}
1217
1218
1219	/**
1220	* Change the thread state to blocking and do deadlock detection.
1221	*
1222	* This is a RT_STRICT method for debugging locks and detecting deadlocks.
1223	*
1224	* @param pThread This thread.
1225	* @param enmState The sleep state.
1226	* @param u64Block The block data. A pointer or handle.
1227	* @param pszFile Where we are blocking.
1228	* @param uLine Where we are blocking.
1229	* @param uId Where we are blocking.
1230	*/
1231	void rtThreadBlocking(PRTTHREADINT pThread, RTTHREADSTATE enmState, uint64_t u64Block,
1232	const char *pszFile, unsigned uLine, RTUINTPTR uId)
1233	{
1234	Assert(RTTHREAD_IS_SLEEPING(enmState));
1235	if (pThread && pThread->enmState == RTTHREADSTATE_RUNNING)
1236	{
1237	/** @todo This has to be serialized! The deadlock detection isn't 100% safe!!! */
1238	pThread->Block.u64 = u64Block;
1239	pThread->pszBlockFile = pszFile;
1240	pThread->uBlockLine = uLine;
1241	pThread->uBlockId = uId;
1242	ASMAtomicXchgSize(&pThread->enmState, enmState);
1243
1244	/*
1245	* Do deadlock detection.
1246	*
1247	* Since we're missing proper serialization, we don't declare it a
1248	* deadlock until we've got three runs with the same list length.
1249	* While this isn't perfect, it should avoid out the most obvious
1250	* races on SMP boxes.
1251	*/
1252	PRTTHREADINT pCur;
1253	unsigned cPrevLength = ~0U;
1254	unsigned cEqualRuns = 0;
1255	unsigned iParanoia = 256;
1256	do
1257	{
1258	unsigned cLength = 0;
1259	pCur = pThread;
1260	for (;;)
1261	{
1262	/*
1263	* Get the next thread.
1264	*/
1265	for (;;)
1266	{
1267	switch (pCur->enmState)
1268	{
1269	case RTTHREADSTATE_CRITSECT:
1270	{
1271	PRTCRITSECT pCritSect = pCur->Block.pCritSect;
1272	if (pCur->enmState != RTTHREADSTATE_CRITSECT)
1273	continue;
1274	pCur = pCritSect->Strict.ThreadOwner;
1275	break;
1276	}
1277
1278	default:
1279	pCur = NULL;
1280	break;
1281	}
1282	break;
1283	}
1284	if (!pCur)
1285	return;
1286
1287	/*
1288	* If we've got back to the blocking thread id we've got a deadlock.
1289	* If we've got a chain of more than 256 items, there is some kind of cycle
1290	* in the list, which means that there is already a deadlock somewhere.
1291	*/
1292	if (pCur == pThread \|\| cLength >= 256)
1293	break;
1294	cLength++;
1295	}
1296
1297	/* compare with previous list run. */
1298	if (cLength != cPrevLength)
1299	{
1300	cPrevLength = cLength;
1301	cEqualRuns = 0;
1302	}
1303	else
1304	cEqualRuns++;
1305	} while (cEqualRuns < 3 && --iParanoia > 0);
1306
1307	/*
1308	* Ok, if we ever get here, it's most likely a genuine deadlock.
1309	*/
1310	rtThreadDeadlock(pThread, pCur, enmState, u64Block, pszFile, uLine, uId);
1311	}
1312	}
1313
1314
1315	/**
1316	* Unblocks a thread.
1317	*
1318	* This function is paired with rtThreadBlocking.
1319	*
1320	* @param pThread The current thread.
1321	* @param enmCurState The current state, used to check for nested blocking.
1322	* The new state will be running.
1323	*/
1324	void rtThreadUnblocked(PRTTHREADINT pThread, RTTHREADSTATE enmCurState)
1325	{
1326	if (pThread && pThread->enmState == enmCurState)
1327	ASMAtomicXchgSize(&pThread->enmState, RTTHREADSTATE_RUNNING);
1328	}
1329
1330	#endif /* IN_RING3 */
1331
1332
1333	#ifdef IPRT_WITH_GENERIC_TLS
1334
1335	/**
1336	* Thread enumerator - clears a TLS entry.
1337	*
1338	* @returns 0.
1339	* @param pNode The thread node.
1340	* @param pvUser The TLS index.
1341	*/
1342	static DECLCALLBACK(int) rtThreadClearTlsEntryCallback(PAVLPVNODECORE pNode, void *pvUser)
1343	{
1344	PRTTHREADINT pThread = (PRTTHREADINT)pNode;
1345	RTTLS iTls = (RTTLS)(uintptr_t)pvUser;
1346	ASMAtomicWritePtr(&pThread->apvTlsEntries[iTls], NULL);
1347	return 0;
1348	}
1349
1350
1351	/**
1352	* Helper for the generic TLS implementation that clears a given TLS
1353	* entry on all threads.
1354	*
1355	* @param iTls The TLS entry. (valid)
1356	*/
1357	void rtThreadClearTlsEntry(RTTLS iTls)
1358	{
1359	RT_THREAD_LOCK_TMP(Tmp);
1360	RT_THREAD_LOCK_RD(Tmp);
1361	RTAvlPVDoWithAll(&g_ThreadTree, true /* fFromLeft/, rtThreadClearTlsEntryCallback, (void )(uintptr_t)iTls);
1362	RT_THREAD_UNLOCK_RD(Tmp);
1363	}
1364
1365	#endif /* IPRT_WITH_GENERIC_TLS */
1366

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

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

Download in other formats: