DECLINLINE(int) rtSemEventMultiPosixWait(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
/*
* Validate input.
*/
struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
uint32_t u32 = pThis->u32State;
AssertReturn(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED, VERR_INVALID_HANDLE);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
/*
* Optimize the case where the event is signalled.
*/
if (ASMAtomicUoReadU32(&pThis->u32State) == EVENTMULTI_STATE_SIGNALED)
{
int rc = rtSemEventMultiPosixWaitPoll(pThis);
if (RT_LIKELY(rc != VERR_TIMEOUT))
return rc;
}
/*
* Indefinite or timed wait?
*/
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
return rtSemEventMultiPosixWaitIndefinite(pThis, fFlags, pSrcPos);
return rtSemEventMultiPosixWaitTimed(pThis, fFlags, uTimeout, pSrcPos);
}
/**
* Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventWaitEx.
* @param uTimeout See RTSemEventWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventLnxWait(PRTSEMEVENTINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
int rc;
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventLnxRetain(pThis);
/*
* Try grab the event without setting up the wait.
*/
if ( 1 /** @todo check if there are someone waiting already - waitqueue_active, but then what do we do below? */
&& ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else
{
/*
* We have to wait.
*/
RTR0SEMLNXWAIT Wait;
rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
if (RT_SUCCESS(rc))
{
IPRT_DEBUG_SEMS_STATE(pThis, 'E');
for (;;)
{
/* The destruction test. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else
{
rtR0SemLnxWaitPrepare(&Wait);
/* Check the exit conditions. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else if (ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else if (rtR0SemLnxWaitHasTimedOut(&Wait))
rc = VERR_TIMEOUT;
else if (rtR0SemLnxWaitWasInterrupted(&Wait))
rc = VERR_INTERRUPTED;
else
{
/* Do the wait and then recheck the conditions. */
rtR0SemLnxWaitDoIt(&Wait);
continue;
}
}
break;
}
rtR0SemLnxWaitDelete(&Wait);
IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
}
}
rtR0SemEventLnxRelease(pThis);
return rc;
}
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiHkuWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
status_t status;
int rc;
int32 flags = 0;
bigtime_t timeout; /* in microseconds */
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
timeout = B_INFINITE_TIMEOUT;
else
{
if (fFlags & RTSEMWAIT_FLAGS_NANOSECS)
timeout = uTimeout / 1000;
else if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
timeout = uTimeout * 1000;
else
return VERR_INVALID_PARAMETER;
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
flags |= B_RELATIVE_TIMEOUT;
else if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE)
flags |= B_ABSOLUTE_TIMEOUT;
else
return VERR_INVALID_PARAMETER;
}
if (fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE)
flags |= B_CAN_INTERRUPT;
// likely not:
//else
// flags |= B_KILL_CAN_INTERRUPT;
rtR0SemEventMultiHkuRetain(pThis);
status = acquire_sem_etc(pThis->SemId, 1, flags, timeout);
switch (status)
{
case B_OK:
rc = VINF_SUCCESS;
break;
case B_BAD_SEM_ID:
rc = VERR_SEM_DESTROYED;
break;
case B_INTERRUPTED:
rc = VERR_INTERRUPTED;
break;
case B_WOULD_BLOCK:
/* fallthrough? */
case B_TIMED_OUT:
rc = VERR_TIMEOUT;
break;
default:
rc = RTErrConvertFromHaikuKernReturn(status);
break;
}
rtR0SemEventMultiHkuRelease(pThis);
return rc;
}
/**
* Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventWaitEx.
* @param uTimeout See RTSemEventWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiOs2Wait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
/*
* Validate and convert the input.
*/
if (!pThis)
return VERR_INVALID_HANDLE;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC,
("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
VERR_INVALID_HANDLE);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
ULONG cMsTimeout = rtR0SemWaitOs2ConvertTimeout(fFlags, uTimeout);
ULONG fBlock = BLOCK_SPINLOCK;
if (!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE))
fBlock |= BLOCK_UNINTERRUPTABLE;
/*
* Do the job.
*/
KernAcquireSpinLock(&pThis->Spinlock);
int rc;
if (pThis->fSignaled)
rc = VINF_SUCCESS;
else
{
ASMAtomicIncU32(&pThis->cWaiters);
ULONG ulData = (ULONG)VERR_INTERNAL_ERROR;
rc = KernBlock((ULONG)pThis, cMsTimeout, fBlock,
&pThis->Spinlock,
&ulData);
switch (rc)
{
case NO_ERROR:
rc = (int)ulData;
Assert(rc == VINF_SUCCESS || rc == VERR_SEM_DESTROYED);
Assert(pThis->cWaking > 0);
if ( !ASMAtomicDecU32(&pThis->cWaking)
&& pThis->u32Magic != RTSEMEVENTMULTI_MAGIC)
{
/* The event was destroyed (ulData == VINF_SUCCESS if it was after we awoke), as
the last thread do the cleanup. */
KernReleaseSpinLock(&pThis->Spinlock);
KernFreeSpinLock(&pThis->Spinlock);
RTMemFree(pThis);
return VINF_SUCCESS;
}
rc = VINF_SUCCESS;
break;
case ERROR_TIMEOUT:
Assert(cMsTimeout != SEM_INDEFINITE_WAIT);
ASMAtomicDecU32(&pThis->cWaiters);
rc = VERR_TIMEOUT;
break;
case ERROR_INTERRUPT:
Assert(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
ASMAtomicDecU32(&pThis->cWaiters);
rc = VERR_INTERRUPTED;
break;
default:
AssertMsgFailed(("rc=%d\n", rc));
rc = VERR_GENERAL_FAILURE;
break;
}
}
KernReleaseSpinLock(&pThis->Spinlock);
return rc;
}
/**
* Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventWaitEx.
* @param uTimeout See RTSemEventWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventWait(PRTSEMEVENTINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
int rc;
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventBsdRetain(pThis);
/*
* Try grab the event without setting up the wait.
*/
if (ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else
{
/*
* We have to wait.
*/
RTR0SEMBSDSLEEP Wait;
rc = rtR0SemBsdWaitInit(&Wait, fFlags, uTimeout, pThis);
if (RT_SUCCESS(rc))
{
for (;;)
{
/* The destruction test. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else
{
rtR0SemBsdWaitPrepare(&Wait);
/* Check the exit conditions. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENT_MAGIC))
rc = VERR_SEM_DESTROYED;
else if (ASMAtomicCmpXchgU32(&pThis->fState, 0, 1))
rc = VINF_SUCCESS;
else if (rtR0SemBsdWaitHasTimedOut(&Wait))
rc = VERR_TIMEOUT;
else if (rtR0SemBsdWaitWasInterrupted(&Wait))
rc = VERR_INTERRUPTED;
else
{
/* Do the wait and then recheck the conditions. */
rtR0SemBsdWaitDoIt(&Wait);
continue;
}
}
break;
}
rtR0SemBsdWaitDelete(&Wait);
}
}
rtR0SemEventBsdRelease(pThis);
return rc;
}
DECLINLINE(int) rtSemEventLnxMultiWait(struct RTSEMEVENTMULTIINTERNAL *pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
/*
* Validate input.
*/
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
/*
* Quickly check whether it's signaled.
*/
int32_t iCur = ASMAtomicUoReadS32(&pThis->iState);
Assert(iCur == 0 || iCur == -1 || iCur == 1);
if (iCur == -1)
return VINF_SUCCESS;
/*
* Check and convert the timeout value.
*/
struct timespec ts;
struct timespec *pTimeout = NULL;
uint64_t u64Deadline = 0; /* shut up gcc */
if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
{
/* If the timeout is zero, then we're done. */
if (!uTimeout)
return VERR_TIMEOUT;
/* Convert it to a deadline + interval timespec. */
if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
? uTimeout * UINT32_C(1000000)
: UINT64_MAX;
if (uTimeout != UINT64_MAX) /* unofficial way of indicating an indefinite wait */
{
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
u64Deadline = RTTimeSystemNanoTS() + uTimeout;
else
{
uint64_t u64Now = RTTimeSystemNanoTS();
if (uTimeout <= u64Now)
return VERR_TIMEOUT;
u64Deadline = uTimeout;
uTimeout -= u64Now;
}
if ( sizeof(ts.tv_sec) >= sizeof(uint64_t)
|| uTimeout <= UINT64_C(1000000000) * UINT32_MAX)
{
ts.tv_nsec = uTimeout % UINT32_C(1000000000);
ts.tv_sec = uTimeout / UINT32_C(1000000000);
pTimeout = &ts;
}
}
}
/*
* The wait loop.
*/
#ifdef RTSEMEVENTMULTI_STRICT
RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt();
#else
RTTHREAD hThreadSelf = RTThreadSelf();
#endif
for (unsigned i = 0;; i++)
{
/*
* Start waiting. We only account for there being or having been
* threads waiting on the semaphore to keep things simple.
*/
iCur = ASMAtomicUoReadS32(&pThis->iState);
Assert(iCur == 0 || iCur == -1 || iCur == 1);
if ( iCur == 1
|| ASMAtomicCmpXchgS32(&pThis->iState, 1, 0))
{
/* adjust the relative timeout */
if (pTimeout)
{
int64_t i64Diff = u64Deadline - RTTimeSystemNanoTS();
if (i64Diff < 1000)
return VERR_TIMEOUT;
ts.tv_sec = (uint64_t)i64Diff / UINT32_C(1000000000);
ts.tv_nsec = (uint64_t)i64Diff % UINT32_C(1000000000);
}
#ifdef RTSEMEVENTMULTI_STRICT
if (pThis->fEverHadSignallers)
{
int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false,
uTimeout / UINT32_C(1000000), RTTHREADSTATE_EVENT_MULTI, true);
if (RT_FAILURE(rc9))
return rc9;
}
#endif
RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true);
long rc = sys_futex(&pThis->iState, FUTEX_WAIT, 1, pTimeout, NULL, 0);
RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI);
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
return VERR_SEM_DESTROYED;
if (rc == 0)
return VINF_SUCCESS;
/*
* Act on the wakup code.
*/
if (rc == -ETIMEDOUT)
{
/** @todo something is broken here. shows up every now and again in the ata
* code. Should try to run the timeout against RTTimeMilliTS to
* check that it's doing the right thing... */
Assert(pTimeout);
return VERR_TIMEOUT;
}
if (rc == -EWOULDBLOCK)
/* retry, the value changed. */;
else if (rc == -EINTR)
{
if (fFlags & RTSEMWAIT_FLAGS_NORESUME)
return VERR_INTERRUPTED;
}
else
{
/* this shouldn't happen! */
AssertMsgFailed(("rc=%ld errno=%d\n", rc, errno));
return RTErrConvertFromErrno(rc);
}
}
else if (iCur == -1)
return VINF_SUCCESS;
}
}
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiSolWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
uint32_t fOrgStateAndGen;
int rc;
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventMultiSolRetain(pThis);
mutex_enter(&pThis->Mtx); /* this could be moved down to the else, but play safe for now. */
/*
* Is the event already signalled or do we have to wait?
*/
fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
if (fOrgStateAndGen & RTSEMEVENTMULTISOL_STATE_MASK)
rc = VINF_SUCCESS;
else
{
/*
* We have to wait.
*/
RTR0SEMSOLWAIT Wait;
rc = rtR0SemSolWaitInit(&Wait, fFlags, uTimeout);
if (RT_SUCCESS(rc))
{
for (;;)
{
/* The destruction test. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
rc = VERR_SEM_DESTROYED;
else
{
/* Check the exit conditions. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
rc = VERR_SEM_DESTROYED;
else if (ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen)
rc = VINF_SUCCESS;
else if (rtR0SemSolWaitHasTimedOut(&Wait))
rc = VERR_TIMEOUT;
else if (rtR0SemSolWaitWasInterrupted(&Wait))
rc = VERR_INTERRUPTED;
else
{
/* Do the wait and then recheck the conditions. */
rtR0SemSolWaitDoIt(&Wait, &pThis->Cnd, &pThis->Mtx, &pThis->fStateAndGen, fOrgStateAndGen);
continue;
}
}
break;
}
rtR0SemSolWaitDelete(&Wait);
}
}
mutex_exit(&pThis->Mtx);
rtR0SemEventMultiSolRelease(pThis);
return rc;
}
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiDarwinWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
/*
* Validate input.
*/
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic), VERR_INVALID_HANDLE);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
if (uTimeout != 0 || (fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
RT_ASSERT_PREEMPTIBLE();
rtR0SemEventMultiDarwinRetain(pThis);
lck_spin_lock(pThis->pSpinlock);
/*
* Is the event already signalled or do we have to wait?
*/
int rc;
uint32_t const fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
if (fOrgStateAndGen & RTSEMEVENTMULTIDARWIN_STATE_MASK)
rc = VINF_SUCCESS;
else
{
/*
* We have to wait. So, we'll need to convert the timeout and figure
* out if it's indefinite or not.
*/
uint64_t uNsAbsTimeout = 1;
if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
{
if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
? uTimeout * UINT32_C(1000000)
: UINT64_MAX;
if (uTimeout == UINT64_MAX)
fFlags |= RTSEMWAIT_FLAGS_INDEFINITE;
else
{
uint64_t u64Now;
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
{
if (uTimeout != 0)
{
u64Now = RTTimeSystemNanoTS();
uNsAbsTimeout = u64Now + uTimeout;
if (uNsAbsTimeout < u64Now) /* overflow */
fFlags |= RTSEMWAIT_FLAGS_INDEFINITE;
}
}
else
{
uNsAbsTimeout = uTimeout;
u64Now = RTTimeSystemNanoTS();
uTimeout = u64Now < uTimeout ? uTimeout - u64Now : 0;
}
}
}
if ( !(fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
&& uTimeout == 0)
{
/*
* Poll call, we already checked the condition above so no need to
* wait for anything.
*/
rc = VERR_TIMEOUT;
}
else
{
for (;;)
{
/*
* Do the actual waiting.
*/
ASMAtomicWriteBool(&pThis->fHaveBlockedThreads, true);
wait_interrupt_t fInterruptible = fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE ? THREAD_ABORTSAFE : THREAD_UNINT;
wait_result_t rcWait;
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
rcWait = lck_spin_sleep(pThis->pSpinlock, LCK_SLEEP_DEFAULT, (event_t)pThis, fInterruptible);
else
{
uint64_t u64AbsTime;
nanoseconds_to_absolutetime(uNsAbsTimeout, &u64AbsTime);
rcWait = lck_spin_sleep_deadline(pThis->pSpinlock, LCK_SLEEP_DEFAULT,
(event_t)pThis, fInterruptible, u64AbsTime);
}
/*
* Deal with the wait result.
*/
if (RT_LIKELY(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC))
{
switch (rcWait)
{
case THREAD_AWAKENED:
if (RT_LIKELY(ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen))
rc = VINF_SUCCESS;
else if (fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE)
rc = VERR_INTERRUPTED;
else
continue; /* Seen this happen after fork/exec/something. */
break;
case THREAD_TIMED_OUT:
Assert(!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE));
rc = VERR_TIMEOUT;
break;
case THREAD_INTERRUPTED:
Assert(fInterruptible != THREAD_UNINT);
rc = VERR_INTERRUPTED;
break;
case THREAD_RESTART:
AssertMsg(pThis->u32Magic == ~RTSEMEVENTMULTI_MAGIC, ("%#x\n", pThis->u32Magic));
rc = VERR_SEM_DESTROYED;
break;
default:
AssertMsgFailed(("rcWait=%d\n", rcWait));
rc = VERR_INTERNAL_ERROR_3;
break;
}
}
else
rc = VERR_SEM_DESTROYED;
break;
}
}
}
lck_spin_unlock(pThis->pSpinlock);
rtR0SemEventMultiDarwinRelease(pThis);
return rc;
}
/**
* Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventMultiWaitEx.
* @param uTimeout See RTSemEventMultiWaitEx.
* @param pSrcPos The source code position of the wait.
*/
static int rtR0SemEventMultiLnxWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
uint32_t fOrgStateAndGen;
int rc;
/*
* Validate the input.
*/
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventMultiLnxRetain(pThis);
/*
* Is the event already signalled or do we have to wait?
*/
fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
if (fOrgStateAndGen & RTSEMEVENTMULTILNX_STATE_MASK)
rc = VINF_SUCCESS;
else
{
/*
* We have to wait.
*/
RTR0SEMLNXWAIT Wait;
rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
if (RT_SUCCESS(rc))
{
IPRT_DEBUG_SEMS_STATE(pThis, 'E');
for (;;)
{
/* The destruction test. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
rc = VERR_SEM_DESTROYED;
else
{
rtR0SemLnxWaitPrepare(&Wait);
/* Check the exit conditions. */
if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
rc = VERR_SEM_DESTROYED;
else if (ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen)
rc = VINF_SUCCESS;
else if (rtR0SemLnxWaitHasTimedOut(&Wait))
rc = VERR_TIMEOUT;
else if (rtR0SemLnxWaitWasInterrupted(&Wait))
rc = VERR_INTERRUPTED;
else
{
/* Do the wait and then recheck the conditions. */
rtR0SemLnxWaitDoIt(&Wait);
continue;
}
}
break;
}
rtR0SemLnxWaitDelete(&Wait);
IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
}
}
rtR0SemEventMultiLnxRelease(pThis);
return rc;
}
/**
* Worker for RTSemEventWaitEx and RTSemEventWaitExDebug.
*
* @returns VBox status code.
* @param pThis The event semaphore.
* @param fFlags See RTSemEventWaitEx.
* @param uTimeout See RTSemEventWaitEx.
* @param pSrcPos The source code position of the wait.
*/
DECLINLINE(int) rtR0SemEventNtWait(PRTSEMEVENTINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
PCRTLOCKVALSRCPOS pSrcPos)
{
/*
* Validate input.
*/
if (!pThis)
return VERR_INVALID_PARAMETER;
AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
AssertMsgReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
rtR0SemEventNtRetain(pThis);
/*
* Convert the timeout to a relative one because KeWaitForSingleObject
* takes system time instead of interrupt time as input for absolute
* timeout specifications. So, we're best of by giving it relative time.
*
* Lazy bird converts uTimeout to relative nanoseconds and then to Nt time.
*/
if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
{
if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
uTimeout = uTimeout < UINT64_MAX / UINT32_C(1000000) * UINT32_C(1000000)
? uTimeout * UINT32_C(1000000)
: UINT64_MAX;
if (uTimeout == UINT64_MAX)
fFlags |= RTSEMWAIT_FLAGS_INDEFINITE;
else
{
if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE)
{
uint64_t u64Now = RTTimeSystemNanoTS();
uTimeout = u64Now < uTimeout
? uTimeout - u64Now
: 0;
}
}
}
/*
* Wait for it.
* We're assuming interruptible waits should happen at UserMode level.
*/
NTSTATUS rcNt;
BOOLEAN fInterruptible = !!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE);
KPROCESSOR_MODE WaitMode = fInterruptible ? UserMode : KernelMode;
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, NULL);
else
{
LARGE_INTEGER Timeout;
Timeout.QuadPart = -(int64_t)(uTimeout / 100);
rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, &Timeout);
}
int rc;
if (pThis->u32Magic == RTSEMEVENT_MAGIC)
{
switch (rcNt)
{
case STATUS_SUCCESS:
rc = VINF_SUCCESS;
break;
case STATUS_ALERTED:
rc = VERR_INTERRUPTED;
break;
case STATUS_USER_APC:
rc = VERR_INTERRUPTED;
break;
case STATUS_TIMEOUT:
rc = VERR_TIMEOUT;
break;
default:
AssertMsgFailed(("pThis->u32Magic=%RX32 pThis=%p: wait returned %lx!\n",
pThis->u32Magic, pThis, (long)rcNt));
rc = VERR_INTERNAL_ERROR_4;
break;
}
}
else
rc = VERR_SEM_DESTROYED;
rtR0SemEventNtRelease(pThis);
return rc;
}
