PDMAllCritSect.cpp@ 32035

Last change on this file since 32035 was 31393, checked in by vboxsync, 14 years ago
build fix
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 24.8 KB

Line
1	/* $Id: PDMAllCritSect.cpp 31393 2010-08-05 11:44:39Z vboxsync $ */
2	/** @file
3	* PDM - Critical Sections, All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 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
18
19	/*******************************************************************************
20	* Header Files *
21	*******************************************************************************/
22	#define LOG_GROUP LOG_GROUP_PDM//_CRITSECT
23	#include "../PDMInternal.h"
24	#include <VBox/pdmcritsect.h>
25	#include <VBox/mm.h>
26	#include <VBox/vmm.h>
27	#include <VBox/vm.h>
28	#include <VBox/err.h>
29	#include <VBox/hwaccm.h>
30
31	#include <VBox/log.h>
32	#include <iprt/asm.h>
33	#include <iprt/asm-amd64-x86.h>
34	#include <iprt/assert.h>
35	#ifdef IN_RING3
36	# include <iprt/lockvalidator.h>
37	# include <iprt/semaphore.h>
38	#endif
39	#if defined(IN_RING3) \|\| defined(IN_RING0)
40	# include <iprt/thread.h>
41	#endif
42
43
44	/*******************************************************************************
45	* Defined Constants And Macros *
46	*******************************************************************************/
47	/** The number loops to spin for in ring-3. */
48	#define PDMCRITSECT_SPIN_COUNT_R3 20
49	/** The number loops to spin for in ring-0. */
50	#define PDMCRITSECT_SPIN_COUNT_R0 256
51	/** The number loops to spin for in the raw-mode context. */
52	#define PDMCRITSECT_SPIN_COUNT_RC 256
53
54
55	/* Undefine the automatic VBOX_STRICT API mappings. */
56	#undef PDMCritSectEnter
57	#undef PDMCritSectTryEnter
58
59
60	/**
61	* Gets the ring-3 native thread handle of the calling thread.
62	*
63	* @returns native thread handle (ring-3).
64	* @param pCritSect The critical section. This is used in R0 and RC.
65	*/
66	DECL_FORCE_INLINE(RTNATIVETHREAD) pdmCritSectGetNativeSelf(PCPDMCRITSECT pCritSect)
67	{
68	#ifdef IN_RING3
69	NOREF(pCritSect);
70	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
71	#else
72	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, ("%RX32\n", pCritSect->s.Core.u32Magic),
73	NIL_RTNATIVETHREAD);
74	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
75	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
76	RTNATIVETHREAD hNativeSelf = pVCpu->hNativeThread; Assert(hNativeSelf != NIL_RTNATIVETHREAD);
77	#endif
78	return hNativeSelf;
79	}
80
81
82	/**
83	* Tail code called when we've won the battle for the lock.
84	*
85	* @returns VINF_SUCCESS.
86	*
87	* @param pCritSect The critical section.
88	* @param hNativeSelf The native handle of this thread.
89	*/
90	DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
91	{
92	AssertMsg(pCritSect->s.Core.NativeThreadOwner == NIL_RTNATIVETHREAD, ("NativeThreadOwner=%p\n", pCritSect->s.Core.NativeThreadOwner));
93	Assert(!(pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK));
94
95	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 1);
96	Assert(pCritSect->s.Core.cNestings == 1);
97	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, hNativeSelf);
98
99	# ifdef PDMCRITSECT_STRICT
100	RTLockValidatorRecExclSetOwner(pCritSect->s.Core.pValidatorRec, NIL_RTTHREAD, pSrcPos, true);
101	# endif
102
103	STAM_PROFILE_ADV_START(&pCritSect->s.StatLocked, l);
104	return VINF_SUCCESS;
105	}
106
107
108	#if defined(IN_RING3) \|\| defined(IN_RING0)
109	/**
110	* Deals with the contended case in ring-3 and ring-0.
111	*
112	* @returns VINF_SUCCESS or VERR_SEM_DESTROYED.
113	* @param pCritSect The critsect.
114	* @param hNativeSelf The native thread handle.
115	*/
116	static int pdmR3R0CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
117	{
118	/*
119	* Start waiting.
120	*/
121	if (ASMAtomicIncS32(&pCritSect->s.Core.cLockers) == 0)
122	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
123	# ifdef IN_RING3
124	STAM_COUNTER_INC(&pCritSect->s.StatContentionR3);
125	# else
126	STAM_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
127	# endif
128
129	/*
130	* The wait loop.
131	*/
132	PSUPDRVSESSION pSession = pCritSect->s.CTX_SUFF(pVM)->pSession;
133	SUPSEMEVENT hEvent = (SUPSEMEVENT)pCritSect->s.Core.EventSem;
134	# ifdef IN_RING3
135	# ifdef PDMCRITSECT_STRICT
136	RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
137	int rc2 = RTLockValidatorRecExclCheckOrder(pCritSect->s.Core.pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
138	if (RT_FAILURE(rc2))
139	return rc2;
140	# else
141	RTTHREAD hThreadSelf = RTThreadSelf();
142	# endif
143	# endif
144	for (;;)
145	{
146	# ifdef PDMCRITSECT_STRICT
147	int rc9 = RTLockValidatorRecExclCheckBlocking(pCritSect->s.Core.pValidatorRec, hThreadSelf, pSrcPos,
148	!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NO_NESTING),
149	RT_INDEFINITE_WAIT, RTTHREADSTATE_CRITSECT, true);
150	if (RT_FAILURE(rc9))
151	return rc9;
152	# elif defined(IN_RING3)
153	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_CRITSECT, true);
154	# endif
155	int rc = SUPSemEventWaitNoResume(pSession, hEvent, RT_INDEFINITE_WAIT);
156	# ifdef IN_RING3
157	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_CRITSECT);
158	# endif
159
160	if (RT_UNLIKELY(pCritSect->s.Core.u32Magic != RTCRITSECT_MAGIC))
161	return VERR_SEM_DESTROYED;
162	if (rc == VINF_SUCCESS)
163	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
164	AssertMsg(rc == VERR_INTERRUPTED, ("rc=%Rrc\n", rc));
165	}
166	/* won't get here */
167	}
168	#endif /* IN_RING3 \|\| IN_RING0 */
169
170
171	/**
172	* Common worker for the debug and normal APIs.
173	*
174	* @returns VINF_SUCCESS if entered successfully.
175	* @returns rcBusy when encountering a busy critical section in GC/R0.
176	* @returns VERR_SEM_DESTROYED if the critical section is dead.
177	*
178	* @param pCritSect The PDM critical section to enter.
179	* @param rcBusy The status code to return when we're in GC or R0
180	* and the section is busy.
181	*/
182	DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PCRTLOCKVALSRCPOS pSrcPos)
183	{
184	Assert(pCritSect->s.Core.cNestings < 8); /* useful to catch incorrect locking */
185	Assert(pCritSect->s.Core.cNestings >= 0);
186
187	/*
188	* If the critical section has already been destroyed, then inform the caller.
189	*/
190	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC,
191	("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic),
192	VERR_SEM_DESTROYED);
193
194	/*
195	* See if we're lucky.
196	*/
197	RTNATIVETHREAD hNativeSelf = pdmCritSectGetNativeSelf(pCritSect);
198	/* Not owned ... */
199	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
200	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
201
202	/* ... or nested. */
203	if (pCritSect->s.Core.NativeThreadOwner == hNativeSelf)
204	{
205	ASMAtomicIncS32(&pCritSect->s.Core.cLockers);
206	ASMAtomicIncS32(&pCritSect->s.Core.cNestings);
207	Assert(pCritSect->s.Core.cNestings > 1);
208	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
209	return VINF_SUCCESS;
210	}
211
212	/*
213	* Spin for a bit without incrementing the counter.
214	*/
215	/** @todo Move this to cfgm variables since it doesn't make sense to spin on UNI
216	* cpu systems. */
217	int32_t cSpinsLeft = CTX_SUFF(PDMCRITSECT_SPIN_COUNT_);
218	while (cSpinsLeft-- > 0)
219	{
220	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
221	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
222	ASMNopPause();
223	/** @todo Should use monitor/mwait on e.g. &cLockers here, possibly with a
224	cli'ed pendingpreemption check up front using sti w/ instruction fusing
225	for avoiding races. Hmm ... This is assuming the other party is actually
226	executing code on another CPU ... which we could keep track of if we
227	wanted. */
228	}
229
230	#ifdef IN_RING3
231	/*
232	* Take the slow path.
233	*/
234	return pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
235
236	#elif defined(IN_RING0)
237	/** @todo If preemption is disabled it means we're in VT-x/AMD-V context
238	* and would be better off switching out of that while waiting for
239	* the lock. Several of the locks jumps back to ring-3 just to
240	* get the lock, the ring-3 code will then call the kernel to do
241	* the lock wait and when the call return it will call ring-0
242	* again and resume via in setjmp style. Not very efficient. */
243	# if 0
244	if (ASMIntAreEnabled()) /** @todo this can be handled as well by changing
245	* callers not prepared for longjmp/blocking to
246	* use PDMCritSectTryEnter. */
247	{
248	/*
249	* Leave HWACCM context while waiting if necessary.
250	*/
251	int rc;
252	if (RTThreadPreemptIsEnabled(NIL_RTTHREAD))
253	{
254	STAM_REL_COUNTER_ADD(&pCritSect->s.StatContentionRZLock, 1000000);
255	rc = pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
256	}
257	else
258	{
259	STAM_REL_COUNTER_ADD(&pCritSect->s.StatContentionRZLock, 1000000000);
260	PVM pVM = pCritSect->s.CTX_SUFF(pVM);
261	PVMCPU pVCpu = VMMGetCpu(pVM);
262	HWACCMR0Leave(pVM, pVCpu);
263	RTThreadPreemptRestore(NIL_RTTHREAD, ????);
264
265	rc = pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
266
267	RTThreadPreemptDisable(NIL_RTTHREAD, ????);
268	HWACCMR0Enter(pVM, pVCpu);
269	}
270	return rc;
271	}
272	# else
273	/*
274	* We preemption hasn't been disabled, we can block here in ring-0.
275	*/
276	if ( RTThreadPreemptIsEnabled(NIL_RTTHREAD)
277	&& ASMIntAreEnabled())
278	return pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
279	# endif
280
281	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
282	LogFlow(("PDMCritSectEnter: locked => R3 (%Rrc)\n", rcBusy));
283	return rcBusy;
284
285	#else /* IN_RC */
286	/*
287	* Return busy.
288	*/
289	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
290	LogFlow(("PDMCritSectEnter: locked => R3 (%Rrc)\n", rcBusy));
291	return rcBusy;
292	#endif /* IN_RC */
293	}
294
295
296	/**
297	* Enters a PDM critical section.
298	*
299	* @returns VINF_SUCCESS if entered successfully.
300	* @returns rcBusy when encountering a busy critical section in GC/R0.
301	* @returns VERR_SEM_DESTROYED if the critical section is dead.
302	*
303	* @param pCritSect The PDM critical section to enter.
304	* @param rcBusy The status code to return when we're in GC or R0
305	* and the section is busy.
306	*/
307	VMMDECL(int) PDMCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy)
308	{
309	#ifndef PDMCRITSECT_STRICT
310	return pdmCritSectEnter(pCritSect, rcBusy, NULL);
311	#else
312	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
313	return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
314	#endif
315	}
316
317
318	/**
319	* Enters a PDM critical section, with location information for debugging.
320	*
321	* @returns VINF_SUCCESS if entered successfully.
322	* @returns rcBusy when encountering a busy critical section in GC/R0.
323	* @returns VERR_SEM_DESTROYED if the critical section is dead.
324	*
325	* @param pCritSect The PDM critical section to enter.
326	* @param rcBusy The status code to return when we're in GC or R0
327	* and the section is busy.
328	* @param uId Some kind of locking location ID. Typically a
329	* return address up the stack. Optional (0).
330	* @param pszFile The file where the lock is being acquired from.
331	* Optional.
332	* @param iLine The line number in that file. Optional (0).
333	* @param pszFunction The functionn where the lock is being acquired
334	* from. Optional.
335	*/
336	VMMDECL(int) PDMCritSectEnterDebug(PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
337	{
338	#ifdef PDMCRITSECT_STRICT
339	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
340	return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
341	#else
342	return pdmCritSectEnter(pCritSect, rcBusy, NULL);
343	#endif
344	}
345
346
347	/**
348	* Common worker for the debug and normal APIs.
349	*
350	* @retval VINF_SUCCESS on success.
351	* @retval VERR_SEM_BUSY if the critsect was owned.
352	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
353	* @retval VERR_SEM_DESTROYED if RTCritSectDelete was called while waiting.
354	*
355	* @param pCritSect The critical section.
356	*/
357	static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
358	{
359	/*
360	* If the critical section has already been destroyed, then inform the caller.
361	*/
362	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC,
363	("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic),
364	VERR_SEM_DESTROYED);
365
366	/*
367	* See if we're lucky.
368	*/
369	RTNATIVETHREAD hNativeSelf = pdmCritSectGetNativeSelf(pCritSect);
370	/* Not owned ... */
371	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
372	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
373
374	/* ... or nested. */
375	if (pCritSect->s.Core.NativeThreadOwner == hNativeSelf)
376	{
377	ASMAtomicIncS32(&pCritSect->s.Core.cLockers);
378	ASMAtomicIncS32(&pCritSect->s.Core.cNestings);
379	Assert(pCritSect->s.Core.cNestings > 1);
380	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
381	return VINF_SUCCESS;
382	}
383
384	/* no spinning */
385
386	/*
387	* Return busy.
388	*/
389	#ifdef IN_RING3
390	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionR3);
391	#else
392	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
393	#endif
394	LogFlow(("PDMCritSectTryEnter: locked\n"));
395	return VERR_SEM_BUSY;
396	}
397
398
399	/**
400	* Try enter a critical section.
401	*
402	* @retval VINF_SUCCESS on success.
403	* @retval VERR_SEM_BUSY if the critsect was owned.
404	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
405	* @retval VERR_SEM_DESTROYED if RTCritSectDelete was called while waiting.
406	*
407	* @param pCritSect The critical section.
408	*/
409	VMMDECL(int) PDMCritSectTryEnter(PPDMCRITSECT pCritSect)
410	{
411	#ifndef PDMCRITSECT_STRICT
412	return pdmCritSectTryEnter(pCritSect, NULL);
413	#else
414	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
415	return pdmCritSectTryEnter(pCritSect, &SrcPos);
416	#endif
417	}
418
419
420	/**
421	* Try enter a critical section, with location information for debugging.
422	*
423	* @retval VINF_SUCCESS on success.
424	* @retval VERR_SEM_BUSY if the critsect was owned.
425	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
426	* @retval VERR_SEM_DESTROYED if RTCritSectDelete was called while waiting.
427	*
428	* @param pCritSect The critical section.
429	* @param uId Some kind of locking location ID. Typically a
430	* return address up the stack. Optional (0).
431	* @param pszFile The file where the lock is being acquired from.
432	* Optional.
433	* @param iLine The line number in that file. Optional (0).
434	* @param pszFunction The functionn where the lock is being acquired
435	* from. Optional.
436	*/
437	VMMDECL(int) PDMCritSectTryEnterDebug(PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
438	{
439	#ifdef PDMCRITSECT_STRICT
440	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
441	return pdmCritSectTryEnter(pCritSect, &SrcPos);
442	#else
443	return pdmCritSectTryEnter(pCritSect, NULL);
444	#endif
445	}
446
447
448	#ifdef IN_RING3
449	/**
450	* Enters a PDM critical section.
451	*
452	* @returns VINF_SUCCESS if entered successfully.
453	* @returns rcBusy when encountering a busy critical section in GC/R0.
454	* @returns VERR_SEM_DESTROYED if the critical section is dead.
455	*
456	* @param pCritSect The PDM critical section to enter.
457	* @param fCallRing3 Whether this is a VMMRZCallRing3()request.
458	*/
459	VMMR3DECL(int) PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallRing3)
460	{
461	int rc = PDMCritSectEnter(pCritSect, VERR_INTERNAL_ERROR);
462	if ( rc == VINF_SUCCESS
463	&& fCallRing3
464	&& pCritSect->s.Core.pValidatorRec
465	&& pCritSect->s.Core.pValidatorRec->hThread != NIL_RTTHREAD)
466	RTLockValidatorRecExclReleaseOwnerUnchecked(pCritSect->s.Core.pValidatorRec);
467	return rc;
468	}
469	#endif /* IN_RING3 */
470
471
472	/**
473	* Leaves a critical section entered with PDMCritSectEnter().
474	*
475	* @param pCritSect The PDM critical section to leave.
476	*/
477	VMMDECL(void) PDMCritSectLeave(PPDMCRITSECT pCritSect)
478	{
479	AssertMsg(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, ("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic));
480	Assert(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC);
481	Assert(pCritSect->s.Core.NativeThreadOwner == pdmCritSectGetNativeSelf(pCritSect));
482	Assert(pCritSect->s.Core.cNestings >= 1);
483
484	/*
485	* Nested leave.
486	*/
487	if (pCritSect->s.Core.cNestings > 1)
488	{
489	ASMAtomicDecS32(&pCritSect->s.Core.cNestings);
490	Assert(pCritSect->s.Core.cNestings >= 1);
491	ASMAtomicDecS32(&pCritSect->s.Core.cLockers);
492	return;
493	}
494
495	#ifdef IN_RING0
496	# if 0 /** @todo Make SUPSemEventSignal interrupt safe (handle table++) and enable this for: defined(RT_OS_LINUX) \|\| defined(RT_OS_OS2) */
497	if (1) /* SUPSemEventSignal is safe */
498	# else
499	if (ASMIntAreEnabled())
500	# endif
501	#endif
502	#if defined(IN_RING3) \|\| defined(IN_RING0)
503	{
504	/*
505	* Leave for real.
506	*/
507	/* update members. */
508	# ifdef IN_RING3
509	RTSEMEVENT hEventToSignal = pCritSect->s.EventToSignal;
510	pCritSect->s.EventToSignal = NIL_RTSEMEVENT;
511	# if defined(PDMCRITSECT_STRICT)
512	if (pCritSect->s.Core.pValidatorRec->hThread != NIL_RTTHREAD)
513	RTLockValidatorRecExclReleaseOwnerUnchecked(pCritSect->s.Core.pValidatorRec);
514	# endif
515	Assert(!pCritSect->s.Core.pValidatorRec \|\| pCritSect->s.Core.pValidatorRec->hThread == NIL_RTTHREAD);
516	# endif
517	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
518	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, NIL_RTNATIVETHREAD);
519	ASMAtomicDecS32(&pCritSect->s.Core.cNestings);
520	Assert(pCritSect->s.Core.cNestings == 0);
521
522	/* stop and decrement lockers. */
523	STAM_PROFILE_ADV_STOP(&pCritSect->s.StatLocked, l);
524	ASMCompilerBarrier();
525	if (ASMAtomicDecS32(&pCritSect->s.Core.cLockers) >= 0)
526	{
527	/* Someone is waiting, wake up one of them. */
528	SUPSEMEVENT hEvent = (SUPSEMEVENT)pCritSect->s.Core.EventSem;
529	PSUPDRVSESSION pSession = pCritSect->s.CTX_SUFF(pVM)->pSession;
530	int rc = SUPSemEventSignal(pSession, hEvent);
531	AssertRC(rc);
532	}
533
534	# ifdef IN_RING3
535	/* Signal exit event. */
536	if (hEventToSignal != NIL_RTSEMEVENT)
537	{
538	LogBird(("Signalling %#x\n", hEventToSignal));
539	int rc = RTSemEventSignal(hEventToSignal);
540	AssertRC(rc);
541	}
542	# endif
543
544	# if defined(DEBUG_bird) && defined(IN_RING0)
545	VMMTrashVolatileXMMRegs();
546	# endif
547	}
548	#endif /* IN_RING3 \|\| IN_RING0 */
549	#ifdef IN_RING0
550	else
551	#endif
552	#if defined(IN_RING0) \|\| defined(IN_RC)
553	{
554	/*
555	* Try leave it.
556	*/
557	if (pCritSect->s.Core.cLockers == 0)
558	{
559	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 0);
560	RTNATIVETHREAD hNativeThread = pCritSect->s.Core.NativeThreadOwner;
561	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
562	STAM_PROFILE_ADV_STOP(&pCritSect->s.StatLocked, l);
563
564	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, NIL_RTNATIVETHREAD);
565	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, -1, 0))
566	return;
567
568	/* darn, someone raced in on us. */
569	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, hNativeThread);
570	STAM_PROFILE_ADV_START(&pCritSect->s.StatLocked, l);
571	Assert(pCritSect->s.Core.cNestings == 0);
572	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 1);
573	}
574	ASMAtomicOrU32(&pCritSect->s.Core.fFlags, PDMCRITSECT_FLAGS_PENDING_UNLOCK);
575
576	/*
577	* Queue the request.
578	*/
579	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
580	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
581	uint32_t i = pVCpu->pdm.s.cQueuedCritSectLeaves++;
582	LogFlow(("PDMCritSectLeave: [%d]=%p => R3\n", i, pCritSect));
583	AssertFatal(i < RT_ELEMENTS(pVCpu->pdm.s.apQueuedCritSectsLeaves));
584	pVCpu->pdm.s.apQueuedCritSectsLeaves[i] = MMHyperCCToR3(pVM, pCritSect);
585	VMCPU_FF_SET(pVCpu, VMCPU_FF_PDM_CRITSECT);
586	VMCPU_FF_SET(pVCpu, VMCPU_FF_TO_R3);
587	STAM_REL_COUNTER_INC(&pVM->pdm.s.StatQueuedCritSectLeaves);
588	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZUnlock);
589	}
590	#endif /* IN_RING0 \|\| IN_RC */
591	}
592
593
594	#if defined(IN_RING3) \|\| defined(IN_RING0)
595	/**
596	* Process the critical sections queued for ring-3 'leave'.
597	*
598	* @param pVCpu The VMCPU handle.
599	*/
600	VMMDECL(void) PDMCritSectFF(PVMCPU pVCpu)
601	{
602	Assert(pVCpu->pdm.s.cQueuedCritSectLeaves > 0);
603
604	const RTUINT c = pVCpu->pdm.s.cQueuedCritSectLeaves;
605	for (RTUINT i = 0; i < c; i++)
606	{
607	# ifdef IN_RING3
608	PPDMCRITSECT pCritSect = pVCpu->pdm.s.apQueuedCritSectsLeaves[i];
609	# else
610	PPDMCRITSECT pCritSect = (PPDMCRITSECT)MMHyperR3ToCC(pVCpu->CTX_SUFF(pVM), pVCpu->pdm.s.apQueuedCritSectsLeaves[i]);
611	# endif
612
613	PDMCritSectLeave(pCritSect);
614	LogFlow(("PDMR3CritSectFF: %p\n", pCritSect));
615	}
616
617	pVCpu->pdm.s.cQueuedCritSectLeaves = 0;
618	VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_PDM_CRITSECT);
619	}
620	#endif /* IN_RING3 \|\| IN_RING0 */
621
622
623	/**
624	* Checks the caller is the owner of the critical section.
625	*
626	* @returns true if owner.
627	* @returns false if not owner.
628	* @param pCritSect The critical section.
629	*/
630	VMMDECL(bool) PDMCritSectIsOwner(PCPDMCRITSECT pCritSect)
631	{
632	#ifdef IN_RING3
633	return RTCritSectIsOwner(&pCritSect->s.Core);
634	#else
635	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
636	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
637	if (pCritSect->s.Core.NativeThreadOwner != pVCpu->hNativeThread)
638	return false;
639	return (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0;
640	#endif
641	}
642
643
644	/**
645	* Checks the specified VCPU is the owner of the critical section.
646	*
647	* @returns true if owner.
648	* @returns false if not owner.
649	* @param pCritSect The critical section.
650	* @param idCpu VCPU id
651	*/
652	VMMDECL(bool) PDMCritSectIsOwnerEx(PCPDMCRITSECT pCritSect, VMCPUID idCpu)
653	{
654	#ifdef IN_RING3
655	NOREF(idCpu);
656	return RTCritSectIsOwner(&pCritSect->s.Core);
657	#else
658	PVM pVM = pCritSect->s.CTX_SUFF(pVM);
659	AssertPtr(pVM);
660	Assert(idCpu < pVM->cCpus);
661	return pCritSect->s.Core.NativeThreadOwner == pVM->aCpus[idCpu].hNativeThread
662	&& (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0;
663	#endif
664	}
665
666
667	/**
668	* Checks if somebody currently owns the critical section.
669	*
670	* @returns true if locked.
671	* @returns false if not locked.
672	*
673	* @param pCritSect The critical section.
674	*
675	* @remarks This doesn't prove that no deadlocks will occur later on; it's
676	* just a debugging tool
677	*/
678	VMMDECL(bool) PDMCritSectIsOwned(PCPDMCRITSECT pCritSect)
679	{
680	return pCritSect->s.Core.NativeThreadOwner != NIL_RTNATIVETHREAD
681	&& (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0;
682	}
683
684
685	/**
686	* Checks if anyone is waiting on the critical section we own.
687	*
688	* @returns true if someone is waitings.
689	* @returns false if no one is waiting.
690	* @param pCritSect The critical section.
691	*/
692	VMMDECL(bool) PDMCritSectHasWaiters(PCPDMCRITSECT pCritSect)
693	{
694	AssertReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, false);
695	Assert(pCritSect->s.Core.NativeThreadOwner == pdmCritSectGetNativeSelf(pCritSect));
696	return pCritSect->s.Core.cLockers >= pCritSect->s.Core.cNestings;
697	}
698
699
700	/**
701	* Checks if a critical section is initialized or not.
702	*
703	* @returns true if initialized.
704	* @returns false if not initialized.
705	* @param pCritSect The critical section.
706	*/
707	VMMDECL(bool) PDMCritSectIsInitialized(PCPDMCRITSECT pCritSect)
708	{
709	return RTCritSectIsInitialized(&pCritSect->s.Core);
710	}
711
712
713	/**
714	* Gets the recursion depth.
715	*
716	* @returns The recursion depth.
717	* @param pCritSect The critical section.
718	*/
719	VMMDECL(uint32_t) PDMCritSectGetRecursion(PCPDMCRITSECT pCritSect)
720	{
721	return RTCritSectGetRecursion(&pCritSect->s.Core);
722	}

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

source: vbox/trunk/src/VBox/VMM/VMMAll/PDMAllCritSect.cpp@ 32035

Download in other formats: