RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
{
/*
* Validate input.
*/
struct RTSEMMUTEXINTERNAL *pThis = hMutexSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
#ifdef RTSEMMUTEX_STRICT
int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, pThis->cNestings == 1);
if (RT_FAILURE(rc9))
return rc9;
#endif
/*
* Check if nested.
*/
pthread_t Self = pthread_self();
if (RT_UNLIKELY( pThis->Owner != Self
|| pThis->cNestings == 0))
{
AssertMsgFailed(("Not owner of mutex %p!! Self=%08x Owner=%08x cNestings=%d\n",
pThis, Self, pThis->Owner, pThis->cNestings));
return VERR_NOT_OWNER;
}
/*
* If nested we'll just pop a nesting.
*/
if (pThis->cNestings > 1)
{
ASMAtomicDecU32(&pThis->cNestings);
return VINF_SUCCESS;
}
/*
* Clear the state. (cNestings == 1)
*/
pThis->Owner = (pthread_t)~0;
ASMAtomicWriteU32(&pThis->cNestings, 0);
/*
* Release the mutex.
*/
int32_t iNew = ASMAtomicDecS32(&pThis->iState);
if (RT_UNLIKELY(iNew != 0))
{
/* somebody is waiting, try wake up one of them. */
ASMAtomicXchgS32(&pThis->iState, 0);
(void)sys_futex(&pThis->iState, FUTEX_WAKE, 1, NULL, NULL, 0);
}
return VINF_SUCCESS;
}
RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
{
/*
* Validate input.
*/
struct RTSEMMUTEXINTERNAL *pThis = hMutexSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
#ifdef RTSEMMUTEX_STRICT
int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, pThis->cNesting == 1);
if (RT_FAILURE(rc9))
return rc9;
#endif
/*
* Check if nested.
*/
pthread_t Self = pthread_self();
if (RT_UNLIKELY( pThis->Owner != Self
|| pThis->cNesting == 0))
{
AssertMsgFailed(("Not owner of mutex %p!! Self=%08x Owner=%08x cNesting=%d\n",
pThis, Self, pThis->Owner, pThis->cNesting));
return VERR_NOT_OWNER;
}
/*
* If nested we'll just pop a nesting.
*/
if (pThis->cNesting > 1)
{
ASMAtomicDecU32(&pThis->cNesting);
return VINF_SUCCESS;
}
/*
* Clear the state. (cNesting == 1)
*/
pThis->Owner = (pthread_t)-1;
ASMAtomicWriteU32(&pThis->cNesting, 0);
/*
* Unlock mutex semaphore.
*/
int rc = pthread_mutex_unlock(&pThis->Mutex);
if (RT_UNLIKELY(rc))
{
AssertMsgFailed(("Failed to unlock mutex sem %p, rc=%d.\n", hMutexSem, rc)); NOREF(rc);
return RTErrConvertFromErrno(rc);
}
return VINF_SUCCESS;
}
RTDECL(int) RTSemRWReleaseWrite(RTSEMRW hRWSem)
{
/*
* Validate input.
*/
struct RTSEMRWINTERNAL *pThis = hRWSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertMsgReturn(pThis->u32Magic == RTSEMRW_MAGIC,
("pThis=%p u32Magic=%#x\n", pThis, pThis->u32Magic),
VERR_INVALID_HANDLE);
/*
* Verify ownership and implement recursion.
*/
pthread_t Self = pthread_self();
pthread_t Writer;
ATOMIC_GET_PTHREAD_T(&pThis->Writer, &Writer);
AssertMsgReturn(Writer == Self, ("pThis=%p\n", pThis), VERR_NOT_OWNER);
AssertReturn(pThis->cWriterReads == 0 || pThis->cWrites > 1, VERR_WRONG_ORDER);
if (pThis->cWrites > 1)
{
#ifdef RTSEMRW_STRICT
int rc9 = RTLockValidatorRecExclUnwind(&pThis->ValidatorWrite);
if (RT_FAILURE(rc9))
return rc9;
#endif
pThis->cWrites--;
return VINF_SUCCESS;
}
/*
* Try unlock it.
*/
#ifdef RTSEMRW_STRICT
int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorWrite, true);
if (RT_FAILURE(rc9))
return rc9;
#endif
pThis->cWrites--;
ATOMIC_SET_PTHREAD_T(&pThis->Writer, (pthread_t)-1);
int rc = pthread_rwlock_unlock(&pThis->RWLock);
if (rc)
{
AssertMsgFailed(("Failed write unlock read-write sem %p, rc=%d.\n", hRWSem, rc));
return RTErrConvertFromErrno(rc);
}
return VINF_SUCCESS;
}
RTDECL(int) RTSemMutexRelease(RTSEMMUTEX hMutexSem)
{
/*
* Validate.
*/
RTSEMMUTEXINTERNAL *pThis = hMutexSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMMUTEX_MAGIC, VERR_INVALID_HANDLE);
/*
* Check ownership and recursions.
*/
RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
RTNATIVETHREAD hNativeOwner;
ASMAtomicReadHandle(&pThis->hNativeOwner, &hNativeOwner);
if (RT_UNLIKELY(hNativeOwner != hNativeSelf))
{
AssertMsgFailed(("Not owner of mutex %p!! hNativeSelf=%RTntrd Owner=%RTntrd cRecursions=%d\n",
pThis, hNativeSelf, hNativeOwner, pThis->cRecursions));
return VERR_NOT_OWNER;
}
if (pThis->cRecursions > 1)
{
#ifdef RTSEMMUTEX_STRICT
int rc9 = RTLockValidatorRecExclUnwind(&pThis->ValidatorRec);
if (RT_FAILURE(rc9))
return rc9;
#endif
ASMAtomicDecU32(&pThis->cRecursions);
return VINF_SUCCESS;
}
/*
* Unlock mutex semaphore.
*/
#ifdef RTSEMMUTEX_STRICT
int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorRec, false);
if (RT_FAILURE(rc9))
return rc9;
#endif
ASMAtomicWriteU32(&pThis->cRecursions, 0);
ASMAtomicWriteHandle(&pThis->hNativeOwner, NIL_RTNATIVETHREAD);
if (ReleaseMutex(pThis->hMtx))
return VINF_SUCCESS;
int rc = RTErrConvertFromWin32(GetLastError());
AssertMsgFailed(("%p/%p, rc=%Rrc lasterr=%d\n", pThis, pThis->hMtx, rc, GetLastError()));
return rc;
}
RTDECL(int) RTCritSectLeave(PRTCRITSECT pCritSect)
{
/*
* Assert sanity and check for NOP.
*/
Assert(pCritSect);
Assert(pCritSect->u32Magic == RTCRITSECT_MAGIC);
if (pCritSect->fFlags & RTCRITSECT_FLAGS_NOP)
return VINF_SUCCESS;
/*
* Assert ownership and so on.
*/
Assert(pCritSect->cNestings > 0);
Assert(pCritSect->cLockers >= 0);
Assert(pCritSect->NativeThreadOwner == RTThreadNativeSelf());
#ifdef RTCRITSECT_STRICT
int rc9 = RTLockValidatorRecExclReleaseOwner(pCritSect->pValidatorRec, pCritSect->cNestings == 1);
if (RT_FAILURE(rc9))
return rc9;
#endif
/*
* Decrement nestings, if <= 0 when we'll release the critsec.
*/
pCritSect->cNestings--;
if (pCritSect->cNestings > 0)
ASMAtomicDecS32(&pCritSect->cLockers);
else
{
/*
* Set owner to zero.
* Decrement waiters, if >= 0 then we have to wake one of them up.
*/
ASMAtomicWriteHandle(&pCritSect->NativeThreadOwner, NIL_RTNATIVETHREAD);
if (ASMAtomicDecS32(&pCritSect->cLockers) >= 0)
{
int rc = RTSemEventSignal(pCritSect->EventSem);
AssertReleaseMsg(RT_SUCCESS(rc), ("RTSemEventSignal -> %Rrc\n", rc));
}
}
return VINF_SUCCESS;
}
RTDECL(int) RTSemRWReleaseWrite(RTSEMRW hRWSem)
{
/*
* Validate handle.
*/
struct RTSEMRWINTERNAL *pThis = hRWSem;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTSEMRW_MAGIC, VERR_INVALID_HANDLE);
/*
* Take critsect.
*/
int rc = RTCritSectEnter(&pThis->CritSect);
AssertRCReturn(rc, rc);
/*
* Check if owner.
*/
RTNATIVETHREAD hNativeSelf = pThis->CritSect.NativeThreadOwner;
if (pThis->hWriter != hNativeSelf)
{
RTCritSectLeave(&pThis->CritSect);
AssertMsgFailed(("Not read-write owner of rwsem %p.\n", hRWSem));
return VERR_NOT_OWNER;
}
#ifdef RTSEMRW_STRICT
if (pThis->cWrites > 1 || !pThis->cWriterReads) /* don't check+release if VERR_WRONG_ORDER */
{
int rc9 = RTLockValidatorRecExclReleaseOwner(&pThis->ValidatorWrite, pThis->cWrites == 1);
if (RT_FAILURE(rc9))
{
RTCritSectLeave(&pThis->CritSect);
return rc9;
}
}
#endif
/*
* Release ownership and remove ourselves from the writers count.
*/
Assert(pThis->cWrites > 0);
pThis->cWrites--;
if (!pThis->cWrites)
{
if (RT_UNLIKELY(pThis->cWriterReads > 0))
{
pThis->cWrites++;
RTCritSectLeave(&pThis->CritSect);
AssertMsgFailed(("All recursive read locks need to be released prior to the final write lock! (%p)n\n", pThis));
return VERR_WRONG_ORDER;
}
pThis->hWriter = NIL_RTNATIVETHREAD;
}
/*
* Release the readers if no more writers waiting, otherwise the writers.
*/
if (!pThis->cWritesWaiting)
{
rc = RTSemEventMultiSignal(pThis->ReadEvent);
AssertMsgRC(rc, ("RTSemEventMultiSignal failed for rwsem %p, rc=%Rrc.\n", hRWSem, rc));
pThis->fNeedResetReadEvent = true;
}
else
{
rc = RTSemEventSignal(pThis->WriteEvent);
AssertMsgRC(rc, ("Failed to signal writers on rwsem %p, rc=%Rrc\n", hRWSem, rc));
}
RTCritSectLeave(&pThis->CritSect);
return rc;
}
