semmutex-linux.cpp@ 46941

Last change on this file since 46941 was 44528, checked in by vboxsync, 12 years ago
header (C) fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 13.5 KB

Line
1	/* $Id: semmutex-linux.cpp 44528 2013-02-04 14:27:54Z vboxsync $ */
2	/** @file
3	* IPRT - Mutex Semaphore, Linux (2.6.x+).
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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	* Header Files *
29	*******************************************************************************/
30	#include <iprt/semaphore.h>
31	#include "internal/iprt.h"
32
33	#include <iprt/alloc.h>
34	#include <iprt/asm.h>
35	#include <iprt/assert.h>
36	#include <iprt/err.h>
37	#include <iprt/lockvalidator.h>
38	#include <iprt/thread.h>
39	#include <iprt/time.h>
40	#include "internal/magics.h"
41	#include "internal/strict.h"
42
43	#include <errno.h>
44	#include <limits.h>
45	#include <pthread.h>
46	#include <unistd.h>
47	#include <sys/time.h>
48	#include <sys/syscall.h>
49	#if 0 /* With 2.6.17 futex.h has become C++ unfriendly. */
50	# include <linux/futex.h>
51	#else
52	# define FUTEX_WAIT 0
53	# define FUTEX_WAKE 1
54	#endif
55
56
57	/*******************************************************************************
58	* Structures and Typedefs *
59	*******************************************************************************/
60	/**
61	* Linux internal representation of a Mutex semaphore.
62	*/
63	struct RTSEMMUTEXINTERNAL
64	{
65	/** The futex state variable.
66	* 0 means unlocked.
67	* 1 means locked, no waiters.
68	* 2 means locked, one or more waiters.
69	*/
70	int32_t volatile iState;
71	/** Nesting count. */
72	uint32_t volatile cNestings;
73	/** The owner of the mutex. */
74	pthread_t volatile Owner;
75	/** Magic value (RTSEMMUTEX_MAGIC). */
76	uint32_t volatile u32Magic;
77	#ifdef RTSEMMUTEX_STRICT
78	/** Lock validator record associated with this mutex. */
79	RTLOCKVALRECEXCL ValidatorRec;
80	#endif
81	};
82
83
84
85	/**
86	* Wrapper for the futex syscall.
87	*/
88	static long sys_futex(int32_t volatile uaddr, int op, int val, struct timespec utime, int32_t *uaddr2, int val3)
89	{
90	errno = 0;
91	long rc = syscall(__NR_futex, uaddr, op, val, utime, uaddr2, val3);
92	if (rc < 0)
93	{
94	Assert(rc == -1);
95	rc = -errno;
96	}
97	return rc;
98	}
99
100
101	#undef RTSemMutexCreate
102	RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phMutexSem)
103	{
104	return RTSemMutexCreateEx(phMutexSem, 0 /fFlags/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
105	}
106
107
108	RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags,
109	RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
110	{
111	AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
112
113	/*
114	* Allocate semaphore handle.
115	*/
116	struct RTSEMMUTEXINTERNAL pThis = (struct RTSEMMUTEXINTERNAL )RTMemAlloc(sizeof(struct RTSEMMUTEXINTERNAL));
117	if (pThis)
118	{
119	pThis->u32Magic = RTSEMMUTEX_MAGIC;
120	pThis->iState = 0;
121	pThis->Owner = (pthread_t)~0;
122	pThis->cNestings = 0;
123	#ifdef RTSEMMUTEX_STRICT
124	if (!pszNameFmt)
125	{
126	static uint32_t volatile s_iMutexAnon = 0;
127	RTLockValidatorRecExclInit(&pThis->ValidatorRec, hClass, uSubClass, pThis,
128	!(fFlags & RTSEMMUTEX_FLAGS_NO_LOCK_VAL),
129	"RTSemMutex-%u", ASMAtomicIncU32(&s_iMutexAnon) - 1);
130	}
131	else
132	{
133	va_list va;
134	va_start(va, pszNameFmt);
135	RTLockValidatorRecExclInitV(&pThis->ValidatorRec, hClass, uSubClass, pThis,
136	!(fFlags & RTSEMMUTEX_FLAGS_NO_LOCK_VAL), pszNameFmt, va);
137	va_end(va);
138	}
139	#endif
140
141	*phMutexSem = pThis;
142	return VINF_SUCCESS;
143	}
144
145	return VERR_NO_MEMORY;
146	}
147
148
149	RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hMutexSem)
150	{
151	/*
152	* Validate input.
153	*/
154	if (hMutexSem == NIL_RTSEMMUTEX)
155	return VINF_SUCCESS;
156	struct RTSEMMUTEXINTERNAL *pThis = hMutexSem;
157	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
158	AssertMsgReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC,
159	("hMutexSem=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
160	VERR_INVALID_HANDLE);
161
162	/*
163	* Invalidate the semaphore and wake up anyone waiting on it.
164	*/
165	ASMAtomicWriteU32(&pThis->u32Magic, RTSEMMUTEX_MAGIC_DEAD);
166	if (ASMAtomicXchgS32(&pThis->iState, 0) > 0)
167	{
168	sys_futex(&pThis->iState, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
169	usleep(1000);
170	}
171	pThis->Owner = (pthread_t)~0;
172	pThis->cNestings = 0;
173	#ifdef RTSEMMUTEX_STRICT
174	RTLockValidatorRecExclDelete(&pThis->ValidatorRec);
175	#endif
176
177	/*
178	* Free the semaphore memory and be gone.
179	*/
180	RTMemFree(pThis);
181	return VINF_SUCCESS;
182	}
183
184
185	RTDECL(uint32_t) RTSemMutexSetSubClass(RTSEMMUTEX hMutexSem, uint32_t uSubClass)
186	{
187	#ifdef RTSEMMUTEX_STRICT
188	/*
189	* Validate.
190	*/
191	RTSEMMUTEXINTERNAL *pThis = hMutexSem;
192	AssertPtrReturn(pThis, RTLOCKVAL_SUB_CLASS_INVALID);
193	AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, RTLOCKVAL_SUB_CLASS_INVALID);
194
195	return RTLockValidatorRecExclSetSubClass(&pThis->ValidatorRec, uSubClass);
196	#else
197	return RTLOCKVAL_SUB_CLASS_INVALID;
198	#endif
199	}
200
201
202	DECL_FORCE_INLINE(int) rtSemMutexRequest(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, bool fAutoResume, PCRTLOCKVALSRCPOS pSrcPos)
203	{
204	/*
205	* Validate input.
206	*/
207	struct RTSEMMUTEXINTERNAL *pThis = hMutexSem;
208	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
209	AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
210
211	/*
212	* Check if nested request.
213	*/
214	pthread_t Self = pthread_self();
215	if ( pThis->Owner == Self
216	&& pThis->cNestings > 0)
217	{
218	#ifdef RTSEMMUTEX_STRICT
219	int rc9 = RTLockValidatorRecExclRecursion(&pThis->ValidatorRec, pSrcPos);
220	if (RT_FAILURE(rc9))
221	return rc9;
222	#endif
223	ASMAtomicIncU32(&pThis->cNestings);
224	return VINF_SUCCESS;
225	}
226
227	#ifdef RTSEMMUTEX_STRICT
228	RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
229	if (cMillies)
230	{
231	int rc9 = RTLockValidatorRecExclCheckOrder(&pThis->ValidatorRec, hThreadSelf, pSrcPos, cMillies);
232	if (RT_FAILURE(rc9))
233	return rc9;
234	}
235	#else
236	RTTHREAD hThreadSelf = RTThreadSelf();
237	#endif
238
239	/*
240	* Convert timeout value.
241	*/
242	struct timespec ts;
243	struct timespec *pTimeout = NULL;
244	uint64_t u64End = 0; /* shut up gcc */
245	if (cMillies != RT_INDEFINITE_WAIT)
246	{
247	ts.tv_sec = cMillies / 1000;
248	ts.tv_nsec = (cMillies % 1000) * UINT32_C(1000000);
249	u64End = RTTimeSystemNanoTS() + cMillies * UINT64_C(1000000);
250	pTimeout = &ts;
251	}
252
253	/*
254	* Lock the mutex.
255	* Optimize for the uncontended case (makes 1-2 ns difference).
256	*/
257	if (RT_UNLIKELY(!ASMAtomicCmpXchgS32(&pThis->iState, 1, 0)))
258	{
259	for (;;)
260	{
261	int32_t iOld = ASMAtomicXchgS32(&pThis->iState, 2);
262
263	/*
264	* Was the lock released in the meantime? This is unlikely (but possible)
265	*/
266	if (RT_UNLIKELY(iOld == 0))
267	break;
268
269	/*
270	* Go to sleep.
271	*/
272	if (pTimeout && ( pTimeout->tv_sec \|\| pTimeout->tv_nsec ))
273	{
274	#ifdef RTSEMMUTEX_STRICT
275	int rc9 = RTLockValidatorRecExclCheckBlocking(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true,
276	cMillies, RTTHREADSTATE_MUTEX, true);
277	if (RT_FAILURE(rc9))
278	return rc9;
279	#else
280	RTThreadBlocking(hThreadSelf, RTTHREADSTATE_MUTEX, true);
281	#endif
282	}
283
284	long rc = sys_futex(&pThis->iState, FUTEX_WAIT, 2, pTimeout, NULL, 0);
285
286	RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_MUTEX);
287	if (RT_UNLIKELY(pThis->u32Magic != RTSEMMUTEX_MAGIC))
288	return VERR_SEM_DESTROYED;
289
290	/*
291	* Act on the wakup code.
292	*/
293	if (rc == -ETIMEDOUT)
294	{
295	Assert(pTimeout);
296	return VERR_TIMEOUT;
297	}
298	if (rc == 0)
299	/* we'll leave the loop now unless another thread is faster */;
300	else if (rc == -EWOULDBLOCK)
301	/* retry with new value. */;
302	else if (rc == -EINTR)
303	{
304	if (!fAutoResume)
305	return VERR_INTERRUPTED;
306	}
307	else
308	{
309	/* this shouldn't happen! */
310	AssertMsgFailed(("rc=%ld errno=%d\n", rc, errno));
311	return RTErrConvertFromErrno(rc);
312	}
313
314	/* adjust the relative timeout */
315	if (pTimeout)
316	{
317	int64_t i64Diff = u64End - RTTimeSystemNanoTS();
318	if (i64Diff < 1000)
319	{
320	rc = VERR_TIMEOUT;
321	break;
322	}
323	ts.tv_sec = (uint64_t)i64Diff / UINT32_C(1000000000);
324	ts.tv_nsec = (uint64_t)i64Diff % UINT32_C(1000000000);
325	}
326	}
327
328	/*
329	* When leaving this loop, iState is set to 2. This means that we gained the
330	* lock and there are _possibly_ some waiters. We don't know exactly as another
331	* thread might entered this loop at nearly the same time. Therefore we will
332	* call futex_wakeup once too often (if _no_ other thread entered this loop).
333	* The key problem is the simple futex_wait test for x != y (iState != 2) in
334	* our case).
335	*/
336	}
337
338	/*
339	* Set the owner and nesting.
340	*/
341	pThis->Owner = Self;
342	ASMAtomicWriteU32(&pThis->cNestings, 1);
343	#ifdef RTSEMMUTEX_STRICT
344	RTLockValidatorRecExclSetOwner(&pThis->ValidatorRec, hThreadSelf, pSrcPos, true);
345	#endif
346	return VINF_SUCCESS;
347	}
348
349
350	#undef RTSemMutexRequest
351	RTDECL(int) RTSemMutexRequest(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies)
352	{
353	#ifndef RTSEMMUTEX_STRICT
354	int rc = rtSemMutexRequest(hMutexSem, cMillies, true, NULL);
355	#else
356	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
357	int rc = rtSemMutexRequest(hMutexSem, cMillies, true, &SrcPos);
358	#endif
359	Assert(rc != VERR_INTERRUPTED);
360	return rc;
361	}
362
363
364	RTDECL(int) RTSemMutexRequestDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
365	{
366	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
367	int rc = rtSemMutexRequest(hMutexSem, cMillies, true, &SrcPos);
368	Assert(rc != VERR_INTERRUPTED);
369	return rc;
370	}
371
372
373	#undef RTSemMutexRequestNoResume
374	RTDECL(int) RTSemMutexRequestNoResume(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies)
375	{
376	#ifndef RTSEMMUTEX_STRICT
377	return rtSemMutexRequest(hMutexSem, cMillies, false, NULL);
378	#else
379	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
380	return rtSemMutexRequest(hMutexSem, cMillies, false, &SrcPos);
381	#endif
382	}
383
384
385	RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
386	{
387	RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
388	return rtSemMutexRequest(hMutexSem, cMillies, false, &SrcPos);
389	}
390
391
392	RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
393	{
394	/*
395	* Validate input.
396	*/
397	struct RTSEMMUTEXINTERNAL *pThis = hMutexSem;
398	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
399	AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
400
401	#ifdef RTSEMMUTEX_STRICT
402	int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, pThis->cNestings == 1);
403	if (RT_FAILURE(rc9))
404	return rc9;
405	#endif
406
407	/*
408	* Check if nested.
409	*/
410	pthread_t Self = pthread_self();
411	if (RT_UNLIKELY( pThis->Owner != Self
412	\|\| pThis->cNestings == 0))
413	{
414	AssertMsgFailed(("Not owner of mutex %p!! Self=%08x Owner=%08x cNestings=%d\n",
415	pThis, Self, pThis->Owner, pThis->cNestings));
416	return VERR_NOT_OWNER;
417	}
418
419	/*
420	* If nested we'll just pop a nesting.
421	*/
422	if (pThis->cNestings > 1)
423	{
424	ASMAtomicDecU32(&pThis->cNestings);
425	return VINF_SUCCESS;
426	}
427
428	/*
429	* Clear the state. (cNestings == 1)
430	*/
431	pThis->Owner = (pthread_t)~0;
432	ASMAtomicWriteU32(&pThis->cNestings, 0);
433
434	/*
435	* Release the mutex.
436	*/
437	int32_t iNew = ASMAtomicDecS32(&pThis->iState);
438	if (RT_UNLIKELY(iNew != 0))
439	{
440	/* somebody is waiting, try wake up one of them. */
441	ASMAtomicXchgS32(&pThis->iState, 0);
442	(void)sys_futex(&pThis->iState, FUTEX_WAKE, 1, NULL, NULL, 0);
443	}
444	return VINF_SUCCESS;
445	}
446
447
448	RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutexSem)
449	{
450	/*
451	* Validate.
452	*/
453	RTSEMMUTEXINTERNAL *pThis = hMutexSem;
454	AssertPtrReturn(pThis, false);
455	AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, false);
456
457	return pThis->Owner != (pthread_t)~0;
458	}
459

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

source: vbox/trunk/src/VBox/Runtime/r3/linux/semmutex-linux.cpp@ 46941

Download in other formats: