tstRTLockValidator.cpp revision 0fcf82b2591711fa8980e8f5d9cad1b8f222d6d7
/* $Id$ */
/** @file
* IPRT Testcase - RTLockValidator.
*/
/*
* Copyright (C) 2006-2009 Sun Microsystems, Inc.
*
* 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.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include <iprt/lockvalidator.h>
#include <iprt/critsect.h>
#include <iprt/semaphore.h>
/*******************************************************************************
* Global Variables *
*******************************************************************************/
/** The testcase handle. */
/** Flip this in the debugger to get some peace to single step wild code. */
bool volatile g_fDoNotSpin = false;
static uint32_t g_cThreads;
static uint32_t g_iDeadlockThread;
static RTSEMEVENT g_hSemEvt;
static RTSEMEVENTMULTI g_hSemEvtMulti;
/** Multiple release event semaphore that is signalled by the main thread after
* it has started all the threads. */
static RTSEMEVENTMULTI g_hThreadStarteEvt;
/** When to stop testing. */
static uint64_t g_NanoTSStop;
/** The number of deadlocks. */
static uint32_t volatile g_cDeadlocks;
/** The number of loops. */
/**
* Spin until someone else has taken ownership of the critical section.
*
* @returns true on success, false on abort.
* @param pCritSect The critical section.
*/
{
unsigned iLoop = 0;
while (!RTCritSectIsOwned(pCritSect))
{
if (!RTCritSectIsInitialized(pCritSect))
return false;
iLoop++;
}
return true;
}
/**
* Spin until someone else has taken ownership (any kind) of the read-write
* semaphore.
*
* @returns true on success, false on abort.
* @param hSemRW The read-write semaphore.
*/
{
unsigned iLoop = 0;
for (;;)
{
if (RTSemRWGetWriteRecursion(hSemRW) > 0)
return true;
if (RTSemRWGetReadCount(hSemRW) > 0)
return true;
iLoop++;
}
return true;
}
/**
* Spin until someone else has taken ownership of the mutex semaphore.
*
* @returns true on success, false on abort.
* @param hSemMutex The mutex sempahore.
*/
{
unsigned iLoop = 0;
while (!RTSemMutexIsOwned(hSemMutex))
{
iLoop++;
}
return true;
}
/**
* 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;
int rc = VINF_SUCCESS;
{
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 cPasses, uint32_t cSecs, PFNRTTHREAD pfnThread, const char *pszName)
{
/*
* Init test.
*/
if (cSecs)
else
{
}
/*
* The test loop.
*/
uint32_t cDeadlocks = 0;
{
g_cLoops = 0;
g_cDeadlocks = 0;
if (RT_SUCCESS(rc))
}
/*
* Cleanup.
*/
{
}
/*
* Print results if applicable.
*/
if (cSecs)
}
{
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
{
{
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;
}
{
}
static bool testIsLockValidationCompiledIn(void)
{
if (rc != VERR_SEM_LV_ILLEGAL_UPGRADE)
fRet = false;
#if 0 /** @todo detect it on RTSemMutex... */
/*??*/
#endif
if (rc != VERR_SEM_LV_NOT_SIGNALLER)
fRet = false;
return fRet;
}
int main()
{
/*
* Init.
*/
if (rc)
return rc;
RTLockValidatorSetEnabled(true);
RTLockValidatorSetMayPanic(false);
RTLockValidatorSetQuiet(true);
if (!testIsLockValidationCompiledIn())
return RTTestErrorCount(g_hTest) > 0
RTLockValidatorSetQuiet(false);
/*
* Some initial tests with verbose output.
*/
#if 1
#endif
/*
* More thorough testing without noisy output.
*/
RTLockValidatorSetQuiet(true);
#if 1
#endif
return RTTestSummaryAndDestroy(g_hTest);
}