Index: /trunk/include/iprt/semaphore.h =================================================================== --- /trunk/include/iprt/semaphore.h (revision 25639) +++ /trunk/include/iprt/semaphore.h (revision 25640) @@ -143,5 +143,5 @@ * @param hThread A previously added thread. */ -RTDECL(void) RTSemEventRemoverSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread); +RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread); /** @} */ @@ -211,4 +211,39 @@ */ RTDECL(int) RTSemEventMultiWaitNoResume(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies); + +/** + * Sets the signaller thread to one specific thread. + * + * This is only used for validating usage and deadlock detection. When used + * after calls to RTSemEventAddSignaller, the specified thread will be the only + * signalling thread. + * + * @param hEventMultiSem The multiple release event semaphore. + * @param hThread The thread that will signal it. Pass + * NIL_RTTHREAD to indicate that there is no + * special signalling thread. + */ +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread); + +/** + * To add more signalling threads. + * + * First call RTSemEventSetSignaller then add further threads with this. + * + * @param hEventMultiSem The multiple release event semaphore. + * @param hThread The thread that will signal it. NIL_RTTHREAD is + * not accepted. + */ +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread); + +/** + * To remove a signalling thread. + * + * Reverts work done by RTSemEventAddSignaller and RTSemEventSetSignaller. + * + * @param hEventMultiSem The multiple release event semaphore. + * @param hThread A previously added thread. + */ +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread); /** @} */ Index: /trunk/src/VBox/Runtime/r3/linux/semeventmulti-linux.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/linux/semeventmulti-linux.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/r3/linux/semeventmulti-linux.cpp (revision 25640) @@ -31,5 +31,5 @@ #include -#if __GLIBC_PREREQ(2,6) && !defined(IPRT_WITH_FUTEX_BASED_SEMS) +#if __GLIBC_PREREQ(2,6) && !defined(IPRT_WITH_FUTEX_BASED_SEMS) && !defined(DEBUG_bird) /* @@ -300,4 +300,20 @@ } + +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ + /** @todo implement RTSemEventMultiSetSignaller on OS/2 */ +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + #endif /* glibc < 2.6 || IPRT_WITH_FUTEX_BASED_SEMS */ Index: /trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/r3/os2/sems-os2.cpp (revision 25640) @@ -136,5 +136,5 @@ -RTDECL(void) RTSemEventRemoverSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) +RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) { @@ -313,3 +313,17 @@ - +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ + /** @todo implement RTSemEventMultiSetSignaller on OS/2 */ +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + Index: /trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/r3/posix/semeventmulti-posix.cpp (revision 25640) @@ -33,8 +33,13 @@ *******************************************************************************/ #include +#include "internal/iprt.h" + +#include #include -#include -#include #include +#include +#include + +#include "internal/strict.h" #include @@ -61,4 +66,10 @@ /** Number of waiters. */ volatile uint32_t cWaiters; +#ifdef RTSEMEVENTMULTI_STRICT + /** Signallers. */ + RTLOCKVALRECSHRD Signallers; + /** Indicates that lock validation should be performed. */ + bool volatile fEverHadSignallers; +#endif }; @@ -73,25 +84,4 @@ /** @} */ - - -/** - * Validate an event multi semaphore handle passed to one of the interface. - * - * @returns true if valid. - * @returns false if invalid. - * @param pThis Pointer to the event semaphore to validate. - */ -inline bool rtsemEventMultiValid(struct RTSEMEVENTMULTIINTERNAL *pThis) -{ - if ((uintptr_t)pThis < 0x10000) - return false; - - uint32_t u32 = pThis->u32State; /* this is volatile, so a explicit read like this is needed. */ - if ( u32 != EVENTMULTI_STATE_NOT_SIGNALED - && u32 != EVENTMULTI_STATE_SIGNALED) - return false; - - return true; -} @@ -131,4 +121,10 @@ ASMAtomicXchgU32(&pThis->u32State, EVENTMULTI_STATE_NOT_SIGNALED); ASMAtomicXchgU32(&pThis->cWaiters, 0); +#ifdef RTSEMEVENTMULTI_STRICT + RTLockValidatorRecSharedInit(&pThis->Signallers, + NIL_RTLOCKVALIDATORCLASS, RTLOCKVALIDATOR_SUB_CLASS_ANY, + "RTSemEvent", pThis, true /*fSignaller*/); + pThis->fEverHadSignallers = false; +#endif *pEventMultiSem = pThis; @@ -159,14 +155,14 @@ * Validate handle. */ - if (!rtsemEventMultiValid(EventMultiSem)) - { - AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem)); - return VERR_INVALID_HANDLE; - } + struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; + if (pThis == NIL_RTSEMEVENTMULTI) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + uint32_t u32 = pThis->u32State; + AssertReturn(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED, VERR_INVALID_HANDLE); /* * Abort all waiters forcing them to return failure. */ - struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; int rc; for (int i = 30; i > 0; i--) @@ -205,4 +201,7 @@ * Free the semaphore memory and be gone. */ +#ifdef RTSEMEVENTMULTI_STRICT + RTLockValidatorRecSharedDelete(&pThis->Signallers); +#endif RTMemFree(pThis); return VINF_SUCCESS; @@ -215,14 +214,21 @@ * Validate input. */ - if (!rtsemEventMultiValid(EventMultiSem)) - { - AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem)); - return VERR_INVALID_HANDLE; - } + struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + uint32_t u32 = pThis->u32State; + AssertReturn(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED, VERR_INVALID_HANDLE); + +#ifdef RTSEMEVENTMULTI_STRICT + if (pThis->fEverHadSignallers) + { + int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD); + if (RT_FAILURE(rc9)) + return rc9; + } +#endif /* * Lock the mutex semaphore. */ - struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; int rc = pthread_mutex_lock(&pThis->Mutex); if (rc) @@ -268,14 +274,12 @@ * Validate input. */ - if (!rtsemEventMultiValid(EventMultiSem)) - { - AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem)); - return VERR_INVALID_HANDLE; - } + struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + uint32_t u32 = pThis->u32State; + AssertReturn(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED, VERR_INVALID_HANDLE); /* * Lock the mutex semaphore. */ - struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; int rc = pthread_mutex_lock(&pThis->Mutex); if (rc) @@ -310,17 +314,17 @@ static int rtSemEventMultiWait(RTSEMEVENTMULTI EventMultiSem, unsigned cMillies, bool fAutoResume) { + PCRTLOCKVALSRCPOS pSrcPos = NULL; + /* * Validate input. */ - if (!rtsemEventMultiValid(EventMultiSem)) - { - AssertMsgFailed(("Invalid handle %p!\n", EventMultiSem)); - return VERR_INVALID_HANDLE; - } + struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; + AssertPtrReturn(pThis, VERR_INVALID_HANDLE); + uint32_t u32 = pThis->u32State; + AssertReturn(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED, VERR_INVALID_HANDLE); /* * Timed or indefinite wait? */ - struct RTSEMEVENTMULTIINTERNAL *pThis = EventMultiSem; if (cMillies == RT_INDEFINITE_WAIT) { @@ -352,5 +356,23 @@ /* wait */ +#ifdef RTSEMEVENTMULTI_STRICT + RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt(); + if (pThis->fEverHadSignallers) + { + rc = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false, + RTTHREADSTATE_EVENT_MULTI, true); + if (RT_FAILURE(rc)) + { + ASMAtomicDecU32(&pThis->cWaiters); + pthread_mutex_unlock(&pThis->Mutex); + return rc; + } + } +#else + RTTHREAD hThreadSelf = RTThreadSelf(); +#endif + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true); rc = pthread_cond_wait(&pThis->Cond, &pThis->Mutex); + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI); if (rc) { @@ -396,9 +418,5 @@ /* take mutex */ -#ifdef RT_OS_DARWIN int rc = pthread_mutex_lock(&pThis->Mutex); -#else - int rc = pthread_mutex_timedlock(&pThis->Mutex, &ts); -#endif if (rc) { @@ -425,6 +443,32 @@ } + /* we're done if the timeout is 0. */ + if (!cMillies) + { + ASMAtomicDecU32(&pThis->cWaiters); + rc = pthread_mutex_unlock(&pThis->Mutex); + return VERR_SEM_BUSY; + } + /* wait */ +#ifdef RTSEMEVENTMULTI_STRICT + RTTHREAD hThreadSelf = RTThreadSelfAutoAdopt(); + if (pThis->fEverHadSignallers) + { + rc = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, pSrcPos, false, + RTTHREADSTATE_EVENT_MULTI, true); + if (RT_FAILURE(rc)) + { + ASMAtomicDecU32(&pThis->cWaiters); + pthread_mutex_unlock(&pThis->Mutex); + return rc; + } + } +#else + RTTHREAD hThreadSelf = RTThreadSelf(); +#endif + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true); rc = pthread_cond_timedwait(&pThis->Cond, &pThis->Mutex, &ts); + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI); if (rc && (rc != EINTR || !fAutoResume)) /* according to SuS this function shall not return EINTR, but linux man page says differently. */ { @@ -453,2 +497,43 @@ } + +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENTMULTI_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + uint32_t u32 = pThis->u32State; + AssertReturnVoid(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL); +#endif +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENTMULTI_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + uint32_t u32 = pThis->u32State; + AssertReturnVoid(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL); +#endif +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +#ifdef RTSEMEVENTMULTI_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + uint32_t u32 = pThis->u32State; + AssertReturnVoid(u32 == EVENTMULTI_STATE_NOT_SIGNALED || u32 == EVENTMULTI_STATE_SIGNALED); + + RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread); +#endif +} + Index: /trunk/src/VBox/Runtime/r3/win/semevent-win.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/win/semevent-win.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/r3/win/semevent-win.cpp (revision 25640) @@ -137,5 +137,5 @@ -RTDECL(void) RTSemEventRemoverSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) +RTDECL(void) RTSemEventRemoveSignaller(RTSEMEVENT hEventSem, RTTHREAD hThread) { Index: /trunk/src/VBox/Runtime/r3/win/semeventmulti-win.cpp =================================================================== --- /trunk/src/VBox/Runtime/r3/win/semeventmulti-win.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/r3/win/semeventmulti-win.cpp (revision 25640) @@ -132,2 +132,18 @@ } + +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ + /** @todo implement RTSemEventMultiSetSignaller on Windows */ +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +} + Index: /trunk/src/VBox/Runtime/testcase/tstRTLockValidator.cpp =================================================================== --- /trunk/src/VBox/Runtime/testcase/tstRTLockValidator.cpp (revision 25639) +++ /trunk/src/VBox/Runtime/testcase/tstRTLockValidator.cpp (revision 25640) @@ -630,4 +630,56 @@ +static DECLCALLBACK(int) test7Thread(RTTHREAD ThreadSelf, void *pvUser) +{ + uintptr_t i = (uintptr_t)pvUser; + PRTCRITSECT pMine = &g_aCritSects[i]; + PRTCRITSECT pNext = &g_aCritSects[(i + 1) % g_cThreads]; + + RTTEST_CHECK_RC_RET(g_hTest, RTCritSectEnter(pMine), VINF_SUCCESS, rcCheck); + if (i & 1) + RTTEST_CHECK_RC(g_hTest, RTCritSectEnter(pMine), VINF_SUCCESS); + if (testWaitForCritSectToBeOwned(pNext)) + { + int rc; + if (i != g_iDeadlockThread) + { + RTTEST_CHECK_RC(g_hTest, rc = RTCritSectEnter(pNext), VINF_SUCCESS); + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + if (RT_SUCCESS(rc)) + RTTEST_CHECK_RC(g_hTest, rc = RTCritSectLeave(pNext), VINF_SUCCESS); + } + else + { + RTTEST_CHECK_RC_OK(g_hTest, rc = testWaitForAllOtherThreadsToSleep(RTTHREADSTATE_CRITSECT, 1)); + if (RT_SUCCESS(rc)) + { + RTSemEventMultiSetSignaller(g_hSemEvtMulti, g_ahThreads[0]); + for (uint32_t iThread = 1; iThread < g_cThreads; iThread++) + RTSemEventMultiAddSignaller(g_hSemEvtMulti, g_ahThreads[iThread]); + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + RTTEST_CHECK_RC(g_hTest, RTSemEventMultiReset(g_hSemEvtMulti), VINF_SUCCESS); + RTTEST_CHECK_RC(g_hTest, RTSemEventMultiWait(g_hSemEvtMulti, 10*1000), VERR_SEM_LV_DEADLOCK); + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + RTTEST_CHECK_RC(g_hTest, RTSemEventMultiSignal(g_hSemEvtMulti), VINF_SUCCESS); + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + RTTEST_CHECK_RC(g_hTest, RTSemEventMultiWait(g_hSemEvtMulti, 10*1000), VINF_SUCCESS); + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + RTSemEventMultiSetSignaller(g_hSemEvtMulti, NIL_RTTHREAD); + } + } + RTTEST_CHECK(g_hTest, RTThreadGetState(RTThreadSelf()) == RTTHREADSTATE_RUNNING); + } + if (i & 1) + RTTEST_CHECK_RC(g_hTest, RTCritSectLeave(pMine), VINF_SUCCESS); + RTTEST_CHECK_RC(g_hTest, RTCritSectLeave(pMine), VINF_SUCCESS); + return VINF_SUCCESS; +} + + +static void test7(uint32_t cThreads, uint32_t cPasses) +{ + testIt(cThreads, cPasses, 0, test7Thread, "event multi"); +} + static bool testIsLockValidationCompiledIn(void) { @@ -669,4 +721,14 @@ RTTEST_CHECK_RET(g_hTest, RT_FAILURE_NP(rc), false); RTTEST_CHECK_RC_OK_RET(g_hTest, RTSemEventDestroy(hSemEvt), false); + + RTSEMEVENTMULTI hSemEvtMulti; + RTTEST_CHECK_RC_OK_RET(g_hTest, RTSemEventMultiCreate(&hSemEvtMulti), false); + RTSemEventMultiSetSignaller(hSemEvtMulti, RTThreadSelf()); + RTSemEventMultiSetSignaller(hSemEvtMulti, NIL_RTTHREAD); + rc = RTSemEventMultiSignal(hSemEvtMulti); + if (rc != VERR_SEM_LV_NOT_SIGNALLER) + fRet = false; + RTTEST_CHECK_RET(g_hTest, RT_FAILURE_NP(rc), false); + RTTEST_CHECK_RC_OK_RET(g_hTest, RTSemEventMultiDestroy(hSemEvtMulti), false); return fRet; @@ -703,4 +765,5 @@ test6(3, 1); #endif + test7(3, 1); /* @@ -708,4 +771,5 @@ */ RTLockValidatorSetQuiet(true); +#if 1 test1( 2, 256); /* 256 * 4ms = 1s (approx); 4ms == fudge factor */ test1( 3, 256); @@ -715,5 +779,4 @@ test1(30, 256); -#if 1 test2( 1, 256); test2( 2, 256); @@ -738,5 +801,4 @@ test5(15, 256); test5(30, 256); -#endif test6( 2, 256); @@ -746,4 +808,14 @@ test6(15, 256); test6(30, 256); +#endif + +#if 1 + test7( 2, 256); + test7( 3, 256); + test7( 7, 256); + test7(10, 256); + test7(15, 256); + test7(30, 256); +#endif return RTTestSummaryAndDestroy(g_hTest);