VirtualBox

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

Last change on this file since 11280 was 8245, checked in by vboxsync, 17 years ago

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