/* $Id$ */
/** @file
* IPRT Testcase - RTLockValidator.
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include <iprt/lockvalidator.h>
#include <iprt/critsect.h>
#include <iprt/semaphore.h>
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
/*******************************************************************************
* Global Variables *
*******************************************************************************/
/** The testcase handle. */
/** Flip this in the debugger to get some peace to single step wild code. */
bool volatile g_fDoNotSpin = false;
/** Set when the main thread wishes to terminate the test. */
bool volatile g_fShutdown = false;
/** The number of threads. */
/** Multiple release event semaphore that is signalled by the main thread after
* it has started all the threads. */
/** The number of threads that have called testThreadBlocking */
/** Multiple release event semaphore that is signalled by the last thread to
* call testThreadBlocking. testWaitForAllOtherThreadsToSleep waits on this. */
/** When to stop testing. */
/** The number of deadlocks. */
/** The number of loops. */
/**
* Spin until the callback stops returning VERR_TRY_AGAIN.
*
* @returns Callback result. VERR_TIMEOUT if too much time elapses.
* @param pfnCallback Callback for checking the state.
* @param pvWhat Callback parameter.
*/
{
{
{
return rc;
}
if (!g_fDoNotSpin)
}
}
{
if (!RTCritSectIsInitialized(pCritSect))
return VERR_SEM_DESTROYED;
if (RTCritSectIsOwned(pCritSect))
return VINF_SUCCESS;
return VERR_TRY_AGAIN;
}
{
}
{
if (RTSemRWGetWriteRecursion(hSemRW) > 0)
return VINF_SUCCESS;
if (RTSemRWGetReadCount(hSemRW) > 0)
return VINF_SUCCESS;
return VERR_TRY_AGAIN;
}
{
}
{
if (RTSemMutexIsOwned(hSemRW))
return VINF_SUCCESS;
return VERR_TRY_AGAIN;
}
{
}
/**
* For reducing spin in testWaitForAllOtherThreadsToSleep.
*/
static void testThreadBlocking(void)
{
}
/**
* Waits for all the other threads to enter sleeping states.
*
* @returns VINF_SUCCESS on success, VERR_INTERNAL_ERROR on failure.
* @param enmDesiredState The desired thread sleep state.
* @param cWaitOn The distance to the lock they'll be waiting on,
* the lock type is derived from the desired state.
* UINT32_MAX means no special lock.
*/
{
{
for (uint32_t i = 0; i < g_cThreads; i++)
{
if (hThread == NIL_RTTHREAD)
cMissing++;
else if (hThread != hThreadSelf)
{
/*
* Figure out which lock to wait for.
*/
if (cWaitOn != UINT32_MAX)
{
switch (enmDesiredState)
{
case RTTHREADSTATE_RW_WRITE:
default: break;
}
}
/*
* Wait for this thread.
*/
{
if (RTTHREAD_IS_SLEEPING(enmState))
{
if ( enmState == enmDesiredState
&& ( !pvLock
)
)
break;
}
else if ( enmState != RTTHREADSTATE_RUNNING
return VERR_INTERNAL_ERROR;
cWaitedOn++;
}
}
}
break;
}
RTThreadSleep(0); /* fudge factor */
return VINF_SUCCESS;
}
/**
* Worker that starts the threads.
*
* @returns Same as RTThreadCreate.
* @param cThreads The number of threads to start.
* @param pfnThread Thread function.
*/
{
g_ahThreads[i] = NIL_RTTHREAD;
{
if (RT_FAILURE(rc))
break;
}
return rc;
}
/**
* Worker that waits for the threads to complete.
*
* @param cMillies How long to wait for each.
* @param fStopOnError Whether to stop on error and heed the thread
* return status.
*/
{
while (i-- > 0)
if (g_ahThreads[i] != NIL_RTTHREAD)
{
int rcThread;
int rc2;
if (RT_SUCCESS(rc2))
g_ahThreads[i] = NIL_RTTHREAD;
return;
}
}
static void testIt(uint32_t cThreads, uint32_t cSecs, bool fLoops, PFNRTTHREAD pfnThread, const char *pszName)
{
/*
* Init test.
*/
if (cSecs > 0)
else
g_fShutdown = false;
{
RTTEST_CHECK_RC_RETV(g_hTest, RTSemMutexCreateEx(&g_ahSemMtxes[i], 0 /*fFlags*/, NIL_RTLOCKVALCLASS,
}
/*
* The test loop.
*/
do
{
g_cLoops = 0;
g_cDeadlocks = 0;
g_cThreadsBlocking = 0;
if (RT_SUCCESS(rc))
{
testWaitForThreads(TEST_DEBUG_TIMEOUT, true);
}
cPasses++;
&& !fLoops
&& RTTimeNanoTS() < g_NanoTSStop);
/*
* Cleanup.
*/
ASMAtomicWriteBool(&g_fShutdown, true);
{
}
testWaitForThreads(TEST_SMALL_TIMEOUT, false);
/*
* Print results if applicable.
*/
if (cSecs)
{
if (fLoops)
else
}
}
{
if (!(i & 1))
{
int rc;
if (i != g_iDeadlockThread)
{
}
else
{
if (RT_SUCCESS(rc))
}
if (RT_SUCCESS(rc))
}
if (!(i & 1))
return VINF_SUCCESS;
}
{
}
{
int rc;
if (i & 1)
{
RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hMine, RT_INDEFINITE_WAIT), VINF_SUCCESS, rcCheck);
if ((i & 3) == 3)
}
else
{
if (i != g_iDeadlockThread)
{
}
else
{
if (RT_SUCCESS(rc))
{
if (g_cThreads > 1)
RTTEST_CHECK_RC(g_hTest, rc = RTSemRWRequestWrite(hNext, RT_INDEFINITE_WAIT), VERR_SEM_LV_DEADLOCK);
else
RTTEST_CHECK_RC(g_hTest, rc = RTSemRWRequestWrite(hNext, RT_INDEFINITE_WAIT), VERR_SEM_LV_ILLEGAL_UPGRADE);
}
}
if (RT_SUCCESS(rc))
}
if (i & 1)
{
if ((i & 3) == 3)
}
else
return VINF_SUCCESS;
}
{
}
{
int rc;
if (i & 1)
RTTEST_CHECK_RC_RET(g_hTest, RTSemRWRequestWrite(hMine, RT_INDEFINITE_WAIT), VINF_SUCCESS, rcCheck);
else
{
do
{
{
break;
}
if (RT_SUCCESS(rc))
{
if (RT_FAILURE(rc))
break;
}
else
} while (RTTimeNanoTS() < g_NanoTSStop);
}
if (i & 1)
else
return VINF_SUCCESS;
}
{
}
{
do
{
int rc1 = (i & 1 ? RTSemRWRequestWrite : RTSemRWRequestRead)(hMine, TEST_SMALL_TIMEOUT); /* ugly ;-) */
{
break;
}
if (RT_SUCCESS(rc1))
{
{
{
break;
}
if (RT_SUCCESS(rc2))
{
if (RT_FAILURE(rc2))
break;
}
else
}
RTTEST_CHECK_RC(g_hTest, rc1 = (i & 1 ? RTSemRWReleaseWrite : RTSemRWReleaseRead)(hMine), VINF_SUCCESS);
if (RT_FAILURE(rc1))
break;
}
else
} while (RTTimeNanoTS() < g_NanoTSStop);
return VINF_SUCCESS;
}
{
}
{
if (i & 1)
{
int rc;
if (i != g_iDeadlockThread)
{
}
else
{
if (RT_SUCCESS(rc))
}
if (RT_SUCCESS(rc))
}
if (i & 1)
return VINF_SUCCESS;
}
{
}
{
if (i & 1)
{
int rc;
if (i != g_iDeadlockThread)
{
if (RT_SUCCESS(rc))
}
else
{
if (RT_SUCCESS(rc))
{
}
}
}
if (i & 1)
return VINF_SUCCESS;
}
{
}
{
if (i & 1)
{
int rc;
if (i != g_iDeadlockThread)
{
if (RT_SUCCESS(rc))
}
else
{
if (RT_SUCCESS(rc))
{
RTTEST_CHECK_RC(g_hTest, RTSemEventMultiWait(g_hSemEvtMulti, TEST_SMALL_TIMEOUT), VERR_SEM_LV_DEADLOCK);
}
}
}
if (i & 1)
return VINF_SUCCESS;
}
{
}
static void testLo1(void)
{
/* Initialize the critsections, the first 4 has their own classes, the rest
use the same class and relies on the sub-class mechanism for ordering. */
for (unsigned i = 0; i < RT_ELEMENTS(g_ahClasses); i++)
{
if (i <= 3)
{
RTTEST_CHECK_RC_RETV(g_hTest, RTLockValidatorClassCreate(&g_ahClasses[i], true /*fAutodidact*/, RT_SRC_POS, "testLo1-%u", i), VINF_SUCCESS);
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectInitEx(&g_aCritSects[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_NONE, "RTCritSectLO-Auto"), VINF_SUCCESS);
}
else
{
if (i == 4)
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectInitEx(&g_aCritSects[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_NONE, "RTCritSectLO-None"), VINF_SUCCESS);
else if (i == 5)
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectInitEx(&g_aCritSects[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_ANY, "RTCritSectLO-Any"), VINF_SUCCESS);
else
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectInitEx(&g_aCritSects[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_USER + i, "RTCritSectLO-User"), VINF_SUCCESS);
RTTEST_CHECK_RETV(g_hTest, RTLockValidatorClassRetain(g_ahClasses[i]) == 1 + (i - 4 + 1) * 2); /* released in cleanup. */
}
}
/* Enter the first 4 critsects in ascending order and thereby defining
this as a valid lock order. */
/* Now, leave and re-enter the critsects in a way that should break the
order and check that we get the appropriate response. */
int rc;
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
/* Check that recursion isn't subject to order checks. */
if (RT_SUCCESS(rc))
{
}
/* Enable strict release order for class 2 and check that violations
are caught. */
RTTEST_CHECK_RC(g_hTest, RTLockValidatorClassEnforceStrictReleaseOrder(g_ahClasses[2], true), VINF_SUCCESS);
if (RT_FAILURE(rc))
{
/* applies to recursions as well */
}
if (RT_FAILURE(rc))
/* Test that sub-class order works (4 = NONE, 5 = ANY, 6+ = USER). */
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
/* Check that NONE trumps both ANY and USER. */
if (RT_SUCCESS(rc))
if (RT_SUCCESS(rc))
/* Take all the locks using sub-classes. */
{
{
}
{
}
}
/* Work up some hash statistics and trigger a violation to show them. */
for (uint32_t i = 0; i < 10240; i++)
{
}
/* clean up */
//for (int i = RT_ELEMENTS(g_ahClasses) - 1; i >= 0; i--)
for (unsigned i = 0; i < RT_ELEMENTS(g_ahClasses); i++)
{
uint32_t c;
if (i <= 3)
(g_hTest, "c=%u i=%u\n", c, i));
else
{
}
}
}
static void testLo2(void)
{
/* Initialize the critsection with all different classes */
for (unsigned i = 0; i < 4; i++)
{
RTTEST_CHECK_RC_RETV(g_hTest, RTLockValidatorClassCreate(&g_ahClasses[i], true /*fAutodidact*/, RT_SRC_POS, "testLo2-%u", i), VINF_SUCCESS);
RTTEST_CHECK_RC_RETV(g_hTest, RTCritSectInitEx(&g_aCritSects[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_NONE, "RTCritSectLO"), VINF_SUCCESS);
}
/* Check the sub-class API.*/
RTTEST_CHECK(g_hTest, RTCritSectSetSubClass(&g_aCritSects[0], RTLOCKVAL_SUB_CLASS_ANY) == RTLOCKVAL_SUB_CLASS_NONE);
RTTEST_CHECK(g_hTest, RTCritSectSetSubClass(&g_aCritSects[0], RTLOCKVAL_SUB_CLASS_NONE) == RTLOCKVAL_SUB_CLASS_ANY);
/* Enter the first 4 critsects in ascending order and thereby defining
this as a valid lock order. */
/* Now, leave and re-enter the critsects in a way that should break the
order and check that we get the appropriate response. */
int rc;
if (RT_SUCCESS(rc))
/* Check that recursion isn't subject to order checks. */
if (RT_SUCCESS(rc))
/* Enable strict release order for class 2 and check that violations
are caught - including recursion. */
RTTEST_CHECK_RC(g_hTest, RTLockValidatorClassEnforceStrictReleaseOrder(g_ahClasses[2], true), VINF_SUCCESS);
/* clean up */
for (int i = 4 - 1; i >= 0; i--)
{
}
}
static void testLo3(void)
{
/* Initialize the critsection with all different classes */
for (unsigned i = 0; i < 6; i++)
{
RTTEST_CHECK_RC_RETV(g_hTest, RTLockValidatorClassCreate(&g_ahClasses[i], true /*fAutodidact*/, RT_SRC_POS, "testLo3-%u", i), VINF_SUCCESS);
RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreateEx(&g_ahSemRWs[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_NONE, "hSemRW-Lo3-%u", i), VINF_SUCCESS);
}
/* Check the sub-class API.*/
RTTEST_CHECK(g_hTest, RTSemRWSetSubClass(g_ahSemRWs[0], RTLOCKVAL_SUB_CLASS_ANY) == RTLOCKVAL_SUB_CLASS_NONE);
RTTEST_CHECK(g_hTest, RTSemRWSetSubClass(g_ahSemRWs[0], RTLOCKVAL_SUB_CLASS_NONE) == RTLOCKVAL_SUB_CLASS_ANY);
/* Enter the first 4 critsects in ascending order and thereby defining
this as a valid lock order. */
/* Now, leave and re-enter the critsects in a way that should break the
order and check that we get the appropriate response. */
int rc;
RTTEST_CHECK_RC(g_hTest, rc = RTSemRWRequestWrite(g_ahSemRWs[0], RT_INDEFINITE_WAIT), VERR_SEM_LV_WRONG_ORDER);
if (RT_SUCCESS(rc))
RTTEST_CHECK_RC(g_hTest, rc = RTSemRWRequestRead(g_ahSemRWs[1], RT_INDEFINITE_WAIT), VERR_SEM_LV_WRONG_ORDER);
if (RT_SUCCESS(rc))
/* Check that recursion isn't subject to order checks. */
if (RT_SUCCESS(rc))
RTTEST_CHECK_RC(g_hTest, rc = RTSemRWRequestWrite(g_ahSemRWs[3], RT_INDEFINITE_WAIT), VINF_SUCCESS);
if (RT_SUCCESS(rc))
/* Enable strict release order for class 2 and 3, then check that violations
are caught - including recursion. */
RTTEST_CHECK_RC(g_hTest, RTLockValidatorClassEnforceStrictReleaseOrder(g_ahClasses[2], true), VINF_SUCCESS);
RTTEST_CHECK_RC(g_hTest, RTLockValidatorClassEnforceStrictReleaseOrder(g_ahClasses[3], true), VINF_SUCCESS);
RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead( g_ahSemRWs[2], RT_INDEFINITE_WAIT), VINF_SUCCESS); /* start recursion */
RTTEST_CHECK_RC(g_hTest, RTSemRWRequestRead( g_ahSemRWs[4], RT_INDEFINITE_WAIT), VINF_SUCCESS); /* (mixed) */
/* clean up */
for (int i = 6 - 1; i >= 0; i--)
{
uint32_t c;
RTTEST_CHECK_MSG(g_hTest, (c = RTLockValidatorClassRelease(g_ahClasses[i])) == 2, (g_hTest, "c=%u i=%u\n", c, i));
g_ahSemRWs[i] = NIL_RTSEMRW;
}
}
static void testLo4(void)
{
/* Initialize the critsection with all different classes */
for (unsigned i = 0; i < 4; i++)
{
RTTEST_CHECK_RC_RETV(g_hTest, RTLockValidatorClassCreate(&g_ahClasses[i], true /*fAutodidact*/, RT_SRC_POS, "testLo4-%u", i), VINF_SUCCESS);
RTTEST_CHECK_RC_RETV(g_hTest, RTSemMutexCreateEx(&g_ahSemMtxes[i], 0, g_ahClasses[i], RTLOCKVAL_SUB_CLASS_NONE, "RTSemMutexLo4-%u", i), VINF_SUCCESS);
}
/* Check the sub-class API.*/
RTTEST_CHECK(g_hTest, RTSemMutexSetSubClass(g_ahSemMtxes[0], RTLOCKVAL_SUB_CLASS_ANY) == RTLOCKVAL_SUB_CLASS_NONE);
RTTEST_CHECK(g_hTest, RTSemMutexSetSubClass(g_ahSemMtxes[0], RTLOCKVAL_SUB_CLASS_NONE) == RTLOCKVAL_SUB_CLASS_ANY);
/* Enter the first 4 critsects in ascending order and thereby defining
this as a valid lock order. */
/* Now, leave and re-enter the critsects in a way that should break the
order and check that we get the appropriate response. */
int rc;
RTTEST_CHECK_RC(g_hTest, rc = RTSemMutexRequest(g_ahSemMtxes[0], RT_INDEFINITE_WAIT), VERR_SEM_LV_WRONG_ORDER);
if (RT_SUCCESS(rc))
/* Check that recursion isn't subject to order checks. */
RTTEST_CHECK_RC(g_hTest, rc = RTSemMutexRequest(g_ahSemMtxes[1], RT_INDEFINITE_WAIT), VINF_SUCCESS);
if (RT_SUCCESS(rc))
/* Enable strict release order for class 2 and check that violations
are caught - including recursion. */
RTTEST_CHECK_RC(g_hTest, RTLockValidatorClassEnforceStrictReleaseOrder(g_ahClasses[2], true), VINF_SUCCESS);
RTTEST_CHECK_RC(g_hTest, RTSemMutexRequest(g_ahSemMtxes[2], RT_INDEFINITE_WAIT), VINF_SUCCESS); /* start recursion */
/* clean up */
for (int i = 4 - 1; i >= 0; i--)
{
}
}
static const char *testCheckIfLockValidationIsCompiledIn(void)
{
if (!fRet)
return "Lock validation is not enabled for critical sections";
/* deadlock detection for RTSemRW */
if (rc != VERR_SEM_LV_ILLEGAL_UPGRADE)
/* lock order for RTSemRW */
if (rc != VERR_SEM_LV_WRONG_ORDER)
{
}
/* lock order for RTSemMutex */
if (rc != VERR_SEM_LV_WRONG_ORDER)
return "Lock order validation is not enabled for the mutex semaphores";
/* signaller checks on event sems. */
if (rc != VERR_SEM_LV_NOT_SIGNALLER)
return "Signalling checks are not enabled for the event semaphores";
/* signaller checks on multiple release event sems. */
if (rc != VERR_SEM_LV_NOT_SIGNALLER)
return "Signalling checks are not enabled for the multiple release event semaphores";
/* we're good */
return NULL;
}
int main()
{
/*
* Init.
*/
if (rc)
return rc;
RTLockValidatorSetEnabled(true);
RTLockValidatorSetMayPanic(false);
RTLockValidatorSetQuiet(true);
if (pszWhyDisabled)
return RTTestErrorCount(g_hTest) > 0
RTLockValidatorSetQuiet(false);
bool fTestDd = true;
bool fTestLo = true;
/*
* Some initial tests with verbose output (all single pass).
*/
if (fTestDd)
{
testDd1(3, 0);
testDd2(1, 0);
testDd2(3, 0);
testDd5(3, 0);
testDd6(3, 0);
testDd7(3, 0);
}
if (fTestLo)
{
testLo1();
testLo2();
testLo3();
testLo4();
}
/*
* If successful, perform more thorough testing without noisy output.
*/
if (RTTestErrorCount(g_hTest) == 0)
{
RTLockValidatorSetQuiet(true);
if (fTestDd)
{
}
}
return RTTestSummaryAndDestroy(g_hTest);
}