semrw-generic.cpp@ 92326

Last change on this file since 92326 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 29.7 KB

Line
1	/* $Id: semrw-generic.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* IPRT - Read-Write Semaphore, Generic.
4	*
5	* This is a generic implementation for OSes which don't have
6	* native RW semaphores.
7	*/
8
9	/*
10	* Copyright (C) 2006-2020 Oracle Corporation
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*
20	* The contents of this file may alternatively be used under the terms
21	* of the Common Development and Distribution License Version 1.0
22	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
23	* VirtualBox OSE distribution, in which case the provisions of the
24	* CDDL are applicable instead of those of the GPL.
25	*
26	* You may elect to license modified versions of this file under the
27	* terms and conditions of either the GPL or the CDDL or both.
28	*/
29
30
31	/*********************************************************************************************************************************
32	* Header Files *
33	*********************************************************************************************************************************/
34	#define RTSEMRW_WITHOUT_REMAPPING
35	#include <iprt/semaphore.h>
36	#include "internal/iprt.h"
37
38	#include <iprt/asm.h>
39	#include <iprt/assert.h>
40	#include <iprt/critsect.h>
41	#include <iprt/err.h>
42	#include <iprt/lockvalidator.h>
43	#include <iprt/mem.h>
44	#include <iprt/time.h>
45	#include <iprt/thread.h>
46
47	#include "internal/magics.h"
48	#include "internal/strict.h"
49
50
51	/*********************************************************************************************************************************
52	* Structures and Typedefs *
53	*********************************************************************************************************************************/
54
55	/** Internal representation of a Read-Write semaphore for the
56	* Generic implementation. */
57	struct RTSEMRWINTERNAL
58	{
59	/** The usual magic. (RTSEMRW_MAGIC) */
60	uint32_t u32Magic;
61	/* Alignment padding. */
62	uint32_t u32Padding;
63	/** This critical section serializes the access to and updating of the structure members. */
64	RTCRITSECT CritSect;
65	/** The current number of reads. (pure read recursion counts too) */
66	uint32_t cReads;
67	/** The current number of writes. (recursion counts too) */
68	uint32_t cWrites;
69	/** Number of read recursions by the writer. */
70	uint32_t cWriterReads;
71	/** Number of writers waiting. */
72	uint32_t cWritesWaiting;
73	/** The write owner of the lock. */
74	RTNATIVETHREAD hWriter;
75	/** The handle of the event object on which the waiting readers block. (manual reset). */
76	RTSEMEVENTMULTI ReadEvent;
77	/** The handle of the event object on which the waiting writers block. (automatic reset). */
78	RTSEMEVENT WriteEvent;
79	/** Need to reset ReadEvent. */
80	bool fNeedResetReadEvent;
81	#ifdef RTSEMRW_STRICT
82	/** The validator record for the writer. */
83	RTLOCKVALRECEXCL ValidatorWrite;
84	/** The validator record for the readers. */
85	RTLOCKVALRECSHRD ValidatorRead;
86	#endif
87	};
88
89
90
91	RTDECL(int) RTSemRWCreate(PRTSEMRW phRWSem)
92	{
93	return RTSemRWCreateEx(phRWSem, 0 /fFlags/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, "RTSemRW");
94	}
95	RT_EXPORT_SYMBOL(RTSemRWCreate);
96
97
98	RTDECL(int) RTSemRWCreateEx(PRTSEMRW phRWSem, uint32_t fFlags,
99	RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
100	{
101	AssertReturn(!(fFlags & ~RTSEMRW_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
102
103	/*
104	* Allocate memory.
105	*/
106	int rc;
107	struct RTSEMRWINTERNAL pThis = (struct RTSEMRWINTERNAL )RTMemAlloc(sizeof(struct RTSEMRWINTERNAL));
108	if (pThis)
109	{
110	/*
111	* Create the semaphores.
112	*/
113	rc = RTSemEventCreateEx(&pThis->WriteEvent, RTSEMEVENT_FLAGS_NO_LOCK_VAL, NIL_RTLOCKVALCLASS, NULL);
114	if (RT_SUCCESS(rc))
115	{
116	rc = RTSemEventMultiCreateEx(&pThis->ReadEvent, RTSEMEVENT_FLAGS_NO_LOCK_VAL, NIL_RTLOCKVALCLASS, NULL);
117	if (RT_SUCCESS(rc))
118	{
119	rc = RTCritSectInitEx(&pThis->CritSect, RTCRITSECT_FLAGS_NO_LOCK_VAL,
120	NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
121	if (RT_SUCCESS(rc))
122	{
123	/*
124	* Signal the read semaphore and initialize other variables.
125	*/
126	rc = RTSemEventMultiSignal(pThis->ReadEvent);
127	if (RT_SUCCESS(rc))
128	{
129	pThis->u32Padding = UINT32_C(0xa5a55a5a);
130	pThis->cReads = 0;
131	pThis->cWrites = 0;
132	pThis->cWriterReads = 0;
133	pThis->cWritesWaiting = 0;
134	pThis->hWriter = NIL_RTNATIVETHREAD;
135	pThis->fNeedResetReadEvent = true;
136	pThis->u32Magic = RTSEMRW_MAGIC;
137	#ifdef RTSEMRW_STRICT
138	bool const fLVEnabled = !(fFlags & RTSEMRW_FLAGS_NO_LOCK_VAL);
139	if (!pszNameFmt)
140	{
141	static uint32_t volatile s_iSemRWAnon = 0;
142	uint32_t i = ASMAtomicIncU32(&s_iSemRWAnon) - 1;
143	RTLockValidatorRecExclInit(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
144	fLVEnabled, "RTSemRW-%u", i);
145	RTLockValidatorRecSharedInit(&pThis->ValidatorRead, hClass, uSubClass, pThis,
146	false /fSignaller/, fLVEnabled, "RTSemRW-%u", i);
147	}
148	else
149	{
150	va_list va;
151	va_start(va, pszNameFmt);
152	RTLockValidatorRecExclInitV(&pThis->ValidatorWrite, hClass, uSubClass, pThis,
153	fLVEnabled, pszNameFmt, va);
154	va_end(va);
155	va_start(va, pszNameFmt);
156	RTLockValidatorRecSharedInitV(&pThis->ValidatorRead, hClass, uSubClass, pThis,
157	false /fSignaller/, fLVEnabled, pszNameFmt, va);
158	va_end(va);
159	}
160	RTLockValidatorRecMakeSiblings(&pThis->ValidatorWrite.Core, &pThis->ValidatorRead.Core);
161	#else
162	RT_NOREF_PV(hClass); RT_NOREF_PV(uSubClass); RT_NOREF_PV(pszNameFmt);
163	#endif
164	*phRWSem = pThis;
165	return VINF_SUCCESS;
166	}
167	RTCritSectDelete(&pThis->CritSect);
168	}
169	RTSemEventMultiDestroy(pThis->ReadEvent);
170	}
171	RTSemEventDestroy(pThis->WriteEvent);
172	}
173	RTMemFree(pThis);
174	}
175	else
176	rc = VERR_NO_MEMORY;
177
178	return rc;
179	}
180	RT_EXPORT_SYMBOL(RTSemRWCreate);
181
182
183	RTDECL(int) RTSemRWDestroy(RTSEMRW hRWSem)
184	{
185	struct RTSEMRWINTERNAL *pThis = hRWSem;
186
187	/*
188	* Validate handle.
189	*/
190	if (pThis == NIL_RTSEMRW)
191	return VINF_SUCCESS;
192	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
193	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
194
195	/*
196	* Check if busy.
197	*/
198	int rc = RTCritSectTryEnter(&pThis->CritSect);
199	if (RT_SUCCESS(rc))
200	{
201	if (!pThis->cReads && !pThis->cWrites)
202	{
203	/*
204	* Make it invalid and unusable.
205	*/
206	ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMRW_MAGIC);
207	pThis->cReads = UINT32_MAX;
208
209	/*
210	* Do actual cleanup. None of these can now fail.
211	*/
212	rc = RTSemEventMultiDestroy(pThis->ReadEvent);
213	AssertMsgRC(rc, ("RTSemEventMultiDestroy failed! rc=%Rrc\n", rc));
214	pThis->ReadEvent = NIL_RTSEMEVENTMULTI;
215
216	rc = RTSemEventDestroy(pThis->WriteEvent);
217	AssertMsgRC(rc, ("RTSemEventDestroy failed! rc=%Rrc\n", rc));
218	pThis->WriteEvent = NIL_RTSEMEVENT;
219
220	RTCritSectLeave(&pThis->CritSect);
221	rc = RTCritSectDelete(&pThis->CritSect);
222	AssertMsgRC(rc, ("RTCritSectDelete failed! rc=%Rrc\n", rc));
223
224	#ifdef RTSEMRW_STRICT
225	RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
226	RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
227	#endif
228	RTMemFree(pThis);
229	rc = VINF_SUCCESS;
230	}
231	else
232	{
233	rc = VERR_SEM_BUSY;
234	RTCritSectLeave(&pThis->CritSect);
235	}
236	}
237	else
238	{
239	AssertMsgRC(rc, ("RTCritSectTryEnter failed! rc=%Rrc\n", rc));
240	rc = VERR_SEM_BUSY;
241	}
242
243	return rc;
244	}
245	RT_EXPORT_SYMBOL(RTSemRWDestroy);
246
247
248	RTDECL(uint32_t) RTSemRWSetSubClass(RTSEMRW hRWSem, uint32_t uSubClass)
249	{
250	#ifdef RTSEMRW_STRICT
251	/*
252	* Validate handle.
253	*/
254	struct RTSEMRWINTERNAL *pThis = hRWSem;
255	AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID);
256	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
257
258	RTLockValidatorRecSharedSetSubClass(&pThis->ValidatorRead, uSubClass);
259	return RTLockValidatorRecExclSetSubClass(&pThis->ValidatorWrite, uSubClass);
260	#else
261	RT_NOREF_PV(hRWSem); RT_NOREF_PV(uSubClass);
262	return RTLOCKVAL_SUB_CLASS_INVALID;
263	#endif
264	}
265	RT_EXPORT_SYMBOL(RTSemRWSetSubClass);
266
267
268	DECL_FORCE_INLINE(int) rtSemRWRequestRead(RTSEMRW hRWSem, RTMSINTERVAL cMillies, bool fInterruptible, PCRTLOCKVALSRCPOS pSrcPos)
269	{
270	/*
271	* Validate handle.
272	*/
273	struct RTSEMRWINTERNAL *pThis = hRWSem;
274	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
275	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
276
277	RTMSINTERVAL cMilliesInitial = cMillies;
278	uint64_t tsStart = 0;
279	if (cMillies != RT_INDEFINITE_WAIT && cMillies != 0)
280	tsStart = RTTimeNanoTS();
281
282	#ifdef RTSEMRW_STRICT
283	RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
284	if (cMillies > 0)
285	{
286	int rc9;
287	if (pThis->hWriter != NIL_RTTHREAD && pThis->hWriter == RTThreadNativeSelf())
288	rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, cMillies);
289	else
290	rc9 = RTLockValidatorRecSharedCheckOrder(&pThis->ValidatorRead, hThreadSelf, pSrcPos, cMillies);
291	if (RT_FAILURE(rc9))
292	return rc9;
293	}
294	#endif
295
296	/*
297	* Take critsect.
298	*/
299	int rc = RTCritSectEnter(&pThis->CritSect);
300	if (RT_FAILURE(rc))
301	{
302	AssertMsgFailed(("RTCritSectEnter failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
303	return rc;
304	}
305
306	/*
307	* Check if the state of affairs allows read access.
308	* Do not block further readers if there is a writer waiting, as
309	* that will break/deadlock reader recursion.
310	*/
311	if ( pThis->hWriter == NIL_RTNATIVETHREAD
312	#if 0
313	&& ( !pThis->cWritesWaiting
314	\|\| pThis->cReads)
315	#endif
316	)
317	{
318	pThis->cReads++;
319	Assert(pThis->cReads > 0);
320	#ifdef RTSEMRW_STRICT
321	RTLockValidatorRecSharedAddOwner(&pThis->ValidatorRead, hThreadSelf, pSrcPos);
322	#endif
323
324	RTCritSectLeave(&pThis->CritSect);
325	return VINF_SUCCESS;
326	}
327
328	RTNATIVETHREAD hNativeSelf = pThis->CritSect.NativeThreadOwner;
329	if (pThis->hWriter == hNativeSelf)
330	{
331	#ifdef RTSEMRW_STRICT
332	int rc9 = RTLockValidatorRecExclRecursionMixed(&pThis->ValidatorWrite, &pThis->ValidatorRead.Core, pSrcPos);
333	if (RT_FAILURE(rc9))
334	{
335	RTCritSectLeave(&pThis->CritSect);
336	return rc9;
337	}
338	#endif
339
340	pThis->cWriterReads++;
341	Assert(pThis->cWriterReads > 0);
342
343	RTCritSectLeave(&pThis->CritSect);
344	return VINF_SUCCESS;
345	}
346
347	RTCritSectLeave(&pThis->CritSect);
348
349	/*
350	* Wait till it's ready for reading.
351	*/
352	if (cMillies == 0)
353	return VERR_TIMEOUT;
354
355	#ifndef RTSEMRW_STRICT
356	RTTHREAD hThreadSelf = RTThreadSelf();
357	#endif
358	for (;;)
359	{
360	if (cMillies != RT_INDEFINITE_WAIT)
361	{
362	int64_t tsDelta = RTTimeNanoTS() - tsStart;
363	if (tsDelta >= 1000000)
364	{
365	tsDelta /= 1000000;
366	if ((uint64_t)tsDelta < cMilliesInitial)
367	cMilliesInitial = (RTMSINTERVAL)tsDelta;
368	else
369	cMilliesInitial = 1;
370	}
371	}
372	#ifdef RTSEMRW_STRICT
373	rc = RTLockValidatorRecSharedCheckBlocking(&pThis->ValidatorRead, hThreadSelf, pSrcPos, true,
374	cMillies, RTTHREADSTATE_RW_READ, false);
375	if (RT_FAILURE(rc))
376	break;
377	#else
378	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_RW_READ, false);
379	RT_NOREF_PV(pSrcPos);
380	#endif
381	int rcWait;
382	if (fInterruptible)
383	rcWait = rc = RTSemEventMultiWaitNoResume(pThis->ReadEvent, cMillies);
384	else
385	rcWait = rc = RTSemEventMultiWait(pThis->ReadEvent, cMillies);
386	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_READ);
387	if (RT_FAILURE(rc) && rc != VERR_TIMEOUT) /* handle timeout below */
388	{
389	AssertMsgRC(rc, ("RTSemEventMultiWait failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
390	break;
391	}
392
393	if (pThis->u32Magic != RTSEMRW_MAGIC)
394	{
395	rc = VERR_SEM_DESTROYED;
396	break;
397	}
398
399	/*
400	* Re-take critsect and repeat the check we did before the loop.
401	*/
402	rc = RTCritSectEnter(&pThis->CritSect);
403	if (RT_FAILURE(rc))
404	{
405	AssertMsgFailed(("RTCritSectEnter failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
406	break;
407	}
408
409	if ( pThis->hWriter == NIL_RTNATIVETHREAD
410	#if 0
411	&& ( !pThis->cWritesWaiting
412	\|\| pThis->cReads)
413	#endif
414	)
415	{
416	pThis->cReads++;
417	Assert(pThis->cReads > 0);
418	#ifdef RTSEMRW_STRICT
419	RTLockValidatorRecSharedAddOwner(&pThis->ValidatorRead, hThreadSelf, pSrcPos);
420	#endif
421
422	RTCritSectLeave(&pThis->CritSect);
423	return VINF_SUCCESS;
424	}
425
426	RTCritSectLeave(&pThis->CritSect);
427
428	/*
429	* Quit if the wait already timed out.
430	*/
431	if (rcWait == VERR_TIMEOUT)
432	{
433	rc = VERR_TIMEOUT;
434	break;
435	}
436	}
437
438	/* failed */
439	return rc;
440	}
441
442
443	RTDECL(int) RTSemRWRequestRead(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
444	{
445	#ifndef RTSEMRW_STRICT
446	return rtSemRWRequestRead(hRWSem, cMillies, false, NULL);
447	#else
448	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
449	return rtSemRWRequestRead(hRWSem, cMillies, false, &SrcPos);
450	#endif
451	}
452	RT_EXPORT_SYMBOL(RTSemRWRequestRead);
453
454
455	RTDECL(int) RTSemRWRequestReadDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
456	{
457	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
458	return rtSemRWRequestRead(hRWSem, cMillies, false, &SrcPos);
459	}
460	RT_EXPORT_SYMBOL(RTSemRWRequestReadDebug);
461
462
463	RTDECL(int) RTSemRWRequestReadNoResume(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
464	{
465	#ifndef RTSEMRW_STRICT
466	return rtSemRWRequestRead(hRWSem, cMillies, true, NULL);
467	#else
468	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
469	return rtSemRWRequestRead(hRWSem, cMillies, true, &SrcPos);
470	#endif
471	}
472	RT_EXPORT_SYMBOL(RTSemRWRequestReadNoResume);
473
474
475	RTDECL(int) RTSemRWRequestReadNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
476	{
477	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
478	return rtSemRWRequestRead(hRWSem, cMillies, true, &SrcPos);
479	}
480	RT_EXPORT_SYMBOL(RTSemRWRequestReadNoResumeDebug);
481
482
483	RTDECL(int) RTSemRWReleaseRead(RTSEMRW hRWSem)
484	{
485	struct RTSEMRWINTERNAL *pThis = hRWSem;
486
487	/*
488	* Validate handle.
489	*/
490	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
491	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
492
493	/*
494	* Take critsect.
495	*/
496	int rc = RTCritSectEnter(&pThis->CritSect);
497	if (RT_SUCCESS(rc))
498	{
499	if (pThis->hWriter == NIL_RTNATIVETHREAD)
500	{
501	#ifdef RTSEMRW_STRICT
502	rc = RTLockValidatorRecSharedCheckAndRelease(&pThis->ValidatorRead, NIL_RTTHREAD);
503	if (RT_SUCCESS(rc))
504	#endif
505	{
506	if (RT_LIKELY(pThis->cReads > 0))
507	{
508	pThis->cReads--;
509
510	/* Kick off a writer if appropriate. */
511	if ( pThis->cWritesWaiting > 0
512	&& !pThis->cReads)
513	{
514	rc = RTSemEventSignal(pThis->WriteEvent);
515	AssertMsgRC(rc, ("Failed to signal writers on rwsem %p, rc=%Rrc\n", hRWSem, rc));
516	}
517	}
518	else
519	{
520	AssertFailed();
521	rc = VERR_NOT_OWNER;
522	}
523	}
524	}
525	else
526	{
527	RTNATIVETHREAD hNativeSelf = pThis->CritSect.NativeThreadOwner;
528	if (pThis->hWriter == hNativeSelf)
529	{
530	if (pThis->cWriterReads > 0)
531	{
532	#ifdef RTSEMRW_STRICT
533	rc = RTLockValidatorRecExclUnwindMixed(&pThis->ValidatorWrite, &pThis->ValidatorRead.Core);
534	if (RT_SUCCESS(rc))
535	#endif
536	{
537	pThis->cWriterReads--;
538	}
539	}
540	else
541	{
542	AssertFailed();
543	rc = VERR_NOT_OWNER;
544	}
545	}
546	else
547	{
548	AssertFailed();
549	rc = VERR_NOT_OWNER;
550	}
551	}
552
553	RTCritSectLeave(&pThis->CritSect);
554	}
555	else
556	AssertMsgFailed(("RTCritSectEnter failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
557
558	return rc;
559	}
560	RT_EXPORT_SYMBOL(RTSemRWReleaseRead);
561
562
563	DECL_FORCE_INLINE(int) rtSemRWRequestWrite(RTSEMRW hRWSem, RTMSINTERVAL cMillies, bool fInterruptible, PCRTLOCKVALSRCPOS pSrcPos)
564	{
565	/*
566	* Validate handle.
567	*/
568	struct RTSEMRWINTERNAL *pThis = hRWSem;
569	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
570	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
571
572	RTMSINTERVAL cMilliesInitial = cMillies;
573	uint64_t tsStart = 0;
574	if (cMillies != RT_INDEFINITE_WAIT && cMillies != 0)
575	tsStart = RTTimeNanoTS();
576
577	#ifdef RTSEMRW_STRICT
578	RTTHREAD hThreadSelf = NIL_RTTHREAD;
579	if (cMillies)
580	{
581	hThreadSelf = RTThreadSelfAutoAdopt();
582	int rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, cMillies);
583	if (RT_FAILURE(rc9))
584	return rc9;
585	}
586	#endif
587
588	/*
589	* Take critsect.
590	*/
591	int rc = RTCritSectEnter(&pThis->CritSect);
592	if (RT_FAILURE(rc))
593	{
594	AssertMsgFailed(("RTCritSectEnter failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
595	return rc;
596	}
597
598	/*
599	* Check if the state of affairs allows write access.
600	*/
601	RTNATIVETHREAD hNativeSelf = pThis->CritSect.NativeThreadOwner;
602	if ( !pThis->cReads
603	&& ( ( !pThis->cWrites
604	&& ( !pThis->cWritesWaiting /* play fair if we can wait */
605	\|\| !cMillies)
606	)
607	\|\| pThis->hWriter == hNativeSelf
608	)
609	)
610	{
611	/*
612	* Reset the reader event semaphore if necessary.
613	*/
614	if (pThis->fNeedResetReadEvent)
615	{
616	pThis->fNeedResetReadEvent = false;
617	rc = RTSemEventMultiReset(pThis->ReadEvent);
618	AssertMsgRC(rc, ("Failed to reset readers, rwsem %p, rc=%Rrc.\n", hRWSem, rc));
619	}
620
621	pThis->cWrites++;
622	pThis->hWriter = hNativeSelf;
623	#ifdef RTSEMRW_STRICT
624	RTLockValidatorRecExclSetOwner(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, pThis->cWrites == 1);
625	#endif
626	RTCritSectLeave(&pThis->CritSect);
627	return VINF_SUCCESS;
628	}
629
630	/*
631	* Signal writer presence.
632	*/
633	if (cMillies != 0)
634	pThis->cWritesWaiting++;
635
636	RTCritSectLeave(&pThis->CritSect);
637
638	/*
639	* Wait till it's ready for writing.
640	*/
641	if (cMillies == 0)
642	return VERR_TIMEOUT;
643
644	#ifndef RTSEMRW_STRICT
645	RTTHREAD hThreadSelf = RTThreadSelf();
646	#endif
647	for (;;)
648	{
649	if (cMillies != RT_INDEFINITE_WAIT)
650	{
651	int64_t tsDelta = RTTimeNanoTS() - tsStart;
652	if (tsDelta >= 1000000)
653	{
654	tsDelta /= 1000000;
655	if ((uint64_t)tsDelta < cMilliesInitial)
656	cMilliesInitial = (RTMSINTERVAL)tsDelta;
657	else
658	cMilliesInitial = 1;
659	}
660	}
661
662	#ifdef RTSEMRW_STRICT
663	rc = RTLockValidatorRecExclCheckBlocking(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true,
664	cMillies, RTTHREADSTATE_RW_WRITE, false);
665	if (RT_FAILURE(rc))
666	break;
667	#else
668	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_RW_WRITE, false);
669	RT_NOREF_PV(pSrcPos);
670	#endif
671	int rcWait;
672	if (fInterruptible)
673	rcWait = rc = RTSemEventWaitNoResume(pThis->WriteEvent, cMillies);
674	else
675	rcWait = rc = RTSemEventWait(pThis->WriteEvent, cMillies);
676	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_RW_WRITE);
677	if (RT_UNLIKELY(RT_FAILURE_NP(rc) && rc != VERR_TIMEOUT)) /* timeouts are handled below */
678	{
679	AssertMsgRC(rc, ("RTSemEventWait failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
680	break;
681	}
682
683	if (RT_UNLIKELY(pThis->u32Magic != RTSEMRW_MAGIC))
684	{
685	rc = VERR_SEM_DESTROYED;
686	break;
687	}
688
689	/*
690	* Re-take critsect and repeat the check we did prior to this loop.
691	*/
692	rc = RTCritSectEnter(&pThis->CritSect);
693	if (RT_FAILURE(rc))
694	{
695	AssertMsgFailed(("RTCritSectEnter failed on rwsem %p, rc=%Rrc\n", hRWSem, rc));
696	break;
697	}
698
699	if (!pThis->cReads && (!pThis->cWrites \|\| pThis->hWriter == hNativeSelf))
700	{
701	/*
702	* Reset the reader event semaphore if necessary.
703	*/
704	if (pThis->fNeedResetReadEvent)
705	{
706	pThis->fNeedResetReadEvent = false;
707	rc = RTSemEventMultiReset(pThis->ReadEvent);
708	AssertMsgRC(rc, ("Failed to reset readers, rwsem %p, rc=%Rrc.\n", hRWSem, rc));
709	}
710
711	pThis->cWrites++;
712	pThis->hWriter = hNativeSelf;
713	pThis->cWritesWaiting--;
714	#ifdef RTSEMRW_STRICT
715	RTLockValidatorRecExclSetOwner(&pThis->ValidatorWrite, hThreadSelf, pSrcPos, true);
716	#endif
717
718	RTCritSectLeave(&pThis->CritSect);
719	return VINF_SUCCESS;
720	}
721
722	RTCritSectLeave(&pThis->CritSect);
723
724	/*
725	* Quit if the wait already timed out.
726	*/
727	if (rcWait == VERR_TIMEOUT)
728	{
729	rc = VERR_TIMEOUT;
730	break;
731	}
732	}
733
734	/*
735	* Timeout/error case, clean up.
736	*/
737	if (pThis->u32Magic == RTSEMRW_MAGIC)
738	{
739	RTCritSectEnter(&pThis->CritSect);
740	/* Adjust this counter, whether we got the critsect or not. */
741	pThis->cWritesWaiting--;
742	RTCritSectLeave(&pThis->CritSect);
743	}
744	return rc;
745	}
746
747
748	RTDECL(int) RTSemRWRequestWrite(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
749	{
750	#ifndef RTSEMRW_STRICT
751	return rtSemRWRequestWrite(hRWSem, cMillies, false, NULL);
752	#else
753	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
754	return rtSemRWRequestWrite(hRWSem, cMillies, false, &SrcPos);
755	#endif
756	}
757	RT_EXPORT_SYMBOL(RTSemRWRequestWrite);
758
759
760	RTDECL(int) RTSemRWRequestWriteDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
761	{
762	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
763	return rtSemRWRequestWrite(hRWSem, cMillies, false, &SrcPos);
764	}
765	RT_EXPORT_SYMBOL(RTSemRWRequestWriteDebug);
766
767
768	RTDECL(int) RTSemRWRequestWriteNoResume(RTSEMRW hRWSem, RTMSINTERVAL cMillies)
769	{
770	#ifndef RTSEMRW_STRICT
771	return rtSemRWRequestWrite(hRWSem, cMillies, true, NULL);
772	#else
773	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
774	return rtSemRWRequestWrite(hRWSem, cMillies, true, &SrcPos);
775	#endif
776	}
777	RT_EXPORT_SYMBOL(RTSemRWRequestWriteNoResume);
778
779
780	RTDECL(int) RTSemRWRequestWriteNoResumeDebug(RTSEMRW hRWSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
781	{
782	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
783	return rtSemRWRequestWrite(hRWSem, cMillies, true, &SrcPos);
784	}
785	RT_EXPORT_SYMBOL(RTSemRWRequestWriteNoResumeDebug);
786
787
788	RTDECL(int) RTSemRWReleaseWrite(RTSEMRW hRWSem)
789	{
790
791	/*
792	* Validate handle.
793	*/
794	struct RTSEMRWINTERNAL *pThis = hRWSem;
795	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
796	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
797
798	/*
799	* Take critsect.
800	*/
801	int rc = RTCritSectEnter(&pThis->CritSect);
802	AssertRCReturn(rc, rc);
803
804	/*
805	* Check if owner.
806	*/
807	RTNATIVETHREAD hNativeSelf = pThis->CritSect.NativeThreadOwner;
808	if (pThis->hWriter != hNativeSelf)
809	{
810	RTCritSectLeave(&pThis->CritSect);
811	AssertMsgFailed(("Not read-write owner of rwsem %p.\n", hRWSem));
812	return VERR_NOT_OWNER;
813	}
814
815	#ifdef RTSEMRW_STRICT
816	if (pThis->cWrites > 1 \|\| !pThis->cWriterReads) /* don't check+release if VERR_WRONG_ORDER */
817	{
818	int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorWrite, pThis->cWrites == 1);
819	if (RT_FAILURE(rc9))
820	{
821	RTCritSectLeave(&pThis->CritSect);
822	return rc9;
823	}
824	}
825	#endif
826
827	/*
828	* Release ownership and remove ourselves from the writers count.
829	*/
830	Assert(pThis->cWrites > 0);
831	pThis->cWrites--;
832	if (!pThis->cWrites)
833	{
834	if (RT_UNLIKELY(pThis->cWriterReads > 0))
835	{
836	pThis->cWrites++;
837	RTCritSectLeave(&pThis->CritSect);
838	AssertMsgFailed(("All recursive read locks need to be released prior to the final write lock! (%p)n\n", pThis));
839	return VERR_WRONG_ORDER;
840	}
841
842	pThis->hWriter = NIL_RTNATIVETHREAD;
843	}
844
845	/*
846	* Release the readers if no more writers waiting, otherwise the writers.
847	*/
848	if (!pThis->cWritesWaiting)
849	{
850	rc = RTSemEventMultiSignal(pThis->ReadEvent);
851	AssertMsgRC(rc, ("RTSemEventMultiSignal failed for rwsem %p, rc=%Rrc.\n", hRWSem, rc));
852	pThis->fNeedResetReadEvent = true;
853	}
854	else
855	{
856	rc = RTSemEventSignal(pThis->WriteEvent);
857	AssertMsgRC(rc, ("Failed to signal writers on rwsem %p, rc=%Rrc\n", hRWSem, rc));
858	}
859	RTCritSectLeave(&pThis->CritSect);
860
861	return rc;
862	}
863	RT_EXPORT_SYMBOL(RTSemRWReleaseWrite);
864
865
866	RTDECL(bool) RTSemRWIsWriteOwner(RTSEMRW hRWSem)
867	{
868	/*
869	* Validate handle.
870	*/
871	struct RTSEMRWINTERNAL *pThis = hRWSem;
872	AssertPtrReturn(pThis, false);
873	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, false);
874
875	/*
876	* Check ownership.
877	*/
878	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
879	RTNATIVETHREAD hWriter;
880	ASMAtomicUoReadHandle(&pThis->hWriter, &hWriter);
881	return hWriter == hNativeSelf;
882	}
883	RT_EXPORT_SYMBOL(RTSemRWIsWriteOwner);
884
885
886	RTDECL(bool) RTSemRWIsReadOwner(RTSEMRW hRWSem, bool fWannaHear)
887	{
888	/*
889	* Validate handle.
890	*/
891	struct RTSEMRWINTERNAL *pThis = hRWSem;
892	AssertPtrReturn(pThis, false);
893	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, false);
894
895	/*
896	* Check write ownership. The writer is also a valid reader.
897	*/
898	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
899	RTNATIVETHREAD hWriter;
900	ASMAtomicUoReadHandle(&pThis->hWriter, &hWriter);
901	if (hWriter == hNativeSelf)
902	return true;
903	if (hWriter != NIL_RTNATIVETHREAD)
904	return false;
905
906	#ifdef RTSEMRW_STRICT
907	/*
908	* Ask the lock validator.
909	*/
910	NOREF(fWannaHear);
911	return RTLockValidatorRecSharedIsOwner(&pThis->ValidatorRead, NIL_RTTHREAD);
912	#else
913	/*
914	* If there are no reads we cannot be one of them... But if there are we
915	* cannot know and can only return what the caller want to hear.
916	*/
917	if (pThis->cReads == 0)
918	return false;
919	return fWannaHear;
920	#endif
921	}
922	RT_EXPORT_SYMBOL(RTSemRWIsReadOwner);
923
924
925	RTDECL(uint32_t) RTSemRWGetWriteRecursion(RTSEMRW hRWSem)
926	{
927	struct RTSEMRWINTERNAL *pThis = hRWSem;
928
929	/*
930	* Validate handle.
931	*/
932	AssertPtrReturn(pThis, 0);
933	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, 0);
934
935	/*
936	* Return the requested data.
937	*/
938	return pThis->cWrites;
939	}
940	RT_EXPORT_SYMBOL(RTSemRWGetWriteRecursion);
941
942
943	RTDECL(uint32_t) RTSemRWGetWriterReadRecursion(RTSEMRW hRWSem)
944	{
945	struct RTSEMRWINTERNAL *pThis = hRWSem;
946
947	/*
948	* Validate handle.
949	*/
950	AssertPtrReturn(pThis, 0);
951	AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, 0);
952
953	/*
954	* Return the requested data.
955	*/
956	return pThis->cWriterReads;
957	}
958	RT_EXPORT_SYMBOL(RTSemRWGetWriterReadRecursion);
959
960
961	RTDECL(uint32_t) RTSemRWGetReadCount(RTSEMRW hRWSem)
962	{
963	/*
964	* Validate input.
965	*/
966	struct RTSEMRWINTERNAL *pThis = hRWSem;
967	AssertPtrReturn(pThis, 0);
968	AssertMsgReturn(pThis->u32Magic == RTSEMRW_MAGIC,
969	("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
970	0);
971
972	/*
973	* Return the requested data.
974	*/
975	return pThis->cReads;
976	}
977	RT_EXPORT_SYMBOL(RTSemRWGetReadCount);
978

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

source: vbox/trunk/src/VBox/Runtime/generic/semrw-generic.cpp@ 92326

Download in other formats: