VirtualBox

source: vbox/trunk/src/VBox/Runtime/r0drv/darwin/semaphore-r0drv-darwin.cpp@ 24181

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

semaphore-r0drv-darwin.cpp: cMillies == 0 will not block.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 23.9 KB
Line 
1/* $Id: semaphore-r0drv-darwin.cpp 22074 2009-08-07 15:27:36Z vboxsync $ */
2/** @file
3 * IPRT - Semaphores, Ring-0 Driver, Darwin.
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/*******************************************************************************
33* Header Files *
34*******************************************************************************/
35#include "the-darwin-kernel.h"
36#include "internal/iprt.h"
37#include <iprt/semaphore.h>
38
39#include <iprt/alloc.h>
40#include <iprt/assert.h>
41#include <iprt/asm.h>
42#include <iprt/err.h>
43#include <iprt/mp.h>
44#include <iprt/thread.h>
45
46#include "internal/magics.h"
47
48
49/*******************************************************************************
50* Structures and Typedefs *
51*******************************************************************************/
52/**
53 * Darwin event semaphore.
54 */
55typedef struct RTSEMEVENTINTERNAL
56{
57 /** Magic value (RTSEMEVENT_MAGIC). */
58 uint32_t volatile u32Magic;
59 /** The number of waiting threads. */
60 uint32_t volatile cWaiters;
61 /** Set if the event object is signaled. */
62 uint8_t volatile fSignaled;
63 /** The number of threads in the process of waking up. */
64 uint32_t volatile cWaking;
65 /** The spinlock protecting us. */
66 lck_spin_t *pSpinlock;
67} RTSEMEVENTINTERNAL, *PRTSEMEVENTINTERNAL;
68
69
70/**
71 * Darwin multiple release event semaphore.
72 */
73typedef struct RTSEMEVENTMULTIINTERNAL
74{
75 /** Magic value (RTSEMEVENTMULTI_MAGIC). */
76 uint32_t volatile u32Magic;
77 /** The number of waiting threads. */
78 uint32_t volatile cWaiters;
79 /** Set if the event object is signaled. */
80 uint8_t volatile fSignaled;
81 /** The number of threads in the process of waking up. */
82 uint32_t volatile cWaking;
83 /** The spinlock protecting us. */
84 lck_spin_t *pSpinlock;
85} RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL;
86
87
88#if 0 /** @todo */
89/**
90 * Darwin mutex semaphore.
91 */
92typedef struct RTSEMMUTEXINTERNAL
93{
94 /** Magic value (RTSEMMUTEX_MAGIC). */
95 uint32_t volatile u32Magic;
96 /** The mutex. */
97 lck_mtx_t *pMtx;
98} RTSEMMUTEXINTERNAL, *PRTSEMMUTEXINTERNAL;
99
100#endif
101
102
103/**
104 * Wrapper for the darwin semaphore structure.
105 */
106typedef struct RTSEMFASTMUTEXINTERNAL
107{
108 /** Magic value (RTSEMFASTMUTEX_MAGIC). */
109 uint32_t u32Magic;
110 /** The mutex. */
111 lck_mtx_t *pMtx;
112} RTSEMFASTMUTEXINTERNAL, *PRTSEMFASTMUTEXINTERNAL;
113
114
115
116RTDECL(int) RTSemEventCreate(PRTSEMEVENT pEventSem)
117{
118 Assert(sizeof(RTSEMEVENTINTERNAL) > sizeof(void *));
119 AssertPtrReturn(pEventSem, VERR_INVALID_POINTER);
120 RT_ASSERT_PREEMPTIBLE();
121
122 PRTSEMEVENTINTERNAL pEventInt = (PRTSEMEVENTINTERNAL)RTMemAlloc(sizeof(*pEventInt));
123 if (pEventInt)
124 {
125 pEventInt->u32Magic = RTSEMEVENT_MAGIC;
126 pEventInt->cWaiters = 0;
127 pEventInt->cWaking = 0;
128 pEventInt->fSignaled = 0;
129 Assert(g_pDarwinLockGroup);
130 pEventInt->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
131 if (pEventInt->pSpinlock)
132 {
133 *pEventSem = pEventInt;
134 return VINF_SUCCESS;
135 }
136
137 pEventInt->u32Magic = 0;
138 RTMemFree(pEventInt);
139 }
140 return VERR_NO_MEMORY;
141}
142
143
144RTDECL(int) RTSemEventDestroy(RTSEMEVENT EventSem)
145{
146 if (EventSem == NIL_RTSEMEVENT) /* don't bitch */
147 return VERR_INVALID_HANDLE;
148 PRTSEMEVENTINTERNAL pEventInt = (PRTSEMEVENTINTERNAL)EventSem;
149 AssertPtrReturn(pEventInt, VERR_INVALID_HANDLE);
150 AssertMsgReturn(pEventInt->u32Magic == RTSEMEVENT_MAGIC,
151 ("pEventInt=%p u32Magic=%#x\n", pEventInt, pEventInt->u32Magic),
152 VERR_INVALID_HANDLE);
153 RT_ASSERT_INTS_ON();
154
155 lck_spin_lock(pEventInt->pSpinlock);
156 ASMAtomicIncU32(&pEventInt->u32Magic); /* make the handle invalid */
157 if (pEventInt->cWaiters > 0)
158 {
159 /* abort waiting thread, last man cleans up. */
160 ASMAtomicXchgU32(&pEventInt->cWaking, pEventInt->cWaking + pEventInt->cWaiters);
161 thread_wakeup_prim((event_t)pEventInt, FALSE /* all threads */, THREAD_RESTART);
162 lck_spin_unlock(pEventInt->pSpinlock);
163 }
164 else if (pEventInt->cWaking)
165 /* the last waking thread is gonna do the cleanup */
166 lck_spin_unlock(pEventInt->pSpinlock);
167 else
168 {
169 lck_spin_unlock(pEventInt->pSpinlock);
170 lck_spin_destroy(pEventInt->pSpinlock, g_pDarwinLockGroup);
171 RTMemFree(pEventInt);
172 }
173
174 return VINF_SUCCESS;
175}
176
177
178RTDECL(int) RTSemEventSignal(RTSEMEVENT EventSem)
179{
180 PRTSEMEVENTINTERNAL pEventInt = (PRTSEMEVENTINTERNAL)EventSem;
181 AssertPtrReturn(pEventInt, VERR_INVALID_HANDLE);
182 AssertMsgReturn(pEventInt->u32Magic == RTSEMEVENT_MAGIC,
183 ("pEventInt=%p u32Magic=%#x\n", pEventInt, pEventInt->u32Magic),
184 VERR_INVALID_HANDLE);
185 RT_ASSERT_PREEMPT_CPUID_VAR();
186 RT_ASSERT_INTS_ON();
187
188 /** @todo should probably disable interrupts here... update
189 * semspinmutex-r0drv-generic.c when done. */
190 lck_spin_lock(pEventInt->pSpinlock);
191
192 if (pEventInt->cWaiters > 0)
193 {
194 ASMAtomicDecU32(&pEventInt->cWaiters);
195 ASMAtomicIncU32(&pEventInt->cWaking);
196 thread_wakeup_prim((event_t)pEventInt, TRUE /* one thread */, THREAD_AWAKENED);
197 /** @todo this isn't safe. a scheduling interrupt on the other cpu while we're in here
198 * could cause the thread to be timed out before we manage to wake it up and the event
199 * ends up in the wrong state. ditto for posix signals.
200 * Update: check the return code; it will return KERN_NOT_WAITING if no one is around. */
201 }
202 else
203 ASMAtomicXchgU8(&pEventInt->fSignaled, true);
204
205 lck_spin_unlock(pEventInt->pSpinlock);
206
207 RT_ASSERT_PREEMPT_CPUID();
208 return VINF_SUCCESS;
209}
210
211
212static int rtSemEventWait(RTSEMEVENT EventSem, unsigned cMillies, wait_interrupt_t fInterruptible)
213{
214 PRTSEMEVENTINTERNAL pEventInt = (PRTSEMEVENTINTERNAL)EventSem;
215 AssertPtrReturn(pEventInt, VERR_INVALID_HANDLE);
216 AssertMsgReturn(pEventInt->u32Magic == RTSEMEVENT_MAGIC,
217 ("pEventInt=%p u32Magic=%#x\n", pEventInt, pEventInt->u32Magic),
218 VERR_INVALID_HANDLE);
219 if (cMillies)
220 RT_ASSERT_PREEMPTIBLE();
221
222 lck_spin_lock(pEventInt->pSpinlock);
223
224 int rc;
225 if (pEventInt->fSignaled)
226 {
227 Assert(!pEventInt->cWaiters);
228 ASMAtomicXchgU8(&pEventInt->fSignaled, false);
229 rc = VINF_SUCCESS;
230 }
231 else if (!cMillies)
232 rc = VERR_TIMEOUT;
233 else
234 {
235 ASMAtomicIncU32(&pEventInt->cWaiters);
236
237 wait_result_t rcWait;
238 if (cMillies == RT_INDEFINITE_WAIT)
239 rcWait = lck_spin_sleep(pEventInt->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pEventInt, fInterruptible);
240 else
241 {
242 uint64_t u64AbsTime;
243 nanoseconds_to_absolutetime(cMillies * UINT64_C(1000000), &u64AbsTime);
244 u64AbsTime += mach_absolute_time();
245
246 rcWait = lck_spin_sleep_deadline(pEventInt->pSpinlock, LCK_SLEEP_DEFAULT,
247 (event_t)pEventInt, fInterruptible, u64AbsTime);
248 }
249 switch (rcWait)
250 {
251 case THREAD_AWAKENED:
252 Assert(pEventInt->cWaking > 0);
253 if ( !ASMAtomicDecU32(&pEventInt->cWaking)
254 && pEventInt->u32Magic != RTSEMEVENT_MAGIC)
255 {
256 /* the event was destroyed after we woke up, as the last thread do the cleanup. */
257 lck_spin_unlock(pEventInt->pSpinlock);
258 Assert(g_pDarwinLockGroup);
259 lck_spin_destroy(pEventInt->pSpinlock, g_pDarwinLockGroup);
260 RTMemFree(pEventInt);
261 return VINF_SUCCESS;
262 }
263 rc = VINF_SUCCESS;
264 break;
265
266 case THREAD_TIMED_OUT:
267 Assert(cMillies != RT_INDEFINITE_WAIT);
268 ASMAtomicDecU32(&pEventInt->cWaiters);
269 rc = VERR_TIMEOUT;
270 break;
271
272 case THREAD_INTERRUPTED:
273 Assert(fInterruptible);
274 ASMAtomicDecU32(&pEventInt->cWaiters);
275 rc = VERR_INTERRUPTED;
276 break;
277
278 case THREAD_RESTART:
279 /* Last one out does the cleanup. */
280 if (!ASMAtomicDecU32(&pEventInt->cWaking))
281 {
282 lck_spin_unlock(pEventInt->pSpinlock);
283 Assert(g_pDarwinLockGroup);
284 lck_spin_destroy(pEventInt->pSpinlock, g_pDarwinLockGroup);
285 RTMemFree(pEventInt);
286 return VERR_SEM_DESTROYED;
287 }
288
289 rc = VERR_SEM_DESTROYED;
290 break;
291
292 default:
293 AssertMsgFailed(("rcWait=%d\n", rcWait));
294 rc = VERR_GENERAL_FAILURE;
295 break;
296 }
297 }
298
299 lck_spin_unlock(pEventInt->pSpinlock);
300 return rc;
301}
302
303
304RTDECL(int) RTSemEventWait(RTSEMEVENT EventSem, unsigned cMillies)
305{
306 return rtSemEventWait(EventSem, cMillies, THREAD_UNINT);
307}
308
309
310RTDECL(int) RTSemEventWaitNoResume(RTSEMEVENT EventSem, unsigned cMillies)
311{
312 return rtSemEventWait(EventSem, cMillies, THREAD_ABORTSAFE);
313}
314
315
316
317RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI pEventMultiSem)
318{
319 Assert(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
320 AssertPtrReturn(pEventMultiSem, VERR_INVALID_POINTER);
321 RT_ASSERT_PREEMPTIBLE();
322
323 PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pEventMultiInt));
324 if (pEventMultiInt)
325 {
326 pEventMultiInt->u32Magic = RTSEMEVENTMULTI_MAGIC;
327 pEventMultiInt->cWaiters = 0;
328 pEventMultiInt->cWaking = 0;
329 pEventMultiInt->fSignaled = 0;
330 Assert(g_pDarwinLockGroup);
331 pEventMultiInt->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
332 if (pEventMultiInt->pSpinlock)
333 {
334 *pEventMultiSem = pEventMultiInt;
335 return VINF_SUCCESS;
336 }
337
338 pEventMultiInt->u32Magic = 0;
339 RTMemFree(pEventMultiInt);
340 }
341 return VERR_NO_MEMORY;
342}
343
344
345RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI EventMultiSem)
346{
347 if (EventMultiSem == NIL_RTSEMEVENTMULTI) /* don't bitch */
348 return VERR_INVALID_HANDLE;
349 PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
350 AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
351 AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
352 ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
353 VERR_INVALID_HANDLE);
354 RT_ASSERT_INTS_ON();
355
356 lck_spin_lock(pEventMultiInt->pSpinlock);
357 ASMAtomicIncU32(&pEventMultiInt->u32Magic); /* make the handle invalid */
358 if (pEventMultiInt->cWaiters > 0)
359 {
360 /* abort waiting thread, last man cleans up. */
361 ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
362 thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_RESTART);
363 lck_spin_unlock(pEventMultiInt->pSpinlock);
364 }
365 else if (pEventMultiInt->cWaking)
366 /* the last waking thread is gonna do the cleanup */
367 lck_spin_unlock(pEventMultiInt->pSpinlock);
368 else
369 {
370 lck_spin_unlock(pEventMultiInt->pSpinlock);
371 lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
372 RTMemFree(pEventMultiInt);
373 }
374
375 return VINF_SUCCESS;
376}
377
378
379RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI EventMultiSem)
380{
381 PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
382 AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
383 AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
384 ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
385 VERR_INVALID_HANDLE);
386 RT_ASSERT_PREEMPT_CPUID_VAR();
387 RT_ASSERT_INTS_ON();
388
389 lck_spin_lock(pEventMultiInt->pSpinlock);
390
391 ASMAtomicXchgU8(&pEventMultiInt->fSignaled, true);
392 if (pEventMultiInt->cWaiters > 0)
393 {
394 ASMAtomicXchgU32(&pEventMultiInt->cWaking, pEventMultiInt->cWaking + pEventMultiInt->cWaiters);
395 ASMAtomicXchgU32(&pEventMultiInt->cWaiters, 0);
396 thread_wakeup_prim((event_t)pEventMultiInt, FALSE /* all threads */, THREAD_AWAKENED);
397 }
398
399 lck_spin_unlock(pEventMultiInt->pSpinlock);
400
401 RT_ASSERT_PREEMPT_CPUID();
402 return VINF_SUCCESS;
403}
404
405
406RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI EventMultiSem)
407{
408 PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
409 AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
410 AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
411 ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
412 VERR_INVALID_HANDLE);
413 RT_ASSERT_PREEMPT_CPUID_VAR();
414 RT_ASSERT_INTS_ON();
415
416 lck_spin_lock(pEventMultiInt->pSpinlock);
417 ASMAtomicXchgU8(&pEventMultiInt->fSignaled, false);
418 lck_spin_unlock(pEventMultiInt->pSpinlock);
419
420 RT_ASSERT_PREEMPT_CPUID();
421 return VINF_SUCCESS;
422}
423
424
425static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, wait_interrupt_t fInterruptible)
426{
427 PRTSEMEVENTMULTIINTERNAL pEventMultiInt = (PRTSEMEVENTMULTIINTERNAL)EventMultiSem;
428 AssertPtrReturn(pEventMultiInt, VERR_INVALID_HANDLE);
429 AssertMsgReturn(pEventMultiInt->u32Magic == RTSEMEVENTMULTI_MAGIC,
430 ("pEventMultiInt=%p u32Magic=%#x\n", pEventMultiInt, pEventMultiInt->u32Magic),
431 VERR_INVALID_HANDLE);
432 if (cMillies)
433 RT_ASSERT_PREEMPTIBLE();
434
435 lck_spin_lock(pEventMultiInt->pSpinlock);
436
437 int rc;
438 if (pEventMultiInt->fSignaled)
439 rc = VINF_SUCCESS;
440 else if (!cMillies)
441 rc = VERR_TIMEOUT;
442 else
443 {
444 ASMAtomicIncU32(&pEventMultiInt->cWaiters);
445
446 wait_result_t rcWait;
447 if (cMillies == RT_INDEFINITE_WAIT)
448 rcWait = lck_spin_sleep(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pEventMultiInt, fInterruptible);
449 else
450 {
451 uint64_t u64AbsTime;
452 nanoseconds_to_absolutetime(cMillies * UINT64_C(1000000), &u64AbsTime);
453 u64AbsTime += mach_absolute_time();
454
455 rcWait = lck_spin_sleep_deadline(pEventMultiInt->pSpinlock, LCK_SLEEP_DEFAULT,
456 (event_t)pEventMultiInt, fInterruptible, u64AbsTime);
457 }
458 switch (rcWait)
459 {
460 case THREAD_AWAKENED:
461 Assert(pEventMultiInt->cWaking > 0);
462 if ( !ASMAtomicDecU32(&pEventMultiInt->cWaking)
463 && pEventMultiInt->u32Magic != RTSEMEVENTMULTI_MAGIC)
464 {
465 /* the event was destroyed after we woke up, as the last thread do the cleanup. */
466 lck_spin_unlock(pEventMultiInt->pSpinlock);
467 Assert(g_pDarwinLockGroup);
468 lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
469 RTMemFree(pEventMultiInt);
470 return VINF_SUCCESS;
471 }
472 rc = VINF_SUCCESS;
473 break;
474
475 case THREAD_TIMED_OUT:
476 Assert(cMillies != RT_INDEFINITE_WAIT);
477 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
478 rc = VERR_TIMEOUT;
479 break;
480
481 case THREAD_INTERRUPTED:
482 Assert(fInterruptible);
483 ASMAtomicDecU32(&pEventMultiInt->cWaiters);
484 rc = VERR_INTERRUPTED;
485 break;
486
487 case THREAD_RESTART:
488 /* Last one out does the cleanup. */
489 if (!ASMAtomicDecU32(&pEventMultiInt->cWaking))
490 {
491 lck_spin_unlock(pEventMultiInt->pSpinlock);
492 Assert(g_pDarwinLockGroup);
493 lck_spin_destroy(pEventMultiInt->pSpinlock, g_pDarwinLockGroup);
494 RTMemFree(pEventMultiInt);
495 return VERR_SEM_DESTROYED;
496 }
497
498 rc = VERR_SEM_DESTROYED;
499 break;
500
501 default:
502 AssertMsgFailed(("rcWait=%d\n", rcWait));
503 rc = VERR_GENERAL_FAILURE;
504 break;
505 }
506 }
507
508 lck_spin_unlock(pEventMultiInt->pSpinlock);
509 return rc;
510}
511
512
513RTDECL(int) RTSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
514{
515 return rtSemEventMultiWait(EventMultiSem, cMillies, THREAD_UNINT);
516}
517
518
519RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies)
520{
521 return rtSemEventMultiWait(EventMultiSem, cMillies, THREAD_ABORTSAFE);
522}
523
524
525
526
527
528#if 0 /* need proper timeout lock function! */
529RTDECL(int) RTSemMutexCreate(PRTSEMMUTEX pMutexSem)
530{
531 RT_ASSERT_PREEMPTIBLE();
532 AssertCompile(sizeof(RTSEMMUTEXINTERNAL) > sizeof(void *));
533 PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pMutexInt));
534 if (pMutexInt)
535 {
536 pMutexInt->u32Magic = RTSEMMUTEX_MAGIC;
537 Assert(g_pDarwinLockGroup);
538 pMutexInt->pMtx = lck_mtx_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
539 if (pMutexInt->pMtx)
540 {
541 *pMutexSem = pMutexInt;
542 return VINF_SUCCESS;
543 }
544 RTMemFree(pMutexInt);
545 }
546 return VERR_NO_MEMORY;
547}
548
549
550RTDECL(int) RTSemMutexDestroy(RTSEMMUTEX MutexSem)
551{
552 /*
553 * Validate input.
554 */
555 PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
556 if (!pMutexInt)
557 return VERR_INVALID_PARAMETER;
558 AssertPtrReturn(pMutexInt, VERR_INVALID_POINTER);
559 AssertMsg(pMutexInt->u32Magic == RTSEMMUTEX_MAGIC,
560 ("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt->u32Magic, pMutexInt)
561 VERR_INVALID_PARAMETER);
562 RT_ASSERT_INTS_ON();
563
564 /*
565 * Invalidate it and signal the object just in case.
566 */
567 ASMAtomicIncU32(&pMutexInt->u32Magic);
568
569 Assert(g_pDarwinLockGroup);
570 lck_mtx_free(pMutexInt->pMtx, g_pDarwinLockGroup);
571 pMutexInt->pMtx = NULL;
572
573 RTMemFree(pMutexInt);
574 return VINF_SUCCESS;
575}
576
577
578RTDECL(int) RTSemMutexRequest(RTSEMMUTEX MutexSem, unsigned cMillies)
579{
580 /*
581 * Validate input.
582 */
583 PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
584 if (!pMutexInt)
585 return VERR_INVALID_PARAMETER;
586 AssertPtrReturn(pMutexInt, VERR_INVALID_POINTER);
587 AssertMsg(pMutexInt->u32Magic == RTSEMMUTEX_MAGIC,
588 ("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt->u32Magic, pMutexInt)
589 VERR_INVALID_PARAMETER);
590 if (cMillies)
591 RT_ASSERT_PREEMPTIBLE();
592
593 /*
594 * Get the mutex.
595 */
596 wait_result_t rc = lck_mtx_lock_deadlink
597#if 1
598#else
599 NTSTATUS rcNt;
600 if (cMillies == RT_INDEFINITE_WAIT)
601 rcNt = KeWaitForSingleObject(&pMutexInt->Mutex, Executive, KernelMode, TRUE, NULL);
602 else
603 {
604 LARGE_INTEGER Timeout;
605 Timeout.QuadPart = -(int64_t)cMillies * 10000;
606 rcNt = KeWaitForSingleObject(&pMutexInt->Mutex, Executive, KernelMode, TRUE, &Timeout);
607 }
608 switch (rcNt)
609 {
610 case STATUS_SUCCESS:
611 if (pMutexInt->u32Magic == RTSEMMUTEX_MAGIC)
612 return VINF_SUCCESS;
613 return VERR_SEM_DESTROYED;
614 case STATUS_ALERTED:
615 return VERR_INTERRUPTED; /** @todo VERR_INTERRUPTED isn't correct anylonger. please fix r0drv stuff! */
616 case STATUS_USER_APC:
617 return VERR_INTERRUPTED; /** @todo VERR_INTERRUPTED isn't correct anylonger. please fix r0drv stuff! */
618 case STATUS_TIMEOUT:
619 return VERR_TIMEOUT;
620 default:
621 AssertMsgFailed(("pMutexInt->u32Magic=%RX32 pMutexInt=%p: wait returned %lx!\n",
622 pMutexInt->u32Magic, pMutexInt, (long)rcNt));
623 return VERR_INTERNAL_ERROR;
624 }
625#endif
626 return VINF_SUCCESS;
627}
628
629
630RTDECL(int) RTSemMutexRelease(RTSEMMUTEX MutexSem)
631{
632 /*
633 * Validate input.
634 */
635 PRTSEMMUTEXINTERNAL pMutexInt = (PRTSEMMUTEXINTERNAL)MutexSem;
636 if (!pMutexInt)
637 return VERR_INVALID_PARAMETER;
638 if ( !pMutexInt
639 || pMutexInt->u32Magic != RTSEMMUTEX_MAGIC)
640 {
641 AssertMsgFailed(("pMutexInt->u32Magic=%RX32 pMutexInt=%p\n", pMutexInt ? pMutexInt->u32Magic : 0, pMutexInt));
642 return VERR_INVALID_PARAMETER;
643 }
644 RT_ASSERT_PREEMPTIBLE();
645
646 /*
647 * Release the mutex.
648 */
649#ifdef RT_USE_FAST_MUTEX
650 ExReleaseFastMutex(&pMutexInt->Mutex);
651#else
652 KeReleaseMutex(&pMutexInt->Mutex, FALSE);
653#endif
654 return VINF_SUCCESS;
655}
656
657#endif /* later */
658
659
660
661
662RTDECL(int) RTSemFastMutexCreate(PRTSEMFASTMUTEX pMutexSem)
663{
664 AssertCompile(sizeof(RTSEMFASTMUTEXINTERNAL) > sizeof(void *));
665 AssertPtrReturn(pMutexSem, VERR_INVALID_POINTER);
666 RT_ASSERT_PREEMPTIBLE();
667
668 PRTSEMFASTMUTEXINTERNAL pFastInt = (PRTSEMFASTMUTEXINTERNAL)RTMemAlloc(sizeof(*pFastInt));
669 if (pFastInt)
670 {
671 pFastInt->u32Magic = RTSEMFASTMUTEX_MAGIC;
672 Assert(g_pDarwinLockGroup);
673 pFastInt->pMtx = lck_mtx_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
674 if (pFastInt->pMtx)
675 {
676 *pMutexSem = pFastInt;
677 return VINF_SUCCESS;
678 }
679
680 RTMemFree(pFastInt);
681 }
682 return VERR_NO_MEMORY;
683}
684
685
686RTDECL(int) RTSemFastMutexDestroy(RTSEMFASTMUTEX MutexSem)
687{
688 if (MutexSem == NIL_RTSEMFASTMUTEX) /* don't bitch */
689 return VERR_INVALID_PARAMETER;
690 PRTSEMFASTMUTEXINTERNAL pFastInt = (PRTSEMFASTMUTEXINTERNAL)MutexSem;
691 AssertPtrReturn(pFastInt, VERR_INVALID_PARAMETER);
692 AssertMsgReturn(pFastInt->u32Magic == RTSEMFASTMUTEX_MAGIC,
693 ("pFastInt->u32Magic=%RX32 pFastInt=%p\n", pFastInt->u32Magic, pFastInt),
694 VERR_INVALID_PARAMETER);
695 RT_ASSERT_INTS_ON();
696
697 ASMAtomicIncU32(&pFastInt->u32Magic); /* make the handle invalid. */
698 Assert(g_pDarwinLockGroup);
699 lck_mtx_free(pFastInt->pMtx, g_pDarwinLockGroup);
700 pFastInt->pMtx = NULL;
701 RTMemFree(pFastInt);
702
703 return VINF_SUCCESS;
704}
705
706
707RTDECL(int) RTSemFastMutexRequest(RTSEMFASTMUTEX MutexSem)
708{
709 PRTSEMFASTMUTEXINTERNAL pFastInt = (PRTSEMFASTMUTEXINTERNAL)MutexSem;
710 AssertPtrReturn(pFastInt, VERR_INVALID_PARAMETER);
711 AssertMsgReturn(pFastInt->u32Magic == RTSEMFASTMUTEX_MAGIC,
712 ("pFastInt->u32Magic=%RX32 pFastInt=%p\n", pFastInt->u32Magic, pFastInt),
713 VERR_INVALID_PARAMETER);
714 RT_ASSERT_PREEMPTIBLE();
715 lck_mtx_lock(pFastInt->pMtx);
716 return VINF_SUCCESS;
717}
718
719
720RTDECL(int) RTSemFastMutexRelease(RTSEMFASTMUTEX MutexSem)
721{
722 PRTSEMFASTMUTEXINTERNAL pFastInt = (PRTSEMFASTMUTEXINTERNAL)MutexSem;
723 AssertPtrReturn(pFastInt, VERR_INVALID_PARAMETER);
724 AssertMsgReturn(pFastInt->u32Magic == RTSEMFASTMUTEX_MAGIC,
725 ("pFastInt->u32Magic=%RX32 pFastInt=%p\n", pFastInt->u32Magic, pFastInt),
726 VERR_INVALID_PARAMETER);
727 RT_ASSERT_PREEMPTIBLE();
728 lck_mtx_unlock(pFastInt->pMtx);
729 return VINF_SUCCESS;
730}
731
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