VirtualBox

source: vbox/trunk/src/VBox/Runtime/r0drv/darwin/semeventmulti-r0drv-darwin.cpp@ 72118

Last change on this file since 72118 was 69111, checked in by vboxsync, 7 years ago

(C) year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 15.3 KB
Line 
1/* $Id: semeventmulti-r0drv-darwin.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
2/** @file
3 * IPRT - Multiple Release Event Semaphores, Ring-0 Driver, Darwin.
4 */
5
6/*
7 * Copyright (C) 2006-2017 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-darwin-kernel.h"
33#include "internal/iprt.h"
34#include <iprt/semaphore.h>
35
36#include <iprt/assert.h>
37#include <iprt/asm.h>
38#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
39# include <iprt/asm-amd64-x86.h>
40#endif
41#include <iprt/err.h>
42#include <iprt/lockvalidator.h>
43#include <iprt/mem.h>
44#include <iprt/mp.h>
45#include <iprt/thread.h>
46#include <iprt/time.h>
47
48#include "internal/magics.h"
49
50
51/*********************************************************************************************************************************
52* Defined Constants And Macros *
53*********************************************************************************************************************************/
54/** @name fStateAndGen values
55 * @{ */
56/** The state bit number. */
57#define RTSEMEVENTMULTIDARWIN_STATE_BIT 0
58/** The state mask. */
59#define RTSEMEVENTMULTIDARWIN_STATE_MASK RT_BIT_32(RTSEMEVENTMULTIDARWIN_STATE_BIT)
60/** The generation mask. */
61#define RTSEMEVENTMULTIDARWIN_GEN_MASK ~RTSEMEVENTMULTIDARWIN_STATE_MASK
62/** The generation shift. */
63#define RTSEMEVENTMULTIDARWIN_GEN_SHIFT 1
64/** The initial variable value. */
65#define RTSEMEVENTMULTIDARWIN_STATE_GEN_INIT UINT32_C(0xfffffffc)
66/** @} */
67
68
69/*********************************************************************************************************************************
70* Structures and Typedefs *
71*********************************************************************************************************************************/
72/**
73 * Darwin multiple release event semaphore.
74 */
75typedef struct RTSEMEVENTMULTIINTERNAL
76{
77 /** Magic value (RTSEMEVENTMULTI_MAGIC). */
78 uint32_t volatile u32Magic;
79 /** The object state bit and generation counter.
80 * The generation counter is incremented every time the object is
81 * signalled. */
82 uint32_t volatile fStateAndGen;
83 /** Reference counter. */
84 uint32_t volatile cRefs;
85 /** Set if there are blocked threads. */
86 bool volatile fHaveBlockedThreads;
87 /** The spinlock protecting us. */
88 lck_spin_t *pSpinlock;
89} RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL;
90
91
92
93RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
94{
95 return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
96}
97
98
99RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
100 const char *pszNameFmt, ...)
101{
102 RT_NOREF(hClass, pszNameFmt);
103 AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
104 AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
105 AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
106 RT_ASSERT_PREEMPTIBLE();
107 IPRT_DARWIN_SAVE_EFL_AC();
108
109 PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
110 if (pThis)
111 {
112 pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
113 pThis->fStateAndGen = RTSEMEVENTMULTIDARWIN_STATE_GEN_INIT;
114 pThis->cRefs = 1;
115 pThis->fHaveBlockedThreads = false;
116 Assert(g_pDarwinLockGroup);
117 pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
118 if (pThis->pSpinlock)
119 {
120 *phEventMultiSem = pThis;
121 IPRT_DARWIN_RESTORE_EFL_AC();
122 return VINF_SUCCESS;
123 }
124
125 pThis->u32Magic = 0;
126 RTMemFree(pThis);
127 }
128 IPRT_DARWIN_RESTORE_EFL_AC();
129 return VERR_NO_MEMORY;
130}
131
132
133/**
134 * Retain a reference to the semaphore.
135 *
136 * @param pThis The semaphore.
137 */
138DECLINLINE(void) rtR0SemEventMultiDarwinRetain(PRTSEMEVENTMULTIINTERNAL pThis)
139{
140 uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
141 Assert(cRefs && cRefs < 100000);
142 RT_NOREF_PV(cRefs);
143}
144
145
146/**
147 * Release a reference, destroy the thing if necessary.
148 *
149 * @param pThis The semaphore.
150 */
151DECLINLINE(void) rtR0SemEventMultiDarwinRelease(PRTSEMEVENTMULTIINTERNAL pThis)
152{
153 if (RT_UNLIKELY(ASMAtomicDecU32(&pThis->cRefs) == 0))
154 {
155 IPRT_DARWIN_SAVE_EFL_AC();
156 Assert(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC);
157
158 lck_spin_destroy(pThis->pSpinlock, g_pDarwinLockGroup);
159 RTMemFree(pThis);
160
161 IPRT_DARWIN_RESTORE_EFL_AC();
162 }
163}
164
165
166RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
167{
168 PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
169 if (pThis == NIL_RTSEMEVENTMULTI)
170 return VINF_SUCCESS;
171 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
172 AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
173 Assert(pThis->cRefs > 0);
174 RT_ASSERT_INTS_ON();
175 IPRT_DARWIN_SAVE_EFL_AC();
176
177 lck_spin_lock(pThis->pSpinlock);
178
179 ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMEVENTMULTI_MAGIC); /* make the handle invalid */
180 ASMAtomicAndU32(&pThis->fStateAndGen, RTSEMEVENTMULTIDARWIN_GEN_MASK);
181 if (pThis->fHaveBlockedThreads)
182 {
183 /* abort waiting threads. */
184 thread_wakeup_prim((event_t)pThis, FALSE /* all threads */, THREAD_RESTART);
185 }
186
187 lck_spin_unlock(pThis->pSpinlock);
188 rtR0SemEventMultiDarwinRelease(pThis);
189
190 IPRT_DARWIN_RESTORE_EFL_AC();
191 return VINF_SUCCESS;
192}
193
194
195RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
196{
197 PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
198 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
199 AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
200 RT_ASSERT_PREEMPT_CPUID_VAR();
201 RT_ASSERT_INTS_ON();
202 IPRT_DARWIN_SAVE_EFL_AC();
203
204 rtR0SemEventMultiDarwinRetain(pThis);
205 lck_spin_lock(pThis->pSpinlock);
206
207 /*
208 * Set the signal and increment the generation counter.
209 */
210 uint32_t fNew = ASMAtomicUoReadU32(&pThis->fStateAndGen);
211 fNew += 1 << RTSEMEVENTMULTIDARWIN_GEN_SHIFT;
212 fNew |= RTSEMEVENTMULTIDARWIN_STATE_MASK;
213 ASMAtomicWriteU32(&pThis->fStateAndGen, fNew);
214
215 /*
216 * Wake up all sleeping threads.
217 */
218 if (pThis->fHaveBlockedThreads)
219 {
220 ASMAtomicWriteBool(&pThis->fHaveBlockedThreads, false);
221 thread_wakeup_prim((event_t)pThis, FALSE /* all threads */, THREAD_AWAKENED);
222 }
223
224 lck_spin_unlock(pThis->pSpinlock);
225 rtR0SemEventMultiDarwinRelease(pThis);
226
227 RT_ASSERT_PREEMPT_CPUID();
228 IPRT_DARWIN_RESTORE_EFL_AC();
229 return VINF_SUCCESS;
230}
231
232
233RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
234{
235 PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
236 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
237 AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
238 RT_ASSERT_PREEMPT_CPUID_VAR();
239 RT_ASSERT_INTS_ON();
240 IPRT_DARWIN_SAVE_EFL_AC();
241
242 rtR0SemEventMultiDarwinRetain(pThis);
243 lck_spin_lock(pThis->pSpinlock);
244
245 ASMAtomicAndU32(&pThis->fStateAndGen, ~RTSEMEVENTMULTIDARWIN_STATE_MASK);
246
247 lck_spin_unlock(pThis->pSpinlock);
248 rtR0SemEventMultiDarwinRelease(pThis);
249
250 RT_ASSERT_PREEMPT_CPUID();
251 IPRT_DARWIN_RESTORE_EFL_AC();
252 return VINF_SUCCESS;
253}
254
255
256/**
257 * Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
258 *
259 * @returns VBox status code.
260 * @param pThis The event semaphore.
261 * @param fFlags See RTSemEventMultiWaitEx.
262 * @param uTimeout See RTSemEventMultiWaitEx.
263 * @param pSrcPos The source code position of the wait.
264 */
265static int rtR0SemEventMultiDarwinWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
266 PCRTLOCKVALSRCPOS pSrcPos)
267{
268 RT_NOREF(pSrcPos);
269
270 /*
271 * Validate input.
272 */
273 AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
274 AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
275 AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
276 if (uTimeout != 0 || (fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
277 RT_ASSERT_PREEMPTIBLE();
278 IPRT_DARWIN_SAVE_EFL_AC();
279
280 rtR0SemEventMultiDarwinRetain(pThis);
281 lck_spin_lock(pThis->pSpinlock);
282
283 /*
284 * Is the event already signalled or do we have to wait?
285 */
286 int rc;
287 uint32_t const fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
288 if (fOrgStateAndGen & RTSEMEVENTMULTIDARWIN_STATE_MASK)
289 rc = VINF_SUCCESS;
290 else
291 {
292 /*
293 * We have to wait. So, we'll need to convert the timeout and figure
294 * out if it's indefinite or not.
295 */
296 uint64_t uNsAbsTimeout = 1;
297 if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
298 {
299 if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
300 uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
301 ? uTimeout * UINT32_C(1000000)
302 : UINT64_MAX;
303 if (uTimeout == UINT64_MAX)
304 fFlags |= RTSEMWAIT_FLAGS_INDEFINITE;
305 else
306 {
307 uint64_t u64Now;
308 if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
309 {
310 if (uTimeout != 0)
311 {
312 u64Now = RTTimeSystemNanoTS();
313 uNsAbsTimeout = u64Now + uTimeout;
314 if (uNsAbsTimeout < u64Now) /* overflow */
315 fFlags |= RTSEMWAIT_FLAGS_INDEFINITE;
316 }
317 }
318 else
319 {
320 uNsAbsTimeout = uTimeout;
321 u64Now = RTTimeSystemNanoTS();
322 uTimeout = u64Now < uTimeout ? uTimeout - u64Now : 0;
323 }
324 }
325 }
326
327 if ( !(fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
328 && uTimeout == 0)
329 {
330 /*
331 * Poll call, we already checked the condition above so no need to
332 * wait for anything.
333 */
334 rc = VERR_TIMEOUT;
335 }
336 else
337 {
338 for (;;)
339 {
340 /*
341 * Do the actual waiting.
342 */
343 ASMAtomicWriteBool(&pThis->fHaveBlockedThreads, true);
344 wait_interrupt_t fInterruptible = fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE ? THREAD_ABORTSAFE : THREAD_UNINT;
345 wait_result_t rcWait;
346 if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
347 rcWait = lck_spin_sleep(pThis->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pThis, fInterruptible);
348 else
349 {
350 uint64_t u64AbsTime;
351 nanoseconds_to_absolutetime(uNsAbsTimeout, &u64AbsTime);
352 rcWait = lck_spin_sleep_deadline(pThis->pSpinlock, LCK_SLEEP_DEFAULT,
353 (event_t)pThis, fInterruptible, u64AbsTime);
354 }
355
356 /*
357 * Deal with the wait result.
358 */
359 if (RT_LIKELY(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC))
360 {
361 switch (rcWait)
362 {
363 case THREAD_AWAKENED:
364 if (RT_LIKELY(ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen))
365 rc = VINF_SUCCESS;
366 else if (fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE)
367 rc = VERR_INTERRUPTED;
368 else
369 continue; /* Seen this happen after fork/exec/something. */
370 break;
371
372 case THREAD_TIMED_OUT:
373 Assert(!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE));
374 rc = VERR_TIMEOUT;
375 break;
376
377 case THREAD_INTERRUPTED:
378 Assert(fInterruptible != THREAD_UNINT);
379 rc = VERR_INTERRUPTED;
380 break;
381
382 case THREAD_RESTART:
383 AssertMsg(pThis->u32Magic == ~RTSEMEVENTMULTI_MAGIC, ("%#x\n", pThis->u32Magic));
384 rc = VERR_SEM_DESTROYED;
385 break;
386
387 default:
388 AssertMsgFailed(("rcWait=%d\n", rcWait));
389 rc = VERR_INTERNAL_ERROR_3;
390 break;
391 }
392 }
393 else
394 rc = VERR_SEM_DESTROYED;
395 break;
396 }
397 }
398 }
399
400 lck_spin_unlock(pThis->pSpinlock);
401 rtR0SemEventMultiDarwinRelease(pThis);
402
403 IPRT_DARWIN_RESTORE_EFL_AC();
404 return rc;
405}
406
407RTDECL(int) RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
408{
409#ifndef RTSEMEVENT_STRICT
410 return rtR0SemEventMultiDarwinWait(hEventMultiSem, fFlags, uTimeout, NULL);
411#else
412 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
413 return rtR0SemEventMultiDarwinWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
414#endif
415}
416
417
418RTDECL(int) RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
419 RTHCUINTPTR uId, RT_SRC_POS_DECL)
420{
421 RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
422 return rtR0SemEventMultiDarwinWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
423}
424
425
426RTDECL(uint32_t) RTSemEventMultiGetResolution(void)
427{
428 uint64_t cNs;
429 absolutetime_to_nanoseconds(1, &cNs);
430 return (uint32_t)cNs ? (uint32_t)cNs : 0;
431}
432
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