VirtualBox

source: vbox/trunk/src/VBox/Runtime/r0drv/darwin/semmutex-r0drv-darwin.cpp@ 34536

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

darwin+asm.h build fixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 11.4 KB
Line 
1/* $Id: semmutex-r0drv-darwin.cpp 29255 2010-05-09 18:11:24Z vboxsync $ */
2/** @file
3 * IPRT - Mutex Semaphores, Ring-0 Driver, Darwin.
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/*******************************************************************************
29* Header Files *
30*******************************************************************************/
31#include "the-darwin-kernel.h"
32#include "internal/iprt.h"
33#include <iprt/semaphore.h>
34
35#include <iprt/asm.h>
36#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
37# include <iprt/asm-amd64-x86.h>
38#endif
39#include <iprt/assert.h>
40#include <iprt/err.h>
41#include <iprt/mem.h>
42#include <iprt/thread.h>
43
44#include "internal/magics.h"
45
46
47/*******************************************************************************
48* Structures and Typedefs *
49*******************************************************************************/
50/**
51 * Darwin mutex semaphore.
52 */
53typedef struct RTSEMMUTEXINTERNAL
54{
55 /** Magic value (RTSEMMUTEX_MAGIC). */
56 uint32_t volatile u32Magic;
57 /** The number of waiting threads. */
58 uint32_t cWaiters;
59 /** The number of references. */
60 uint32_t volatile cRefs;
61 /** The number of recursions. */
62 uint32_t cRecursions;
63 /** The handle of the owner thread. */
64 RTNATIVETHREAD hNativeOwner;
65 /** The spinlock protecting us. */
66 lck_spin_t *pSpinlock;
67} RTSEMMUTEXINTERNAL, *PRTSEMMUTEXINTERNAL;
68
69
70
71RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX phMutexSem)
72{
73 return RTSemMutexCreateEx(phMutexSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, RTLOCKVAL_SUB_CLASS_NONE, NULL);
74}
75
76
77RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags,
78 RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
79{
80 AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
81 RT_ASSERT_PREEMPTIBLE();
82
83 AssertCompile(sizeof(RTSEMMUTEXINTERNAL) > sizeof(void *));
84 PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pThis));
85 if (pThis)
86 {
87 pThis->u32Magic = RTSEMMUTEX_MAGIC;
88 pThis->cWaiters = 0;
89 pThis->cRefs = 1;
90 pThis->cRecursions = 0;
91 pThis->hNativeOwner = NIL_RTNATIVETHREAD;
92 Assert(g_pDarwinLockGroup);
93 pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
94 if (pThis->pSpinlock)
95 {
96 *phMutexSem = pThis;
97 return VINF_SUCCESS;
98 }
99
100 RTMemFree(pThis);
101 }
102 return VERR_NO_MEMORY;
103}
104
105
106/**
107 * Called when the refcount reaches zero.
108 */
109static void rtSemMutexDarwinFree(PRTSEMMUTEXINTERNAL pThis)
110{
111 lck_spin_unlock(pThis->pSpinlock);
112 lck_spin_destroy(pThis->pSpinlock, g_pDarwinLockGroup);
113 RTMemFree(pThis);
114}
115
116
117RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX hMutexSem)
118{
119 /*
120 * Validate input.
121 */
122 PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)hMutexSem;
123 if (!pThis)
124 return VERR_INVALID_PARAMETER;
125 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
126 AssertMsgReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, ("u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis), VERR_INVALID_HANDLE);
127 RT_ASSERT_INTS_ON();
128
129 /*
130 * Kill it, wake up all waiting threads and release the reference.
131 */
132 AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMMUTEX_MAGIC, RTSEMMUTEX_MAGIC), VERR_INVALID_HANDLE);
133 lck_spin_lock(pThis->pSpinlock);
134
135 if (pThis->cWaiters > 0)
136 thread_wakeup_prim((event_t)pThis, FALSE /* one_thread */, THREAD_RESTART);
137
138 if (ASMAtomicDecU32(&pThis->cRefs) == 0)
139 rtSemMutexDarwinFree(pThis);
140 else
141 lck_spin_unlock(pThis->pSpinlock);
142
143 return VINF_SUCCESS;
144}
145
146
147/**
148 * Internal worker for the sleep scenario.
149 *
150 * Called owning the spinlock, returns without it.
151 *
152 * @returns IPRT status code.
153 * @param pThis The mutex instance.
154 * @param cMillies The timeout.
155 * @param fInterruptible Whether it's interruptible
156 * (RTSemMutexRequestNoResume) or not
157 * (RTSemMutexRequest).
158 * @param hNativeSelf The thread handle of the caller.
159 */
160static int rtR0SemMutexDarwinRequestSleep(PRTSEMMUTEXINTERNAL pThis, RTMSINTERVAL cMillies,
161 wait_interrupt_t fInterruptible, RTNATIVETHREAD hNativeSelf)
162{
163 /*
164 * Grab a reference and indicate that we're waiting.
165 */
166 pThis->cWaiters++;
167 ASMAtomicIncU32(&pThis->cRefs);
168
169 /*
170 * Go to sleep, use the address of the mutex instance as sleep/blocking/event id.
171 */
172 wait_result_t rcWait;
173 if (cMillies == RT_INDEFINITE_WAIT)
174 rcWait = lck_spin_sleep(pThis->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pThis, fInterruptible);
175 else
176 {
177 uint64_t u64AbsTime;
178 nanoseconds_to_absolutetime(cMillies * UINT64_C(1000000), &u64AbsTime);
179 u64AbsTime += mach_absolute_time();
180
181 rcWait = lck_spin_sleep_deadline(pThis->pSpinlock, LCK_SLEEP_DEFAULT,
182 (event_t)pThis, fInterruptible, u64AbsTime);
183 }
184 /*
185 * Translate the rc.
186 */
187 int rc;
188 switch (rcWait)
189 {
190 case THREAD_AWAKENED:
191 if (RT_LIKELY(pThis->u32Magic == RTSEMMUTEX_MAGIC))
192 {
193 if (RT_LIKELY( pThis->cRecursions == 0
194 && pThis->hNativeOwner == NIL_RTNATIVETHREAD))
195 {
196 pThis->cRecursions = 1;
197 pThis->hNativeOwner = hNativeSelf;
198 rc = VINF_SUCCESS;
199 }
200 else
201 {
202 Assert(pThis->cRecursions == 0);
203 Assert(pThis->hNativeOwner == NIL_RTNATIVETHREAD);
204 rc = VERR_INTERNAL_ERROR_3;
205 }
206 }
207 else
208 rc = VERR_SEM_DESTROYED;
209 break;
210
211 case THREAD_TIMED_OUT:
212 Assert(cMillies != RT_INDEFINITE_WAIT);
213 rc = VERR_TIMEOUT;
214 break;
215
216 case THREAD_INTERRUPTED:
217 Assert(fInterruptible);
218 rc = VERR_INTERRUPTED;
219 break;
220
221 case THREAD_RESTART:
222 Assert(pThis->u32Magic == ~RTSEMMUTEX_MAGIC);
223 rc = VERR_SEM_DESTROYED;
224 break;
225
226 default:
227 AssertMsgFailed(("rcWait=%d\n", rcWait));
228 rc = VERR_GENERAL_FAILURE;
229 break;
230 }
231
232 /*
233 * Dereference it and quit the lock.
234 */
235 Assert(pThis->cWaiters > 0);
236 pThis->cWaiters--;
237
238 Assert(pThis->cRefs > 0);
239 if (RT_UNLIKELY(ASMAtomicDecU32(&pThis->cRefs) == 0))
240 rtSemMutexDarwinFree(pThis);
241 else
242 lck_spin_unlock(pThis->pSpinlock);
243 return rc;
244}
245
246
247/**
248 * Internal worker for RTSemMutexRequest and RTSemMutexRequestNoResume
249 *
250 * @returns IPRT status code.
251 * @param hMutexSem The mutex handle.
252 * @param cMillies The timeout.
253 * @param fInterruptible Whether it's interruptible
254 * (RTSemMutexRequestNoResume) or not
255 * (RTSemMutexRequest).
256 */
257DECLINLINE(int) rtR0SemMutexDarwinRequest(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, wait_interrupt_t fInterruptible)
258{
259 /*
260 * Validate input.
261 */
262 PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)hMutexSem;
263 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
264 AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
265 RT_ASSERT_PREEMPTIBLE();
266
267 /*
268 * Grab the lock and check out the state.
269 */
270 RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
271 int rc = VINF_SUCCESS;
272 lck_spin_lock(pThis->pSpinlock);
273
274 /* Recursive call? */
275 if (pThis->hNativeOwner == hNativeSelf)
276 {
277 Assert(pThis->cRecursions > 0);
278 Assert(pThis->cRecursions < 256);
279 pThis->cRecursions++;
280 }
281
282 /* Is it free and nobody ahead of us in the queue? */
283 else if ( pThis->hNativeOwner == NIL_RTNATIVETHREAD
284 && pThis->cWaiters == 0)
285 {
286 pThis->hNativeOwner = hNativeSelf;
287 pThis->cRecursions = 1;
288 }
289
290 /* Polling call? */
291 else if (cMillies == 0)
292 rc = VERR_TIMEOUT;
293
294 /* Yawn, time for a nap... */
295 else
296 return rtR0SemMutexDarwinRequestSleep(pThis, cMillies, fInterruptible, hNativeSelf);
297
298 lck_spin_unlock(pThis->pSpinlock);
299 return rc;
300}
301
302
303#undef RTSemMutexRequest
304RTDECL(int) RTSemMutexRequest(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies)
305{
306 return rtR0SemMutexDarwinRequest(hMutexSem, cMillies, THREAD_UNINT);
307}
308
309
310RTDECL(int) RTSemMutexRequestDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
311{
312 return RTSemMutexRequest(hMutexSem, cMillies);
313}
314
315
316#undef RTSemMutexRequestNoResume
317RTDECL(int) RTSemMutexRequestNoResume(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies)
318{
319 return rtR0SemMutexDarwinRequest(hMutexSem, cMillies, THREAD_ABORTSAFE);
320}
321
322
323RTDECL(int) RTSemMutexRequestNoResumeDebug(RTSEMMUTEX hMutexSem, RTMSINTERVAL cMillies, RTHCUINTPTR uId, RT_SRC_POS_DECL)
324{
325 return RTSemMutexRequestNoResume(hMutexSem, cMillies);
326}
327
328
329RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
330{
331 /*
332 * Validate input.
333 */
334 PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)hMutexSem;
335 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
336 AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
337 RT_ASSERT_PREEMPTIBLE();
338
339 /*
340 * Take the lock and do the job.
341 */
342 RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
343 int rc = VINF_SUCCESS;
344 lck_spin_lock(pThis->pSpinlock);
345
346 if (pThis->hNativeOwner == hNativeSelf)
347 {
348 Assert(pThis->cRecursions > 0);
349 if (--pThis->cRecursions == 0)
350 {
351 pThis->hNativeOwner = NIL_RTNATIVETHREAD;
352 if (pThis->cWaiters > 0)
353 {
354 int rc2=thread_wakeup_prim((event_t)pThis, TRUE /* one_thread */, THREAD_AWAKENED);
355 }
356
357 }
358 }
359 else
360 rc = VERR_NOT_OWNER;
361
362 lck_spin_unlock(pThis->pSpinlock);
363
364 AssertRC(rc);
365 return VINF_SUCCESS;
366}
367
368
369RTDECL(bool) RTSemMutexIsOwned(RTSEMMUTEX hMutexSem)
370{
371 /*
372 * Validate.
373 */
374 RTSEMMUTEXINTERNAL *pThis = hMutexSem;
375 AssertPtrReturn(pThis, false);
376 AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, false);
377
378 /*
379 * Take the lock and do the check.
380 */
381 lck_spin_lock(pThis->pSpinlock);
382 bool fRc = pThis->hNativeOwner != NIL_RTNATIVETHREAD;
383 lck_spin_unlock(pThis->pSpinlock);
384
385 return fRc;
386}
387
Note: See TracBrowser for help on using the repository browser.

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