semeventmulti-r0drv-linux.c@ 78381

Last change on this file since 78381 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 11.5 KB

Line
1	/* $Id: semeventmulti-r0drv-linux.c 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* IPRT - Multiple Release Event Semaphores, Ring-0 Driver, Linux.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 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	* 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
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define RTSEMEVENTMULTI_WITHOUT_REMAPPING
32	#include "the-linux-kernel.h"
33	#include "internal/iprt.h"
34	#include <iprt/semaphore.h>
35
36	#include <iprt/assert.h>
37	#include <iprt/asm.h>
38	#include <iprt/err.h>
39	#include <iprt/mem.h>
40	#include <iprt/lockvalidator.h>
41
42	#include "waitqueue-r0drv-linux.h"
43	#include "internal/magics.h"
44
45
46	/*********************************************************************************************************************************
47	* Defined Constants And Macros *
48	*********************************************************************************************************************************/
49	/** @name fStateAndGen values
50	* @{ */
51	/** The state bit number. */
52	#define RTSEMEVENTMULTILNX_STATE_BIT 0
53	/** The state mask. */
54	#define RTSEMEVENTMULTILNX_STATE_MASK RT_BIT_32(RTSEMEVENTMULTILNX_STATE_BIT)
55	/** The generation mask. */
56	#define RTSEMEVENTMULTILNX_GEN_MASK ~RTSEMEVENTMULTILNX_STATE_MASK
57	/** The generation shift. */
58	#define RTSEMEVENTMULTILNX_GEN_SHIFT 1
59	/** The initial variable value. */
60	#define RTSEMEVENTMULTILNX_STATE_GEN_INIT UINT32_C(0xfffffffc)
61	/** @} */
62
63
64	/*********************************************************************************************************************************
65	* Structures and Typedefs *
66	*********************************************************************************************************************************/
67	/**
68	* Linux event semaphore.
69	*/
70	typedef struct RTSEMEVENTMULTIINTERNAL
71	{
72	/** Magic value (RTSEMEVENTMULTI_MAGIC). */
73	uint32_t volatile u32Magic;
74	/** The object state bit and generation counter.
75	* The generation counter is incremented every time the object is
76	* signalled. */
77	uint32_t volatile fStateAndGen;
78	/** Reference counter. */
79	uint32_t volatile cRefs;
80	/** The wait queue. */
81	wait_queue_head_t Head;
82	} RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL;
83
84
85
86
87
88	RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
89	{
90	return RTSemEventMultiCreateEx(phEventMultiSem, 0 /fFlags/, NIL_RTLOCKVALCLASS, NULL);
91	}
92
93
94	RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
95	const char *pszNameFmt, ...)
96	{
97	PRTSEMEVENTMULTIINTERNAL pThis;
98	IPRT_LINUX_SAVE_EFL_AC();
99	RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt);
100
101	AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
102	pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
103	if (pThis)
104	{
105	pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
106	pThis->fStateAndGen = RTSEMEVENTMULTILNX_STATE_GEN_INIT;
107	pThis->cRefs = 1;
108	init_waitqueue_head(&pThis->Head);
109
110	*phEventMultiSem = pThis;
111	IPRT_LINUX_RESTORE_EFL_AC();
112	return VINF_SUCCESS;
113	}
114	IPRT_LINUX_RESTORE_EFL_AC();
115	return VERR_NO_MEMORY;
116	}
117	RT_EXPORT_SYMBOL(RTSemEventMultiCreate);
118
119
120	/**
121	* Retain a reference to the semaphore.
122	*
123	* @param pThis The semaphore.
124	*/
125	DECLINLINE(void) rtR0SemEventMultiLnxRetain(PRTSEMEVENTMULTIINTERNAL pThis)
126	{
127	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
128	NOREF(cRefs);
129	Assert(cRefs && cRefs < 100000);
130	}
131
132
133	/**
134	* Release a reference, destroy the thing if necessary.
135	*
136	* @param pThis The semaphore.
137	*/
138	DECLINLINE(void) rtR0SemEventMultiLnxRelease(PRTSEMEVENTMULTIINTERNAL pThis)
139	{
140	if (RT_UNLIKELY(ASMAtomicDecU32(&pThis->cRefs) == 0))
141	{
142	Assert(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC);
143	RTMemFree(pThis);
144	}
145	}
146
147
148	RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
149	{
150	IPRT_LINUX_SAVE_EFL_AC();
151
152	/*
153	* Validate input.
154	*/
155	PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
156	if (pThis == NIL_RTSEMEVENTMULTI)
157	return VINF_SUCCESS;
158	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
159	AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
160	Assert(pThis->cRefs > 0);
161
162	/*
163	* Invalidate it and signal the object just in case.
164	*/
165	ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMEVENTMULTI_MAGIC);
166	ASMAtomicAndU32(&pThis->fStateAndGen, RTSEMEVENTMULTILNX_GEN_MASK);
167	Assert(!waitqueue_active(&pThis->Head));
168	wake_up_all(&pThis->Head);
169	rtR0SemEventMultiLnxRelease(pThis);
170
171	IPRT_LINUX_RESTORE_EFL_AC();
172	return VINF_SUCCESS;
173	}
174	RT_EXPORT_SYMBOL(RTSemEventMultiDestroy);
175
176
177	RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
178	{
179	IPRT_LINUX_SAVE_EFL_AC();
180	uint32_t fNew;
181	uint32_t fOld;
182
183	/*
184	* Validate input.
185	*/
186	PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
187	if (!pThis)
188	return VERR_INVALID_PARAMETER;
189	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
190	AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
191	rtR0SemEventMultiLnxRetain(pThis);
192
193	/*
194	* Signal the event object. The cause of the paranoia here is racing to try
195	* deal with racing RTSemEventMultiSignal calls (should probably be
196	* forbidden, but it's relatively easy to handle).
197	*/
198	do
199	{
200	fNew = fOld = ASMAtomicUoReadU32(&pThis->fStateAndGen);
201	fNew += 1 << RTSEMEVENTMULTILNX_GEN_SHIFT;
202	fNew \|= RTSEMEVENTMULTILNX_STATE_MASK;
203	}
204	while (!ASMAtomicCmpXchgU32(&pThis->fStateAndGen, fNew, fOld));
205
206	wake_up_all(&pThis->Head);
207
208	rtR0SemEventMultiLnxRelease(pThis);
209	IPRT_LINUX_RESTORE_EFL_AC();
210	return VINF_SUCCESS;
211	}
212	RT_EXPORT_SYMBOL(RTSemEventMultiSignal);
213
214
215	RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
216	{
217	/*
218	* Validate input.
219	*/
220	PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
221	if (!pThis)
222	return VERR_INVALID_PARAMETER;
223	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
224	AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
225	rtR0SemEventMultiLnxRetain(pThis);
226
227	/*
228	* Reset it.
229	*/
230	ASMAtomicAndU32(&pThis->fStateAndGen, ~RTSEMEVENTMULTILNX_STATE_MASK);
231
232	rtR0SemEventMultiLnxRelease(pThis);
233	return VINF_SUCCESS;
234	}
235	RT_EXPORT_SYMBOL(RTSemEventMultiReset);
236
237
238	/**
239	* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
240	*
241	* @returns VBox status code.
242	* @param pThis The event semaphore.
243	* @param fFlags See RTSemEventMultiWaitEx.
244	* @param uTimeout See RTSemEventMultiWaitEx.
245	* @param pSrcPos The source code position of the wait.
246	*/
247	static int rtR0SemEventMultiLnxWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
248	PCRTLOCKVALSRCPOS pSrcPos)
249	{
250	uint32_t fOrgStateAndGen;
251	int rc;
252	RT_NOREF_PV(pSrcPos);
253
254	/*
255	* Validate the input.
256	*/
257	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
258	AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
259	AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
260	rtR0SemEventMultiLnxRetain(pThis);
261
262	/*
263	* Is the event already signalled or do we have to wait?
264	*/
265	fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
266	if (fOrgStateAndGen & RTSEMEVENTMULTILNX_STATE_MASK)
267	rc = VINF_SUCCESS;
268	else
269	{
270	/*
271	* We have to wait.
272	*/
273	RTR0SEMLNXWAIT Wait;
274	IPRT_LINUX_SAVE_EFL_AC();
275	rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
276	if (RT_SUCCESS(rc))
277	{
278	IPRT_DEBUG_SEMS_STATE(pThis, 'E');
279	for (;;)
280	{
281	/* The destruction test. */
282	if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
283	rc = VERR_SEM_DESTROYED;
284	else
285	{
286	rtR0SemLnxWaitPrepare(&Wait);
287
288	/* Check the exit conditions. */
289	if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
290	rc = VERR_SEM_DESTROYED;
291	else if (ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen)
292	rc = VINF_SUCCESS;
293	else if (rtR0SemLnxWaitHasTimedOut(&Wait))
294	rc = VERR_TIMEOUT;
295	else if (rtR0SemLnxWaitWasInterrupted(&Wait))
296	rc = VERR_INTERRUPTED;
297	else
298	{
299	/* Do the wait and then recheck the conditions. */
300	rtR0SemLnxWaitDoIt(&Wait);
301	continue;
302	}
303	}
304	break;
305	}
306
307	rtR0SemLnxWaitDelete(&Wait);
308	IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
309	}
310	IPRT_LINUX_RESTORE_EFL_AC();
311	}
312
313	rtR0SemEventMultiLnxRelease(pThis);
314	return rc;
315	}
316
317
318	RTDECL(int) RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
319	{
320	#ifndef RTSEMEVENT_STRICT
321	return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, NULL);
322	#else
323	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
324	return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
325	#endif
326	}
327	RT_EXPORT_SYMBOL(RTSemEventMultiWaitEx);
328
329
330	RTDECL(int) RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
331	RTHCUINTPTR uId, RT_SRC_POS_DECL)
332	{
333	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
334	return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
335	}
336	RT_EXPORT_SYMBOL(RTSemEventMultiWaitExDebug);
337
338
339	RTDECL(uint32_t) RTSemEventMultiGetResolution(void)
340	{
341	return rtR0SemLnxWaitGetResolution();
342	}
343	RT_EXPORT_SYMBOL(RTSemEventMultiGetResolution);
344

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

source: vbox/trunk/src/VBox/Runtime/r0drv/linux/semeventmulti-r0drv-linux.c@ 78381

Download in other formats: