VirtualBox

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

Last change on this file since 25685 was 25685, checked in by vboxsync, 15 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette