semevent-linux.cpp@ 90330

Last change on this file since 90330 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: 12.6 KB

Line
1	/* $Id: semevent-linux.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* IPRT - Event Semaphore, Linux (2.6.x+).
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	#include <features.h>
28	#if __GLIBC_PREREQ(2,6) && !defined(IPRT_WITH_FUTEX_BASED_SEMS)
29
30	/*
31	* glibc 2.6 fixed a serious bug in the mutex implementation. We wrote this
32	* linux specific event semaphores code in order to work around the bug. We
33	* will fall back on the pthread-based implementation if glibc is known to
34	* contain the bug fix.
35	*
36	* The external reference to epoll_pwait is a hack which prevents that we link
37	* against glibc < 2.6.
38	*/
39	#include "../posix/semevent-posix.cpp"
40	__asm__ (".global epoll_pwait");
41
42	#else /* glibc < 2.6 */
43
44
45	/*********************************************************************************************************************************
46	* Header Files *
47	*********************************************************************************************************************************/
48	#include <iprt/semaphore.h>
49	#include "internal/iprt.h"
50
51	#include <iprt/asm.h>
52	#include <iprt/assert.h>
53	#include <iprt/err.h>
54	#include <iprt/lockvalidator.h>
55	#include <iprt/mem.h>
56	#include <iprt/time.h>
57	#include "internal/magics.h"
58	#include "internal/mem.h"
59	#include "internal/strict.h"
60
61	#include <errno.h>
62	#include <limits.h>
63	#include <pthread.h>
64	#include <unistd.h>
65	#include <sys/time.h>
66	#include <sys/syscall.h>
67	#if 0 /* With 2.6.17 futex.h has become C++ unfriendly. */
68	# include <linux/futex.h>
69	#else
70	# define FUTEX_WAIT 0
71	# define FUTEX_WAKE 1
72	#endif
73
74
75	/*********************************************************************************************************************************
76	* Structures and Typedefs *
77	*********************************************************************************************************************************/
78	/**
79	* Linux (single wakup) event semaphore.
80	*/
81	struct RTSEMEVENTINTERNAL
82	{
83	/** Magic value. */
84	intptr_t volatile iMagic;
85	/** The futex state variable.
86	* 0 means not signalled.
87	1 means signalled. */
88	uint32_t volatile fSignalled;
89	/** The number of waiting threads */
90	int32_t volatile cWaiters;
91	#ifdef RTSEMEVENT_STRICT
92	/** Signallers. */
93	RTLOCKVALRECSHRD Signallers;
94	/** Indicates that lock validation should be performed. */
95	bool volatile fEverHadSignallers;
96	#endif
97	/** The creation flags. */
98	uint32_t fFlags;
99	};
100
101
102	/**
103	* Wrapper for the futex syscall.
104	*/
105	static long sys_futex(uint32_t volatile uaddr, int op, int val, struct timespec utime, int32_t *uaddr2, int val3)
106	{
107	errno = 0;
108	long rc = syscall(__NR_futex, uaddr, op, val, utime, uaddr2, val3);
109	if (rc < 0)
110	{
111	Assert(rc == -1);
112	rc = -errno;
113	}
114	return rc;
115	}
116
117
118
119	RTDECL(int) RTSemEventCreate(PRTSEMEVENT phEventSem)
120	{
121	return RTSemEventCreateEx(phEventSem, 0 /fFlags/, NIL_RTLOCKVALCLASS, NULL);
122	}
123
124
125	RTDECL(int) RTSemEventCreateEx(PRTSEMEVENT phEventSem, uint32_t fFlags, RTLOCKVALCLASS hClass, const char *pszNameFmt, ...)
126	{
127	AssertReturn(!(fFlags & ~(RTSEMEVENT_FLAGS_NO_LOCK_VAL \| RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)), VERR_INVALID_PARAMETER);
128	Assert(!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK) \|\| (fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL));
129
130	/*
131	* Allocate semaphore handle.
132	*/
133	struct RTSEMEVENTINTERNAL *pThis;
134	if (!(fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
135	pThis = (struct RTSEMEVENTINTERNAL *)RTMemAlloc(sizeof(struct RTSEMEVENTINTERNAL));
136	else
137	pThis = (struct RTSEMEVENTINTERNAL *)rtMemBaseAlloc(sizeof(struct RTSEMEVENTINTERNAL));
138	if (pThis)
139	{
140	pThis->iMagic = RTSEMEVENT_MAGIC;
141	pThis->cWaiters = 0;
142	pThis->fSignalled = 0;
143	pThis->fFlags = fFlags;
144	#ifdef RTSEMEVENT_STRICT
145	if (!pszNameFmt)
146	{
147	static uint32_t volatile s_iSemEventAnon = 0;
148	RTLockValidatorRecSharedInit(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
149	true /fSignaller/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL),
150	"RTSemEvent-%u", ASMAtomicIncU32(&s_iSemEventAnon) - 1);
151	}
152	else
153	{
154	va_list va;
155	va_start(va, pszNameFmt);
156	RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis,
157	true /fSignaller/, !(fFlags & RTSEMEVENT_FLAGS_NO_LOCK_VAL),
158	pszNameFmt, va);
159	va_end(va);
160	}
161	pThis->fEverHadSignallers = false;
162	#else
163	RT_NOREF(hClass, pszNameFmt);
164	#endif
165
166	*phEventSem = pThis;
167	return VINF_SUCCESS;
168	}
169	return VERR_NO_MEMORY;
170	}
171
172
173	RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem)
174	{
175	/*
176	* Validate input.
177	*/
178	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
179	if (pThis == NIL_RTSEMEVENT)
180	return VINF_SUCCESS;
181	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
182	AssertReturn(pThis->iMagic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE);
183
184	/*
185	* Invalidate the semaphore and wake up anyone waiting on it.
186	*/
187	ASMAtomicXchgSize(&pThis->iMagic, RTSEMEVENT_MAGIC \| UINT32_C(0x80000000));
188	if (ASMAtomicXchgS32(&pThis->cWaiters, INT32_MIN / 2) > 0)
189	{
190	sys_futex(&pThis->fSignalled, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
191	usleep(1000);
192	}
193
194	/*
195	* Free the semaphore memory and be gone.
196	*/
197	#ifdef RTSEMEVENT_STRICT
198	RTLockValidatorRecSharedDelete(&pThis->Signallers);
199	#endif
200	if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
201	RTMemFree(pThis);
202	else
203	rtMemBaseFree(pThis);
204	return VINF_SUCCESS;
205	}
206
207
208	RTDECL(int) RTSemEventSignal(RTSEMEVENT hEventSem)
209	{
210	/*
211	* Validate input.
212	*/
213	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
214	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
215	AssertReturn(pThis->iMagic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE);
216
217	#ifdef RTSEMEVENT_STRICT
218	if (pThis->fEverHadSignallers)
219	{
220	int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD);
221	if (RT_FAILURE(rc9))
222	return rc9;
223	}
224	#endif
225
226	ASMAtomicWriteU32(&pThis->fSignalled, 1);
227	if (ASMAtomicReadS32(&pThis->cWaiters) < 1)
228	return VINF_SUCCESS;
229
230	/* somebody is waiting, try wake up one of them. */
231	long cWoken = sys_futex(&pThis->fSignalled, FUTEX_WAKE, 1, NULL, NULL, 0);
232	if (RT_LIKELY(cWoken >= 0))
233	return VINF_SUCCESS;
234
235	if (RT_UNLIKELY(pThis->iMagic != RTSEMEVENT_MAGIC))
236	return VERR_SEM_DESTROYED;
237
238	return VERR_INVALID_PARAMETER;
239	}
240
241
242	static int rtSemEventWait(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies, bool fAutoResume)
243	{
244	#ifdef RTSEMEVENT_STRICT
245	PCRTLOCKVALSRCPOS pSrcPos = NULL;
246	#endif
247
248	/*
249	* Validate input.
250	*/
251	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
252	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
253	AssertReturn(pThis->iMagic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE);
254
255	/*
256	* Quickly check whether it's signaled.
257	*/
258	/** @todo this isn't fair if someone is already waiting on it. They should
259	* have the first go at it!
260	* (ASMAtomicReadS32(&pThis->cWaiters) == 0 \|\| !cMillies) && ... */
261	if (ASMAtomicCmpXchgU32(&pThis->fSignalled, 0, 1))
262	return VINF_SUCCESS;
263
264	/*
265	* Convert the timeout value.
266	*/
267	struct timespec ts;
268	struct timespec *pTimeout = NULL;
269	uint64_t u64End = 0; /* shut up gcc */
270	if (cMillies != RT_INDEFINITE_WAIT)
271	{
272	if (!cMillies)
273	return VERR_TIMEOUT;
274	ts.tv_sec = cMillies / 1000;
275	ts.tv_nsec = (cMillies % 1000) * UINT32_C(1000000);
276	u64End = RTTimeSystemNanoTS() + cMillies * UINT64_C(1000000);
277	pTimeout = &ts;
278	}
279
280	ASMAtomicIncS32(&pThis->cWaiters);
281
282	/*
283	* The wait loop.
284	*/
285	#ifdef RTSEMEVENT_STRICT
286	RTTHREAD hThreadSelf = !(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK)
287	? RTThreadSelfAutoAdopt()
288	: RTThreadSelf();
289	#else
290	RTTHREAD hThreadSelf = RTThreadSelf();
291	#endif
292	int rc = VINF_SUCCESS;
293	for (;;)
294	{
295	#ifdef RTSEMEVENT_STRICT
296	if (pThis->fEverHadSignallers)
297	{
298	rc = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false,
299	cMillies, RTTHREADSTATE_EVENT, true);
300	if (RT_FAILURE(rc))
301	break;
302	}
303	#endif
304	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT, true);
305	long lrc = sys_futex(&pThis->fSignalled, FUTEX_WAIT, 0, pTimeout, NULL, 0);
306	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT);
307	if (RT_UNLIKELY(pThis->iMagic != RTSEMEVENT_MAGIC))
308	{
309	rc = VERR_SEM_DESTROYED;
310	break;
311	}
312
313	if (RT_LIKELY(lrc == 0 \|\| lrc == -EWOULDBLOCK))
314	{
315	/* successful wakeup or fSignalled > 0 in the meantime */
316	if (ASMAtomicCmpXchgU32(&pThis->fSignalled, 0, 1))
317	break;
318	}
319	else if (lrc == -ETIMEDOUT)
320	{
321	rc = VERR_TIMEOUT;
322	break;
323	}
324	else if (lrc == -EINTR)
325	{
326	if (!fAutoResume)
327	{
328	rc = VERR_INTERRUPTED;
329	break;
330	}
331	}
332	else
333	{
334	/* this shouldn't happen! */
335	AssertMsgFailed(("rc=%ld errno=%d\n", lrc, errno));
336	rc = RTErrConvertFromErrno(lrc);
337	break;
338	}
339	/* adjust the relative timeout */
340	if (pTimeout)
341	{
342	int64_t i64Diff = u64End - RTTimeSystemNanoTS();
343	if (i64Diff < 1000)
344	{
345	rc = VERR_TIMEOUT;
346	break;
347	}
348	ts.tv_sec = (uint64_t)i64Diff / UINT32_C(1000000000);
349	ts.tv_nsec = (uint64_t)i64Diff % UINT32_C(1000000000);
350	}
351	}
352
353	ASMAtomicDecS32(&pThis->cWaiters);
354	return rc;
355	}
356
357
358	RTDECL(int) RTSemEventWait(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies)
359	{
360	int rc = rtSemEventWait(hEventSem, cMillies, true);
361	Assert(rc != VERR_INTERRUPTED);
362	Assert(rc != VERR_TIMEOUT \|\| cMillies != RT_INDEFINITE_WAIT);
363	return rc;
364	}
365
366
367	RTDECL(int) RTSemEventWaitNoResume(RTSEMEVENT hEventSem, RTMSINTERVAL cMillies)
368	{
369	return rtSemEventWait(hEventSem, cMillies, false);
370	}
371
372
373	RTDECL(void) RTSemEventSetSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
374	{
375	#ifdef RTSEMEVENT_STRICT
376	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
377	AssertPtrReturnVoid(pThis);
378	AssertReturnVoid(pThis->iMagic == RTSEMEVENT_MAGIC);
379
380	ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
381	RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL);
382	#else
383	RT_NOREF(hEventSem, hThread);
384	#endif
385	}
386
387
388	RTDECL(void) RTSemEventAddSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
389	{
390	#ifdef RTSEMEVENT_STRICT
391	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
392	AssertPtrReturnVoid(pThis);
393	AssertReturnVoid(pThis->iMagic == RTSEMEVENT_MAGIC);
394
395	ASMAtomicWriteBool(&pThis->fEverHadSignallers, true);
396	RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL);
397	#else
398	RT_NOREF(hEventSem, hThread);
399	#endif
400	}
401
402
403	RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread)
404	{
405	#ifdef RTSEMEVENT_STRICT
406	struct RTSEMEVENTINTERNAL *pThis = hEventSem;
407	AssertPtrReturnVoid(pThis);
408	AssertReturnVoid(pThis->iMagic == RTSEMEVENT_MAGIC);
409
410	RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread);
411	#else
412	RT_NOREF(hEventSem, hThread);
413	#endif
414	}
415
416	#endif /* glibc < 2.6 \|\| IPRT_WITH_FUTEX_BASED_SEMS */
417

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

source: vbox/trunk/src/VBox/Runtime/r3/linux/semevent-linux.cpp@ 90330

Download in other formats: