RTDECL(int) RTSemRWDestroy(RTSEMRW hRWSem)
{
/*
* Validate input.
*/
RTSEMRWINTERNAL *pThis = hRWSem;
if (pThis == NIL_RTSEMRW)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
Assert(!(ASMAtomicReadU64(&pThis->u64State) & (RTSEMRW_CNT_RD_MASK | RTSEMRW_CNT_WR_MASK)));
/*
* Invalidate the object and free up the resources.
*/
AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMRW_MAGIC, RTSEMRW_MAGIC), VERR_INVALID_HANDLE);
RTSEMEVENTMULTI hEvtRead;
ASMAtomicXchgHandle(&pThis->hEvtRead, NIL_RTSEMEVENTMULTI, &hEvtRead);
int rc = RTSemEventMultiDestroy(hEvtRead);
AssertRC(rc);
RTSEMEVENT hEvtWrite;
ASMAtomicXchgHandle(&pThis->hEvtWrite, NIL_RTSEMEVENT, &hEvtWrite);
rc = RTSemEventDestroy(hEvtWrite);
AssertRC(rc);
#ifdef RTSEMRW_STRICT
RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
#endif
RTMemFree(pThis);
return VINF_SUCCESS;
}
RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
{
/*
* Validate input.
*/
struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem;
if (pThis == NIL_RTSEMEVENTMULTI)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, VERR_INVALID_HANDLE);
/*
* Invalidate the semaphore and wake up anyone waiting on it.
*/
ASMAtomicWriteU32(&pThis->u32Magic, RTSEMEVENTMULTI_MAGIC + 1);
if (ASMAtomicXchgS32(&pThis->iState, -1) == 1)
{
sys_futex(&pThis->iState, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
usleep(1000);
}
/*
* Free the semaphore memory and be gone.
*/
#ifdef RTSEMEVENTMULTI_STRICT
RTLockValidatorRecSharedDelete(&pThis->Signallers);
#endif
RTMemFree(pThis);
return VINF_SUCCESS;
}
RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem)
{
/*
* Validate input.
*/
struct RTSEMEVENTINTERNAL *pThis = hEventSem;
if (pThis == NIL_RTSEMEVENT)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->iMagic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE);
/*
* Invalidate the semaphore and wake up anyone waiting on it.
*/
ASMAtomicXchgSize(&pThis->iMagic, RTSEMEVENT_MAGIC | UINT32_C(0x80000000));
if (ASMAtomicXchgS32(&pThis->cWaiters, INT32_MIN / 2) > 0)
{
sys_futex(&pThis->fSignalled, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
usleep(1000);
}
/*
* Free the semaphore memory and be gone.
*/
#ifdef RTSEMEVENT_STRICT
RTLockValidatorRecSharedDelete(&pThis->Signallers);
#endif
if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
RTMemFree(pThis);
else
rtMemBaseFree(pThis);
return VINF_SUCCESS;
}
RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem)
{
struct RTSEMEVENTINTERNAL *pThis = hEventSem;
if (pThis == NIL_RTSEMEVENT)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMEVENT_MAGIC, VERR_INVALID_HANDLE);
/*
* Invalidate the handle and close the semaphore.
*/
int rc = VINF_SUCCESS;
AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMEVENT_MAGIC, RTSEMEVENT_MAGIC), VERR_INVALID_HANDLE);
if (CloseHandle(pThis->hev))
{
#ifdef RTSEMEVENT_STRICT
RTLockValidatorRecSharedDelete(&pThis->Signallers);
#endif
if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
RTMemFree(pThis);
else
rtMemBaseFree(pThis);
}
else
{
DWORD dwErr = GetLastError();
rc = RTErrConvertFromWin32(dwErr);
AssertMsgFailed(("Destroy hEventSem %p failed, lasterr=%u (%Rrc)\n", pThis, dwErr, rc));
/* Leak it. */
}
return rc;
}
RTDECL(int) RTSemEventDestroy(RTSEMEVENT hEventSem)
{
/*
* Validate handle.
*/
struct RTSEMEVENTINTERNAL *pThis = hEventSem;
if (pThis == NIL_RTSEMEVENT)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
uint32_t u32 = pThis->u32State;
AssertReturn(u32 == EVENT_STATE_NOT_SIGNALED || u32 == EVENT_STATE_SIGNALED, VERR_INVALID_HANDLE);
/*
* Abort all waiters forcing them to return failure.
*/
int rc;
for (int i = 30; i > 0; i--)
{
ASMAtomicWriteU32(&pThis->u32State, EVENT_STATE_UNINITIALIZED);
rc = pthread_cond_destroy(&pThis->Cond);
if (rc != EBUSY)
break;
pthread_cond_broadcast(&pThis->Cond);
usleep(1000);
}
if (rc)
{
AssertMsgFailed(("Failed to destroy event sem %p, rc=%d.\n", pThis, rc));
return RTErrConvertFromErrno(rc);
}
/*
* Destroy the semaphore
* If it's busy we'll wait a bit to give the threads a chance to be scheduled.
*/
for (int i = 30; i > 0; i--)
{
rc = pthread_mutex_destroy(&pThis->Mutex);
if (rc != EBUSY)
break;
usleep(1000);
}
if (rc)
{
AssertMsgFailed(("Failed to destroy event sem %p, rc=%d. (mutex)\n", pThis, rc));
return RTErrConvertFromErrno(rc);
}
/*
* Free the semaphore memory and be gone.
*/
#ifdef RTSEMEVENT_STRICT
RTLockValidatorRecSharedDelete(&pThis->Signallers);
#endif
if (!(pThis->fFlags & RTSEMEVENT_FLAGS_BOOTSTRAP_HACK))
RTMemFree(pThis);
else
rtMemBaseFree(pThis);
return VINF_SUCCESS;
}
RTDECL(int) RTSemRWDestroy(RTSEMRW hRWSem)
{
/*
* Validate input, nil handle is fine.
*/
struct RTSEMRWINTERNAL *pThis = hRWSem;
if (pThis == NIL_RTSEMRW)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertMsgReturn(pThis->u32Magic == RTSEMRW_MAGIC,
("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
VERR_INVALID_HANDLE);
Assert(pThis->Writer == (pthread_t)-1);
Assert(!pThis->cReaders);
Assert(!pThis->cWrites);
Assert(!pThis->cWriterReads);
/*
* Try destroy it.
*/
AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTSEMRW_MAGIC, RTSEMRW_MAGIC), VERR_INVALID_HANDLE);
int rc = pthread_rwlock_destroy(&pThis->RWLock);
if (!rc)
{
#ifdef RTSEMRW_STRICT
RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
#endif
RTMemFree(pThis);
rc = VINF_SUCCESS;
}
else
{
ASMAtomicWriteU32(&pThis->u32Magic, RTSEMRW_MAGIC);
AssertMsgFailed(("Failed to destroy read-write sem %p, rc=%d.\n", hRWSem, rc));
rc = RTErrConvertFromErrno(rc);
}
return rc;
}
RTDECL(int) RTSemRWDestroy(RTSEMRW hRWSem)
{
struct RTSEMRWINTERNAL *pThis = hRWSem;
/*
* Validate handle.
*/
if (pThis == NIL_RTSEMRW)
return VINF_SUCCESS;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
/*
* Check if busy.
*/
int rc = RTCritSectTryEnter(&pThis->CritSect);
if (RT_SUCCESS(rc))
{
if (!pThis->cReads && !pThis->cWrites)
{
/*
* Make it invalid and unusable.
*/
ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMRW_MAGIC);
pThis->cReads = ~0;
/*
* Do actual cleanup. None of these can now fail.
*/
rc = RTSemEventMultiDestroy(pThis->ReadEvent);
AssertMsgRC(rc, ("RTSemEventMultiDestroy failed! rc=%Rrc\n", rc));
pThis->ReadEvent = NIL_RTSEMEVENTMULTI;
rc = RTSemEventDestroy(pThis->WriteEvent);
AssertMsgRC(rc, ("RTSemEventDestroy failed! rc=%Rrc\n", rc));
pThis->WriteEvent = NIL_RTSEMEVENT;
RTCritSectLeave(&pThis->CritSect);
rc = RTCritSectDelete(&pThis->CritSect);
AssertMsgRC(rc, ("RTCritSectDelete failed! rc=%Rrc\n", rc));
#ifdef RTSEMRW_STRICT
RTLockValidatorRecSharedDelete(&pThis->ValidatorRead);
RTLockValidatorRecExclDelete(&pThis->ValidatorWrite);
#endif
RTMemFree(pThis);
rc = VINF_SUCCESS;
}
else
{
rc = VERR_SEM_BUSY;
RTCritSectLeave(&pThis->CritSect);
}
}
else
{
AssertMsgRC(rc, ("RTCritSectTryEnter failed! rc=%Rrc\n", rc));
rc = VERR_SEM_BUSY;
}
return rc;
}
