PDMAllCritSect.cpp@ 71416

Last change on this file since 71416 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 29.4 KB

Line
1	/* $Id: PDMAllCritSect.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* PDM - Write-Only Critical Section, All Contexts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 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/vmm/pdmcritsect.h>
25	#include <VBox/vmm/mm.h>
26	#include <VBox/vmm/vmm.h>
27	#include <VBox/vmm/vm.h>
28	#include <VBox/err.h>
29	#include <VBox/vmm/hm.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	/** Skips some of the overly paranoid atomic updates.
56	* Makes some assumptions about cache coherence, though not brave enough not to
57	* always end with an atomic update. */
58	#define PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
59
60	/* Undefine the automatic VBOX_STRICT API mappings. */
61	#undef PDMCritSectEnter
62	#undef PDMCritSectTryEnter
63
64
65	/**
66	* Gets the ring-3 native thread handle of the calling thread.
67	*
68	* @returns native thread handle (ring-3).
69	* @param pCritSect The critical section. This is used in R0 and RC.
70	*/
71	DECL_FORCE_INLINE(RTNATIVETHREAD) pdmCritSectGetNativeSelf(PCPDMCRITSECT pCritSect)
72	{
73	#ifdef IN_RING3
74	NOREF(pCritSect);
75	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
76	#else
77	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, ("%RX32\n", pCritSect->s.Core.u32Magic),
78	NIL_RTNATIVETHREAD);
79	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
80	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
81	RTNATIVETHREAD hNativeSelf = pVCpu->hNativeThread; Assert(hNativeSelf != NIL_RTNATIVETHREAD);
82	#endif
83	return hNativeSelf;
84	}
85
86
87	/**
88	* Tail code called when we've won the battle for the lock.
89	*
90	* @returns VINF_SUCCESS.
91	*
92	* @param pCritSect The critical section.
93	* @param hNativeSelf The native handle of this thread.
94	* @param pSrcPos The source position of the lock operation.
95	*/
96	DECL_FORCE_INLINE(int) pdmCritSectEnterFirst(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
97	{
98	AssertMsg(pCritSect->s.Core.NativeThreadOwner == NIL_RTNATIVETHREAD, ("NativeThreadOwner=%p\n", pCritSect->s.Core.NativeThreadOwner));
99	Assert(!(pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK));
100
101	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
102	pCritSect->s.Core.cNestings = 1;
103	# else
104	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 1);
105	# endif
106	Assert(pCritSect->s.Core.cNestings == 1);
107	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, hNativeSelf);
108
109	# ifdef PDMCRITSECT_STRICT
110	RTLockValidatorRecExclSetOwner(pCritSect->s.Core.pValidatorRec, NIL_RTTHREAD, pSrcPos, true);
111	# else
112	NOREF(pSrcPos);
113	# endif
114
115	STAM_PROFILE_ADV_START(&pCritSect->s.StatLocked, l);
116	return VINF_SUCCESS;
117	}
118
119
120	#if defined(IN_RING3) \|\| defined(IN_RING0)
121	/**
122	* Deals with the contended case in ring-3 and ring-0.
123	*
124	* @retval VINF_SUCCESS on success.
125	* @retval VERR_SEM_DESTROYED if destroyed.
126	*
127	* @param pCritSect The critsect.
128	* @param hNativeSelf The native thread handle.
129	* @param pSrcPos The source position of the lock operation.
130	*/
131	static int pdmR3R0CritSectEnterContended(PPDMCRITSECT pCritSect, RTNATIVETHREAD hNativeSelf, PCRTLOCKVALSRCPOS pSrcPos)
132	{
133	/*
134	* Start waiting.
135	*/
136	if (ASMAtomicIncS32(&pCritSect->s.Core.cLockers) == 0)
137	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
138	# ifdef IN_RING3
139	STAM_COUNTER_INC(&pCritSect->s.StatContentionR3);
140	# else
141	STAM_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
142	# endif
143
144	/*
145	* The wait loop.
146	*/
147	PSUPDRVSESSION pSession = pCritSect->s.CTX_SUFF(pVM)->pSession;
148	SUPSEMEVENT hEvent = (SUPSEMEVENT)pCritSect->s.Core.EventSem;
149	# ifdef IN_RING3
150	# ifdef PDMCRITSECT_STRICT
151	RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
152	int rc2 = RTLockValidatorRecExclCheckOrder(pCritSect->s.Core.pValidatorRec, hThreadSelf, pSrcPos, RT_INDEFINITE_WAIT);
153	if (RT_FAILURE(rc2))
154	return rc2;
155	# else
156	RTTHREAD hThreadSelf = RTThreadSelf();
157	# endif
158	# endif
159	for (;;)
160	{
161	/*
162	* Do the wait.
163	*
164	* In ring-3 this gets cluttered by lock validation and thread state
165	* maintainence.
166	*
167	* In ring-0 we have to deal with the possibility that the thread has
168	* been signalled and the interruptible wait function returning
169	* immediately. In that case we do normal R0/RC rcBusy handling.
170	*/
171	# ifdef IN_RING3
172	# ifdef PDMCRITSECT_STRICT
173	int rc9 = RTLockValidatorRecExclCheckBlocking(pCritSect->s.Core.pValidatorRec, hThreadSelf, pSrcPos,
174	!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NO_NESTING),
175	RT_INDEFINITE_WAIT, RTTHREADSTATE_CRITSECT, true);
176	if (RT_FAILURE(rc9))
177	return rc9;
178	# else
179	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_CRITSECT, true);
180	# endif
181	int rc = SUPSemEventWaitNoResume(pSession, hEvent, RT_INDEFINITE_WAIT);
182	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_CRITSECT);
183	# else /* IN_RING0 */
184	int rc = SUPSemEventWaitNoResume(pSession, hEvent, RT_INDEFINITE_WAIT);
185	# endif /* IN_RING0 */
186
187	/*
188	* Deal with the return code and critsect destruction.
189	*/
190	if (RT_UNLIKELY(pCritSect->s.Core.u32Magic != RTCRITSECT_MAGIC))
191	return VERR_SEM_DESTROYED;
192	if (rc == VINF_SUCCESS)
193	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
194	AssertMsg(rc == VERR_INTERRUPTED, ("rc=%Rrc\n", rc));
195
196	# ifdef IN_RING0
197	/* Something is pending (signal, APC, debugger, whatever), just go back
198	to ring-3 so the kernel can deal with it when leaving kernel context.
199
200	Note! We've incremented cLockers already and cannot safely decrement
201	it without creating a race with PDMCritSectLeave, resulting in
202	spurious wakeups. */
203	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
204	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
205	rc = VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_VM_R0_PREEMPT, NULL);
206	AssertRC(rc);
207	# endif
208	}
209	/* won't get here */
210	}
211	#endif /* IN_RING3 \|\| IN_RING0 */
212
213
214	/**
215	* Common worker for the debug and normal APIs.
216	*
217	* @returns VINF_SUCCESS if entered successfully.
218	* @returns rcBusy when encountering a busy critical section in GC/R0.
219	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
220	* during the operation.
221	*
222	* @param pCritSect The PDM critical section to enter.
223	* @param rcBusy The status code to return when we're in GC or R0
224	* @param pSrcPos The source position of the lock operation.
225	*/
226	DECL_FORCE_INLINE(int) pdmCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy, PCRTLOCKVALSRCPOS pSrcPos)
227	{
228	Assert(pCritSect->s.Core.cNestings < 8); /* useful to catch incorrect locking */
229	Assert(pCritSect->s.Core.cNestings >= 0);
230
231	/*
232	* If the critical section has already been destroyed, then inform the caller.
233	*/
234	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC,
235	("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic),
236	VERR_SEM_DESTROYED);
237
238	/*
239	* See if we're lucky.
240	*/
241	/* NOP ... */
242	if (!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NOP))
243	{ /* We're more likely to end up here with real critsects than a NOP one. */ }
244	else
245	return VINF_SUCCESS;
246
247	RTNATIVETHREAD hNativeSelf = pdmCritSectGetNativeSelf(pCritSect);
248	/* ... not owned ... */
249	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
250	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
251
252	/* ... or nested. */
253	if (pCritSect->s.Core.NativeThreadOwner == hNativeSelf)
254	{
255	Assert(pCritSect->s.Core.cNestings >= 1);
256	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
257	pCritSect->s.Core.cNestings += 1;
258	# else
259	ASMAtomicIncS32(&pCritSect->s.Core.cNestings);
260	# endif
261	ASMAtomicIncS32(&pCritSect->s.Core.cLockers);
262	return VINF_SUCCESS;
263	}
264
265	/*
266	* Spin for a bit without incrementing the counter.
267	*/
268	/** @todo Move this to cfgm variables since it doesn't make sense to spin on UNI
269	* cpu systems. */
270	int32_t cSpinsLeft = CTX_SUFF(PDMCRITSECT_SPIN_COUNT_);
271	while (cSpinsLeft-- > 0)
272	{
273	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
274	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
275	ASMNopPause();
276	/** @todo Should use monitor/mwait on e.g. &cLockers here, possibly with a
277	cli'ed pendingpreemption check up front using sti w/ instruction fusing
278	for avoiding races. Hmm ... This is assuming the other party is actually
279	executing code on another CPU ... which we could keep track of if we
280	wanted. */
281	}
282
283	#ifdef IN_RING3
284	/*
285	* Take the slow path.
286	*/
287	NOREF(rcBusy);
288	return pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
289
290	#else
291	# ifdef IN_RING0
292	/** @todo If preemption is disabled it means we're in VT-x/AMD-V context
293	* and would be better off switching out of that while waiting for
294	* the lock. Several of the locks jumps back to ring-3 just to
295	* get the lock, the ring-3 code will then call the kernel to do
296	* the lock wait and when the call return it will call ring-0
297	* again and resume via in setjmp style. Not very efficient. */
298	# if 0
299	if (ASMIntAreEnabled()) /** @todo this can be handled as well by changing
300	* callers not prepared for longjmp/blocking to
301	* use PDMCritSectTryEnter. */
302	{
303	/*
304	* Leave HM context while waiting if necessary.
305	*/
306	int rc;
307	if (RTThreadPreemptIsEnabled(NIL_RTTHREAD))
308	{
309	STAM_REL_COUNTER_ADD(&pCritSect->s.StatContentionRZLock, 1000000);
310	rc = pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
311	}
312	else
313	{
314	STAM_REL_COUNTER_ADD(&pCritSect->s.StatContentionRZLock, 1000000000);
315	PVM pVM = pCritSect->s.CTX_SUFF(pVM);
316	PVMCPU pVCpu = VMMGetCpu(pVM);
317	HMR0Leave(pVM, pVCpu);
318	RTThreadPreemptRestore(NIL_RTTHREAD, XXX);
319
320	rc = pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
321
322	RTThreadPreemptDisable(NIL_RTTHREAD, XXX);
323	HMR0Enter(pVM, pVCpu);
324	}
325	return rc;
326	}
327	# else
328	/*
329	* We preemption hasn't been disabled, we can block here in ring-0.
330	*/
331	if ( RTThreadPreemptIsEnabled(NIL_RTTHREAD)
332	&& ASMIntAreEnabled())
333	return pdmR3R0CritSectEnterContended(pCritSect, hNativeSelf, pSrcPos);
334	# endif
335	#endif /* IN_RING0 */
336
337	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
338
339	/*
340	* Call ring-3 to acquire the critical section?
341	*/
342	if (rcBusy == VINF_SUCCESS)
343	{
344	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
345	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
346	return VMMRZCallRing3(pVM, pVCpu, VMMCALLRING3_PDM_CRIT_SECT_ENTER, MMHyperCCToR3(pVM, pCritSect));
347	}
348
349	/*
350	* Return busy.
351	*/
352	LogFlow(("PDMCritSectEnter: locked => R3 (%Rrc)\n", rcBusy));
353	return rcBusy;
354	#endif /* !IN_RING3 */
355	}
356
357
358	/**
359	* Enters a PDM critical section.
360	*
361	* @returns VINF_SUCCESS if entered successfully.
362	* @returns rcBusy when encountering a busy critical section in RC/R0.
363	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
364	* during the operation.
365	*
366	* @param pCritSect The PDM critical section to enter.
367	* @param rcBusy The status code to return when we're in RC or R0
368	* and the section is busy. Pass VINF_SUCCESS to
369	* acquired the critical section thru a ring-3
370	* call if necessary.
371	*/
372	VMMDECL(int) PDMCritSectEnter(PPDMCRITSECT pCritSect, int rcBusy)
373	{
374	#ifndef PDMCRITSECT_STRICT
375	return pdmCritSectEnter(pCritSect, rcBusy, NULL);
376	#else
377	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
378	return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
379	#endif
380	}
381
382
383	/**
384	* Enters a PDM critical section, with location information for debugging.
385	*
386	* @returns VINF_SUCCESS if entered successfully.
387	* @returns rcBusy when encountering a busy critical section in RC/R0.
388	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
389	* during the operation.
390	*
391	* @param pCritSect The PDM critical section to enter.
392	* @param rcBusy The status code to return when we're in RC or R0
393	* and the section is busy. Pass VINF_SUCCESS to
394	* acquired the critical section thru a ring-3
395	* call if necessary.
396	* @param uId Some kind of locking location ID. Typically a
397	* return address up the stack. Optional (0).
398	* @param SRC_POS The source position where to lock is being
399	* acquired from. Optional.
400	*/
401	VMMDECL(int) PDMCritSectEnterDebug(PPDMCRITSECT pCritSect, int rcBusy, RTHCUINTPTR uId, RT_SRC_POS_DECL)
402	{
403	#ifdef PDMCRITSECT_STRICT
404	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
405	return pdmCritSectEnter(pCritSect, rcBusy, &SrcPos);
406	#else
407	NOREF(uId); RT_SRC_POS_NOREF();
408	return pdmCritSectEnter(pCritSect, rcBusy, NULL);
409	#endif
410	}
411
412
413	/**
414	* Common worker for the debug and normal APIs.
415	*
416	* @retval VINF_SUCCESS on success.
417	* @retval VERR_SEM_BUSY if the critsect was owned.
418	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
419	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
420	* during the operation.
421	*
422	* @param pCritSect The critical section.
423	* @param pSrcPos The source position of the lock operation.
424	*/
425	static int pdmCritSectTryEnter(PPDMCRITSECT pCritSect, PCRTLOCKVALSRCPOS pSrcPos)
426	{
427	/*
428	* If the critical section has already been destroyed, then inform the caller.
429	*/
430	AssertMsgReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC,
431	("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic),
432	VERR_SEM_DESTROYED);
433
434	/*
435	* See if we're lucky.
436	*/
437	/* NOP ... */
438	if (!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NOP))
439	{ /* We're more likely to end up here with real critsects than a NOP one. */ }
440	else
441	return VINF_SUCCESS;
442
443	RTNATIVETHREAD hNativeSelf = pdmCritSectGetNativeSelf(pCritSect);
444	/* ... not owned ... */
445	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, 0, -1))
446	return pdmCritSectEnterFirst(pCritSect, hNativeSelf, pSrcPos);
447
448	/* ... or nested. */
449	if (pCritSect->s.Core.NativeThreadOwner == hNativeSelf)
450	{
451	Assert(pCritSect->s.Core.cNestings >= 1);
452	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
453	pCritSect->s.Core.cNestings += 1;
454	# else
455	ASMAtomicIncS32(&pCritSect->s.Core.cNestings);
456	# endif
457	ASMAtomicIncS32(&pCritSect->s.Core.cLockers);
458	return VINF_SUCCESS;
459	}
460
461	/* no spinning */
462
463	/*
464	* Return busy.
465	*/
466	#ifdef IN_RING3
467	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionR3);
468	#else
469	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZLock);
470	#endif
471	LogFlow(("PDMCritSectTryEnter: locked\n"));
472	return VERR_SEM_BUSY;
473	}
474
475
476	/**
477	* Try enter a critical section.
478	*
479	* @retval VINF_SUCCESS on success.
480	* @retval VERR_SEM_BUSY if the critsect was owned.
481	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
482	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
483	* during the operation.
484	*
485	* @param pCritSect The critical section.
486	*/
487	VMMDECL(int) PDMCritSectTryEnter(PPDMCRITSECT pCritSect)
488	{
489	#ifndef PDMCRITSECT_STRICT
490	return pdmCritSectTryEnter(pCritSect, NULL);
491	#else
492	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
493	return pdmCritSectTryEnter(pCritSect, &SrcPos);
494	#endif
495	}
496
497
498	/**
499	* Try enter a critical section, with location information for debugging.
500	*
501	* @retval VINF_SUCCESS on success.
502	* @retval VERR_SEM_BUSY if the critsect was owned.
503	* @retval VERR_SEM_NESTED if nested enter on a no nesting section. (Asserted.)
504	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
505	* during the operation.
506	*
507	* @param pCritSect The critical section.
508	* @param uId Some kind of locking location ID. Typically a
509	* return address up the stack. Optional (0).
510	* @param SRC_POS The source position where to lock is being
511	* acquired from. Optional.
512	*/
513	VMMDECL(int) PDMCritSectTryEnterDebug(PPDMCRITSECT pCritSect, RTHCUINTPTR uId, RT_SRC_POS_DECL)
514	{
515	#ifdef PDMCRITSECT_STRICT
516	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
517	return pdmCritSectTryEnter(pCritSect, &SrcPos);
518	#else
519	NOREF(uId); RT_SRC_POS_NOREF();
520	return pdmCritSectTryEnter(pCritSect, NULL);
521	#endif
522	}
523
524
525	#ifdef IN_RING3
526	/**
527	* Enters a PDM critical section.
528	*
529	* @returns VINF_SUCCESS if entered successfully.
530	* @returns rcBusy when encountering a busy critical section in GC/R0.
531	* @retval VERR_SEM_DESTROYED if the critical section is delete before or
532	* during the operation.
533	*
534	* @param pCritSect The PDM critical section to enter.
535	* @param fCallRing3 Whether this is a VMMRZCallRing3()request.
536	*/
537	VMMR3DECL(int) PDMR3CritSectEnterEx(PPDMCRITSECT pCritSect, bool fCallRing3)
538	{
539	int rc = PDMCritSectEnter(pCritSect, VERR_IGNORED);
540	if ( rc == VINF_SUCCESS
541	&& fCallRing3
542	&& pCritSect->s.Core.pValidatorRec
543	&& pCritSect->s.Core.pValidatorRec->hThread != NIL_RTTHREAD)
544	RTLockValidatorRecExclReleaseOwnerUnchecked(pCritSect->s.Core.pValidatorRec);
545	return rc;
546	}
547	#endif /* IN_RING3 */
548
549
550	/**
551	* Leaves a critical section entered with PDMCritSectEnter().
552	*
553	* @returns Indication whether we really exited the critical section.
554	* @retval VINF_SUCCESS if we really exited.
555	* @retval VINF_SEM_NESTED if we only reduced the nesting count.
556	* @retval VERR_NOT_OWNER if you somehow ignore release assertions.
557	*
558	* @param pCritSect The PDM critical section to leave.
559	*/
560	VMMDECL(int) PDMCritSectLeave(PPDMCRITSECT pCritSect)
561	{
562	AssertMsg(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, ("%p %RX32\n", pCritSect, pCritSect->s.Core.u32Magic));
563	Assert(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC);
564
565	/* Check for NOP sections before asserting ownership. */
566	if (!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NOP))
567	{ /* We're more likely to end up here with real critsects than a NOP one. */ }
568	else
569	return VINF_SUCCESS;
570
571	/*
572	* Always check that the caller is the owner (screw performance).
573	*/
574	RTNATIVETHREAD const hNativeSelf = pdmCritSectGetNativeSelf(pCritSect);
575	AssertReleaseMsgReturn(pCritSect->s.Core.NativeThreadOwner == hNativeSelf,
576	("%p %s: %p != %p; cLockers=%d cNestings=%d\n", pCritSect, R3STRING(pCritSect->s.pszName),
577	pCritSect->s.Core.NativeThreadOwner, hNativeSelf,
578	pCritSect->s.Core.cLockers, pCritSect->s.Core.cNestings),
579	VERR_NOT_OWNER);
580
581	/*
582	* Nested leave.
583	*/
584	int32_t const cNestings = pCritSect->s.Core.cNestings;
585	Assert(cNestings >= 1);
586	if (cNestings > 1)
587	{
588	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
589	pCritSect->s.Core.cNestings = cNestings - 1;
590	# else
591	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, cNestings - 1);
592	# endif
593	ASMAtomicDecS32(&pCritSect->s.Core.cLockers);
594	Assert(pCritSect->s.Core.cLockers >= 0);
595	return VINF_SEM_NESTED;
596	}
597
598	#ifdef IN_RING0
599	# if 0 /** @todo Make SUPSemEventSignal interrupt safe (handle table++) and enable this for: defined(RT_OS_LINUX) \|\| defined(RT_OS_OS2) */
600	if (1) /* SUPSemEventSignal is safe */
601	# else
602	if (ASMIntAreEnabled())
603	# endif
604	#endif
605	#if defined(IN_RING3) \|\| defined(IN_RING0)
606	{
607	/*
608	* Leave for real.
609	*/
610	/* update members. */
611	SUPSEMEVENT hEventToSignal = pCritSect->s.hEventToSignal;
612	pCritSect->s.hEventToSignal = NIL_SUPSEMEVENT;
613	# ifdef IN_RING3
614	# if defined(PDMCRITSECT_STRICT)
615	if (pCritSect->s.Core.pValidatorRec->hThread != NIL_RTTHREAD)
616	RTLockValidatorRecExclReleaseOwnerUnchecked(pCritSect->s.Core.pValidatorRec);
617	# endif
618	Assert(!pCritSect->s.Core.pValidatorRec \|\| pCritSect->s.Core.pValidatorRec->hThread == NIL_RTTHREAD);
619	# endif
620	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
621	//pCritSect->s.Core.cNestings = 0; /* not really needed */
622	pCritSect->s.Core.NativeThreadOwner = NIL_RTNATIVETHREAD;
623	# else
624	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 0);
625	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, NIL_RTNATIVETHREAD);
626	# endif
627	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
628
629	/* stop and decrement lockers. */
630	STAM_PROFILE_ADV_STOP(&pCritSect->s.StatLocked, l);
631	ASMCompilerBarrier();
632	if (ASMAtomicDecS32(&pCritSect->s.Core.cLockers) < 0)
633	{ /* hopefully likely */ }
634	else
635	{
636	/* Someone is waiting, wake up one of them. */
637	SUPSEMEVENT hEvent = (SUPSEMEVENT)pCritSect->s.Core.EventSem;
638	PSUPDRVSESSION pSession = pCritSect->s.CTX_SUFF(pVM)->pSession;
639	int rc = SUPSemEventSignal(pSession, hEvent);
640	AssertRC(rc);
641	}
642
643	/* Signal exit event. */
644	if (RT_LIKELY(hEventToSignal == NIL_SUPSEMEVENT))
645	{ /* likely */ }
646	else
647	{
648	Log8(("Signalling %#p\n", hEventToSignal));
649	int rc = SUPSemEventSignal(pCritSect->s.CTX_SUFF(pVM)->pSession, hEventToSignal);
650	AssertRC(rc);
651	}
652
653	# if defined(DEBUG_bird) && defined(IN_RING0)
654	VMMTrashVolatileXMMRegs();
655	# endif
656	}
657	#endif /* IN_RING3 \|\| IN_RING0 */
658	#ifdef IN_RING0
659	else
660	#endif
661	#if defined(IN_RING0) \|\| defined(IN_RC)
662	{
663	/*
664	* Try leave it.
665	*/
666	if (pCritSect->s.Core.cLockers == 0)
667	{
668	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
669	//pCritSect->s.Core.cNestings = 0; /* not really needed */
670	# else
671	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 0);
672	# endif
673	RTNATIVETHREAD hNativeThread = pCritSect->s.Core.NativeThreadOwner;
674	ASMAtomicAndU32(&pCritSect->s.Core.fFlags, ~PDMCRITSECT_FLAGS_PENDING_UNLOCK);
675	STAM_PROFILE_ADV_STOP(&pCritSect->s.StatLocked, l);
676
677	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, NIL_RTNATIVETHREAD);
678	if (ASMAtomicCmpXchgS32(&pCritSect->s.Core.cLockers, -1, 0))
679	return VINF_SUCCESS;
680
681	/* darn, someone raced in on us. */
682	ASMAtomicWriteHandle(&pCritSect->s.Core.NativeThreadOwner, hNativeThread);
683	STAM_PROFILE_ADV_START(&pCritSect->s.StatLocked, l);
684	# ifdef PDMCRITSECT_WITH_LESS_ATOMIC_STUFF
685	//pCritSect->s.Core.cNestings = 1;
686	Assert(pCritSect->s.Core.cNestings == 1);
687	# else
688	//Assert(pCritSect->s.Core.cNestings == 0);
689	ASMAtomicWriteS32(&pCritSect->s.Core.cNestings, 1);
690	# endif
691	}
692	ASMAtomicOrU32(&pCritSect->s.Core.fFlags, PDMCRITSECT_FLAGS_PENDING_UNLOCK);
693
694	/*
695	* Queue the request.
696	*/
697	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
698	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
699	uint32_t i = pVCpu->pdm.s.cQueuedCritSectLeaves++;
700	LogFlow(("PDMCritSectLeave: [%d]=%p => R3\n", i, pCritSect));
701	AssertFatal(i < RT_ELEMENTS(pVCpu->pdm.s.apQueuedCritSectLeaves));
702	pVCpu->pdm.s.apQueuedCritSectLeaves[i] = MMHyperCCToR3(pVM, pCritSect);
703	VMCPU_FF_SET(pVCpu, VMCPU_FF_PDM_CRITSECT);
704	VMCPU_FF_SET(pVCpu, VMCPU_FF_TO_R3);
705	STAM_REL_COUNTER_INC(&pVM->pdm.s.StatQueuedCritSectLeaves);
706	STAM_REL_COUNTER_INC(&pCritSect->s.StatContentionRZUnlock);
707	}
708	#endif /* IN_RING0 \|\| IN_RC */
709
710	return VINF_SUCCESS;
711	}
712
713
714	#if defined(IN_RING0) \|\| defined(IN_RING3)
715	/**
716	* Schedule a event semaphore for signalling upon critsect exit.
717	*
718	* @returns VINF_SUCCESS on success.
719	* @returns VERR_TOO_MANY_SEMAPHORES if an event was already scheduled.
720	* @returns VERR_NOT_OWNER if we're not the critsect owner (ring-3 only).
721	* @returns VERR_SEM_DESTROYED if RTCritSectDelete was called while waiting.
722	*
723	* @param pCritSect The critical section.
724	* @param hEventToSignal The support driver event semaphore that should be
725	* signalled.
726	*/
727	VMMDECL(int) PDMHCCritSectScheduleExitEvent(PPDMCRITSECT pCritSect, SUPSEMEVENT hEventToSignal)
728	{
729	AssertPtr(pCritSect);
730	Assert(!(pCritSect->s.Core.fFlags & RTCRITSECT_FLAGS_NOP));
731	Assert(hEventToSignal != NIL_SUPSEMEVENT);
732	# ifdef IN_RING3
733	if (RT_UNLIKELY(!RTCritSectIsOwner(&pCritSect->s.Core)))
734	return VERR_NOT_OWNER;
735	# endif
736	if (RT_LIKELY( pCritSect->s.hEventToSignal == NIL_RTSEMEVENT
737	\|\| pCritSect->s.hEventToSignal == hEventToSignal))
738	{
739	pCritSect->s.hEventToSignal = hEventToSignal;
740	return VINF_SUCCESS;
741	}
742	return VERR_TOO_MANY_SEMAPHORES;
743	}
744	#endif /* IN_RING0 \|\| IN_RING3 */
745
746
747	/**
748	* Checks the caller is the owner of the critical section.
749	*
750	* @returns true if owner.
751	* @returns false if not owner.
752	* @param pCritSect The critical section.
753	*/
754	VMMDECL(bool) PDMCritSectIsOwner(PCPDMCRITSECT pCritSect)
755	{
756	#ifdef IN_RING3
757	return RTCritSectIsOwner(&pCritSect->s.Core);
758	#else
759	PVM pVM = pCritSect->s.CTX_SUFF(pVM); AssertPtr(pVM);
760	PVMCPU pVCpu = VMMGetCpu(pVM); AssertPtr(pVCpu);
761	if (pCritSect->s.Core.NativeThreadOwner != pVCpu->hNativeThread)
762	return false;
763	return (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0
764	\|\| pCritSect->s.Core.cNestings > 1;
765	#endif
766	}
767
768
769	/**
770	* Checks the specified VCPU is the owner of the critical section.
771	*
772	* @returns true if owner.
773	* @returns false if not owner.
774	* @param pCritSect The critical section.
775	* @param pVCpu The cross context virtual CPU structure.
776	*/
777	VMMDECL(bool) PDMCritSectIsOwnerEx(PCPDMCRITSECT pCritSect, PVMCPU pVCpu)
778	{
779	#ifdef IN_RING3
780	NOREF(pVCpu);
781	return RTCritSectIsOwner(&pCritSect->s.Core);
782	#else
783	Assert(&pVCpu->CTX_SUFF(pVM)->aCpus[pVCpu->idCpu] == pVCpu);
784	if (pCritSect->s.Core.NativeThreadOwner != pVCpu->hNativeThread)
785	return false;
786	return (pCritSect->s.Core.fFlags & PDMCRITSECT_FLAGS_PENDING_UNLOCK) == 0
787	\|\| pCritSect->s.Core.cNestings > 1;
788	#endif
789	}
790
791
792	/**
793	* Checks if anyone is waiting on the critical section we own.
794	*
795	* @returns true if someone is waiting.
796	* @returns false if no one is waiting.
797	* @param pCritSect The critical section.
798	*/
799	VMMDECL(bool) PDMCritSectHasWaiters(PCPDMCRITSECT pCritSect)
800	{
801	AssertReturn(pCritSect->s.Core.u32Magic == RTCRITSECT_MAGIC, false);
802	Assert(pCritSect->s.Core.NativeThreadOwner == pdmCritSectGetNativeSelf(pCritSect));
803	return pCritSect->s.Core.cLockers >= pCritSect->s.Core.cNestings;
804	}
805
806
807	/**
808	* Checks if a critical section is initialized or not.
809	*
810	* @returns true if initialized.
811	* @returns false if not initialized.
812	* @param pCritSect The critical section.
813	*/
814	VMMDECL(bool) PDMCritSectIsInitialized(PCPDMCRITSECT pCritSect)
815	{
816	return RTCritSectIsInitialized(&pCritSect->s.Core);
817	}
818
819
820	/**
821	* Gets the recursion depth.
822	*
823	* @returns The recursion depth.
824	* @param pCritSect The critical section.
825	*/
826	VMMDECL(uint32_t) PDMCritSectGetRecursion(PCPDMCRITSECT pCritSect)
827	{
828	return RTCritSectGetRecursion(&pCritSect->s.Core);
829	}
830

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

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

Download in other formats: