int main(int argc, char **argv)
{
int rc;
RTR3InitExe(argc, &argv, 0);
rc = SUPR3Init(NULL);
if (RT_SUCCESS(rc))
{
SUPPAGINGMODE enmMode = SUPR3GetPagingMode();
switch (enmMode)
{
case SUPPAGINGMODE_INVALID:
RTPrintf("SUPPAGINGMODE_INVALID\n");
break;
case SUPPAGINGMODE_32_BIT:
RTPrintf("SUPPAGINGMODE_32_BIT\n");
break;
case SUPPAGINGMODE_32_BIT_GLOBAL:
RTPrintf("SUPPAGINGMODE_32_BIT_GLOBAL\n");
break;
case SUPPAGINGMODE_PAE:
RTPrintf("SUPPAGINGMODE_PAE\n");
break;
case SUPPAGINGMODE_PAE_GLOBAL:
RTPrintf("SUPPAGINGMODE_PAE_GLOBAL\n");
break;
case SUPPAGINGMODE_PAE_NX:
RTPrintf("SUPPAGINGMODE_PAE_NX\n");
break;
case SUPPAGINGMODE_PAE_GLOBAL_NX:
RTPrintf("SUPPAGINGMODE_PAE_GLOBAL_NX\n");
break;
case SUPPAGINGMODE_AMD64:
RTPrintf("SUPPAGINGMODE_AMD64\n");
break;
case SUPPAGINGMODE_AMD64_GLOBAL:
RTPrintf("SUPPAGINGMODE_AMD64_GLOBAL\n");
break;
case SUPPAGINGMODE_AMD64_NX:
RTPrintf("SUPPAGINGMODE_AMD64_NX\n");
break;
case SUPPAGINGMODE_AMD64_GLOBAL_NX:
RTPrintf("SUPPAGINGMODE_AMD64_GLOBAL_NX\n");
break;
default:
RTPrintf("Unknown mode %d\n", enmMode);
rc = VERR_INTERNAL_ERROR;
break;
}
int rc2 = SUPR3Term(false /*fForced*/);
RTPrintf("SUPR3Term -> rc=%Rrc\n", rc2);
}
else
RTPrintf("SUPR3Init -> rc=%Rrc\n", rc);
return !RT_SUCCESS(rc);
}
int main(int argc, char **argv)
{
int cErrors = 0;
int rc = 0;
RTR3InitAndSUPLib();
rc = SUPR3Init(NULL);
cErrors += rc != 0;
if (!rc)
{
void *pv;
rc = SUPR3PageAlloc(1, &pv);
cErrors += rc != 0;
if (!rc)
{
memset(pv, 0xff, PAGE_SIZE);
rc = SUPR3PageFree(pv, 1);
cErrors += rc != 0;
if (rc)
RTPrintf("tstPage: SUPR3PageFree() failed rc=%d\n", rc);
}
else
RTPrintf("tstPage: SUPR3PageAlloc(1,) failed rc=%d\n", rc);
/*
* Big chunk.
*/
rc = SUPR3PageAlloc(1023, &pv);
cErrors += rc != 0;
if (!rc)
{
memset(pv, 0xfe, 1023 << PAGE_SHIFT);
rc = SUPR3PageFree(pv, 1023);
cErrors += rc != 0;
if (rc)
RTPrintf("tstPage: SUPR3PageFree() failed rc=%d\n", rc);
}
else
RTPrintf("tstPage: SUPR3PageAlloc(1,) failed rc=%d\n", rc);
//rc = SUPR3Term();
cErrors += rc != 0;
if (rc)
RTPrintf("tstPage: SUPR3Term failed rc=%d\n", rc);
}
else
RTPrintf("tstPage: SUPR3Init failed rc=%d\n", rc);
if (!cErrors)
RTPrintf("tstPage: SUCCESS\n");
else
RTPrintf("tstPage: FAILURE - %d errors\n", cErrors);
return !!cErrors;
}
int main(int argc, char **argv)
{
int rc;
RTR3InitExe(argc, &argv, 0);
rc = SUPR3Init(NULL);
RTPrintf("tstInit: SUPR3Init -> rc=%Rrc\n", rc);
if (!rc)
{
rc = SUPR3Term(false /*fForced*/);
RTPrintf("tstInit: SUPR3Term -> rc=%Rrc\n", rc);
}
return rc;
}
/**
* Internal initialization worker.
*
* @returns IPRT status code.
* @param fFlags Flags, see RTR3INIT_XXX.
* @param cArgs Pointer to the argument count.
* @param ppapszArgs Pointer to the argument vector pointer. NULL
* allowed if @a cArgs is 0.
* @param pszProgramPath The program path. Pass NULL if we're to figure it
* out ourselves.
*/
static int rtR3Init(uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
{
/* no entry log flow, because prefixes and thread may freak out. */
Assert(!(fFlags & ~(RTR3INIT_FLAGS_DLL | RTR3INIT_FLAGS_SUPLIB)));
Assert(!(fFlags & RTR3INIT_FLAGS_DLL) || cArgs == 0);
/*
* Do reference counting, only initialize the first time around.
*
* We are ASSUMING that nobody will be able to race RTR3Init* calls when the
* first one, the real init, is running (second assertion).
*/
int32_t cUsers = ASMAtomicIncS32(&g_cUsers);
if (cUsers != 1)
{
AssertMsg(cUsers > 1, ("%d\n", cUsers));
Assert(!g_fInitializing);
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
if (fFlags & RTR3INIT_FLAGS_SUPLIB)
SUPR3Init(NULL);
#endif
if (!pszProgramPath)
return VINF_SUCCESS;
int rc = rtR3InitProgramPath(pszProgramPath);
if (RT_SUCCESS(rc))
rc = rtR3InitArgv(fFlags, cArgs, papszArgs);
return rc;
}
ASMAtomicWriteBool(&g_fInitializing, true);
/*
* Do the initialization.
*/
int rc = rtR3InitBody(fFlags, cArgs, papszArgs, pszProgramPath);
if (RT_FAILURE(rc))
{
/* failure */
ASMAtomicWriteBool(&g_fInitializing, false);
ASMAtomicDecS32(&g_cUsers);
return rc;
}
/* success */
LogFlow(("rtR3Init: returns VINF_SUCCESS\n"));
ASMAtomicWriteBool(&g_fInitializing, false);
return VINF_SUCCESS;
}
int main()
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitAndCreate("tstRTMemSafer", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
RTTestBanner(hTest);
#ifdef VBOX
SUPR3Init(NULL);
#endif
/*
* Not using sub-tests here, just printing progress.
*/
RTTestPrintf(hTest, RTTESTLVL_ALWAYS, "20 random allocations\n");
for (uint32_t i = 0; i < 20; i++)
doMemSaferAllocation(hTest);
doMemRealloc(hTest);
return RTTestSummaryAndDestroy(hTest);
}
static void doInVmmTests(RTTEST hTest)
{
/*
* Create empty VM structure and init SSM.
*/
int rc = SUPR3Init(NULL);
if (RT_FAILURE(rc))
{
RTTestSkipped(hTest, "SUPR3Init failed with rc=%Rrc", rc);
return;
}
PVM pVM;
RTTESTI_CHECK_RC_RETV(SUPR3PageAlloc(RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT, (void **)&pVM), VINF_SUCCESS);
PUVM pUVM = (PUVM)RTMemPageAlloc(sizeof(*pUVM));
pUVM->u32Magic = UVM_MAGIC;
pUVM->pVM = pVM;
pVM->pUVM = pUVM;
/*
* Do the testing.
*/
RTTESTI_CHECK_RC_RETV(STAMR3InitUVM(pUVM), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(MMR3InitUVM(pUVM), VINF_SUCCESS);
RTTESTI_CHECK_RC_RETV(CFGMR3Init(pVM, NULL, NULL), VINF_SUCCESS);
RTTESTI_CHECK_RETV(CFGMR3GetRoot(pVM) != NULL);
doTestsOnDefaultValues(CFGMR3GetRoot(pVM));
doGeneralTests(CFGMR3GetRoot(pVM));
/* done */
RTTESTI_CHECK_RC_RETV(CFGMR3Term(pVM), VINF_SUCCESS);
}
int main(int argc, char **argv)
{
RTTEST hTest;
RTEXITCODE rcExit = RTTestInitExAndCreate(argc, &argv, 0 /*fRtInit*/, "tstSupTscDelta", &hTest);
if (rcExit != RTEXITCODE_SUCCESS)
return rcExit;
/*
* Parse args
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_INT32 },
{ "--delay", 'd', RTGETOPT_REQ_INT32 },
};
uint32_t cIterations = 0; /* Currently 0 so that it doesn't upset testing. */
uint32_t cMsSleepBetweenIterations = 10;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'd':
cMsSleepBetweenIterations = ValueUnion.u32;
break;
case 'i':
cIterations = ValueUnion.u32;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
if (!cIterations)
return RTTestSkipAndDestroy(hTest, "Nothing to do. The --iterations argument is 0 or not given.");
/*
* Init
*/
PSUPDRVSESSION pSession = NIL_RTR0PTR;
int rc = SUPR3Init(&pSession);
if (RT_SUCCESS(rc))
{
PSUPGLOBALINFOPAGE pGip = g_pSUPGlobalInfoPage;
if (pGip)
{
if (pGip->enmUseTscDelta < SUPGIPUSETSCDELTA_PRACTICALLY_ZERO)
return RTTestSkipAndDestroy(hTest, "No deltas to play with: enmUseTscDelta=%d\n", pGip->enmUseTscDelta);
/*
* Init stats.
*/
struct
{
int64_t iLowest;
int64_t iHighest;
int64_t iTotal;
uint64_t uAbsMin;
uint64_t uAbsMax;
uint64_t uAbsTotal;
} aCpuStats[RTCPUSET_MAX_CPUS];
RT_ZERO(aCpuStats);
for (uint32_t i = 0; i < pGip->cCpus; i++)
{
aCpuStats[i].iLowest = INT64_MAX;
aCpuStats[i].iHighest = INT64_MIN;
aCpuStats[i].uAbsMin = UINT64_MAX;
}
/*
* Do the work.
*/
for (uint32_t iIteration = 0; ; iIteration++)
{
/*
* Display the current deltas and gather statistics.
*/
RTPrintf("tstSupTscDelta: Iteration #%u results:", iIteration);
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
{
int64_t iTscDelta = pGip->aCPUs[iCpu].i64TSCDelta;
/* print */
if ((iCpu % 4) == 0)
RTPrintf("\ntstSupTscDelta:");
if (pGip->aCPUs[iCpu].enmState != SUPGIPCPUSTATE_ONLINE)
RTPrintf(" %02x: offline ", iCpu);
else if (iTscDelta != INT64_MAX)
RTPrintf(" %02x: %-12lld", iCpu, iTscDelta);
else
RTPrintf(" %02x: INT64_MAX ", iCpu);
/* stats */
if ( iTscDelta != INT64_MAX
&& pGip->aCPUs[iCpu].enmState == SUPGIPCPUSTATE_ONLINE)
{
if (aCpuStats[iCpu].iLowest > iTscDelta)
aCpuStats[iCpu].iLowest = iTscDelta;
if (aCpuStats[iCpu].iHighest < iTscDelta)
aCpuStats[iCpu].iHighest = iTscDelta;
aCpuStats[iCpu].iTotal += iTscDelta;
uint64_t uAbsTscDelta = iTscDelta >= 0 ? (uint64_t)iTscDelta : (uint64_t)-iTscDelta;
if (aCpuStats[iCpu].uAbsMin > uAbsTscDelta)
aCpuStats[iCpu].uAbsMin = uAbsTscDelta;
if (aCpuStats[iCpu].uAbsMax < uAbsTscDelta)
aCpuStats[iCpu].uAbsMax = uAbsTscDelta;
aCpuStats[iCpu].uAbsTotal += uAbsTscDelta;
}
}
if (((pGip->cCpus - 1) % 4) != 0)
RTPrintf("\n");
/*
* Done?
*/
if (iIteration + 1 >= cIterations)
break;
/*
* Force a new measurement.
*/
RTThreadSleep(cMsSleepBetweenIterations);
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
if (pGip->aCPUs[iCpu].enmState == SUPGIPCPUSTATE_ONLINE)
{
rc = SUPR3TscDeltaMeasure(pGip->aCPUs[iCpu].idCpu, false /*fAsync*/, true /*fForce*/, 64, 16 /*ms*/);
if (RT_FAILURE(rc))
RTTestFailed(hTest, "SUPR3TscDeltaMeasure failed on %#x: %Rrc", pGip->aCPUs[iCpu].idCpu, rc);
}
}
/*
* Display statistics that we've gathered.
*/
RTPrintf("tstSupTscDelta: Results:\n");
int64_t iLowest = INT64_MAX;
int64_t iHighest = INT64_MIN;
int64_t iTotal = 0;
uint32_t cTotal = 0;
for (uint32_t iCpu = 0; iCpu < pGip->cCpus; iCpu++)
{
if (pGip->aCPUs[iCpu].enmState != SUPGIPCPUSTATE_ONLINE)
RTPrintf("tstSupTscDelta: %02x: offline\n", iCpu);
else
{
RTPrintf("tstSupTscDelta: %02x: lowest=%-12lld highest=%-12lld average=%-12lld spread=%-12lld\n",
iCpu,
aCpuStats[iCpu].iLowest,
aCpuStats[iCpu].iHighest,
aCpuStats[iCpu].iTotal / cIterations,
aCpuStats[iCpu].iHighest - aCpuStats[iCpu].iLowest);
RTPrintf( "tstSupTscDelta: absmin=%-12llu absmax=%-12llu absavg=%-12llu idCpu=%#4x idApic=%#4x\n",
aCpuStats[iCpu].uAbsMin,
aCpuStats[iCpu].uAbsMax,
aCpuStats[iCpu].uAbsTotal / cIterations,
pGip->aCPUs[iCpu].idCpu,
pGip->aCPUs[iCpu].idApic);
if (iLowest > aCpuStats[iCpu].iLowest)
iLowest = aCpuStats[iCpu].iLowest;
if (iHighest < aCpuStats[iCpu].iHighest)
iHighest = aCpuStats[iCpu].iHighest;
iTotal += aCpuStats[iCpu].iHighest;
cTotal += cIterations;
}
}
RTPrintf("tstSupTscDelta: all: lowest=%-12lld highest=%-12lld average=%-12lld spread=%-12lld\n",
iLowest, iHighest, iTotal / cTotal, iHighest - iLowest);
}
else
RTTestFailed(hTest, "g_pSUPGlobalInfoPage is NULL");
SUPR3Term(false /*fForced*/);
}
else
RTTestFailed(hTest, "SUPR3Init failed: %Rrc", rc);
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
bool fSys = true;
bool fGip = false;
#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
fGip = true;
#endif
/*
* Init.
*/
int rc = RTR3InitExe(argc, &argv, RTR3INIT_FLAGS_SUPLIB);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
if (argc == 2 && !strcmp(argv[1], "child"))
{
RTThreadSleep(300);
return 0;
}
RTTEST hTest;
rc = RTTestCreate("tstSupSem", &hTest);
if (RT_FAILURE(rc))
{
RTPrintf("tstSupSem: fatal error: RTTestCreate failed with rc=%Rrc\n", rc);
return 1;
}
g_hTest = hTest;
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
g_pSession = pSession;
RTTestBanner(hTest);
/*
* Basic API checks.
*/
RTTestSub(hTest, "Single Release Event (SRE) API");
SUPSEMEVENT hEvent = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,20), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 20), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,1000),VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 0), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 1), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 2), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent, 8), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventWaitNoResume(pSession, hEvent,20), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VERR_INVALID_HANDLE);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, NIL_SUPSEMEVENT), VINF_SUCCESS);
RTTestSub(hTest, "Multiple Release Event (MRE) API");
SUPSEMEVENTMULTI hEventMulti = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,1000), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiReset(pSession, hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,20), VERR_TIMEOUT);
RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEventMulti), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 0), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 1), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 2), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 8), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti, 20), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiWaitNoResume(pSession, hEventMulti,1000), VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VERR_INVALID_HANDLE);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, NIL_SUPSEMEVENTMULTI), VINF_SUCCESS);
#if !defined(RT_OS_OS2) && !defined(RT_OS_WINDOWS)
RTTestSub(hTest, "SRE Interruptibility");
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
g_cMillies = RT_INDEFINITE_WAIT;
RTTHREAD hThread = NIL_RTTHREAD;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
RTThreadSleep(120);
RTThreadPoke(hThread);
int rcThread = VINF_SUCCESS;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
g_cMillies = 120*1000;
hThread = NIL_RTTHREAD;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
RTThreadSleep(120);
RTThreadPoke(hThread);
rcThread = VINF_SUCCESS;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestSub(hTest, "MRE Interruptibility");
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
g_cMillies = RT_INDEFINITE_WAIT;
hThread = NIL_RTTHREAD;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntMRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
RTThreadSleep(120);
RTThreadPoke(hThread);
rcThread = VINF_SUCCESS;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
g_cMillies = 120*1000;
hThread = NIL_RTTHREAD;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntMRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadUserWait(hThread, 60*1000), VINF_SUCCESS);
RTThreadSleep(120);
RTThreadPoke(hThread);
rcThread = VINF_SUCCESS;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 60*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VERR_INTERRUPTED);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEventMulti), VINF_OBJECT_DESTROYED);
/*
* Fork test.
* Spawn a thread waiting for an event, then spawn a new child process (of
* ourselves) and make sure that this does not alter the intended behaviour
* of our event semaphore implementation (see @bugref{5090}).
*/
RTTestSub(hTest, "SRE Process Spawn");
hThread = NIL_RTTHREAD;
g_cMillies = 120*1000;
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleSRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
const char *apszArgs[3] = { argv[0], "child", NULL };
RTPROCESS Process = NIL_RTPROCESS;
RTThreadSleep(250);
RTTESTI_CHECK_RC(RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, 0, &Process), VINF_SUCCESS);
RTThreadSleep(250);
RTTESTI_CHECK_RC(SUPSemEventSignal(pSession, hEvent), VINF_SUCCESS);
rcThread = VERR_GENERAL_FAILURE;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 120*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestSub(hTest, "MRE Process Spawn");
hThread = NIL_RTTHREAD;
g_cMillies = 120*1000;
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemInterruptibleMRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
RTTHREAD hThread2 = NIL_RTTHREAD;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread2, tstSupSemInterruptibleMRE, (void *)hEvent, 0, RTTHREADTYPE_TIMER, RTTHREADFLAGS_WAITABLE, "IntSRE"), VINF_SUCCESS);
Process = NIL_RTPROCESS;
RTThreadSleep(250);
RTTESTI_CHECK_RC(RTProcCreate(apszArgs[0], apszArgs, RTENV_DEFAULT, 0, &Process), VINF_SUCCESS);
RTThreadSleep(250);
RTTESTI_CHECK_RC(SUPSemEventMultiSignal(pSession, hEvent), VINF_SUCCESS);
rcThread = VERR_GENERAL_FAILURE;
RTTESTI_CHECK_RC(RTThreadWait(hThread, 120*1000, &rcThread), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread, VINF_SUCCESS);
int rcThread2 = VERR_GENERAL_FAILURE;
RTTESTI_CHECK_RC(RTThreadWait(hThread2, 120*1000, &rcThread2), VINF_SUCCESS);
RTTESTI_CHECK_RC(rcThread2, VINF_SUCCESS);
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
#endif /* !OS2 && !WINDOWS */
{
#define LOOP_COUNT 20
static unsigned const s_acMsIntervals[] = { 0, 1, 2, 3, 4, 8, 10, 16, 32 };
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "SRE Timeout Accuracy (ms)");
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acMsIntervals); i++)
{
uint64_t cMs = s_acMsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
int rcX = SUPSemEventWaitNoResume(pSession, hEvent, cMs);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cMs=%u", rcX, cLoops, cMs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%u ms min (clock=sys)", cMs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=sys)", cMs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%u ms min (clock=gip)", cMs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=gip)", cMs);
}
}
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "MRE Timeout Accuracy (ms)");
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acMsIntervals); i++)
{
uint64_t cMs = s_acMsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
int rcX = SUPSemEventMultiWaitNoResume(pSession, hEvent, cMs);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cMs=%u", rcX, cLoops, cMs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%u ms min (clock=sys)", cMs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=sys)", cMs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%u ms min (clock=gip)", cMs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%u ms avg (clock=gip)", cMs);
}
}
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
}
{
static uint32_t const s_acNsIntervals[] =
{
0, 1000, 5000, 15000, 30000, 50000, 100000, 250000, 500000, 750000, 900000, 1500000, 2200000
};
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "SUPSemEventWaitNsRelIntr Accuracy");
RTTestValueF(hTest, SUPSemEventGetResolution(pSession), RTTESTUNIT_NS, "SRE resolution");
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
{
uint64_t cNs = s_acNsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
int rcX = SUPSemEventWaitNsRelIntr(pSession, hEvent, cNs);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
}
}
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "SUPSemEventMultiWaitNsRelIntr Accuracy");
RTTestValueF(hTest, SUPSemEventMultiGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
{
uint64_t cNs = s_acNsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
int rcX = SUPSemEventMultiWaitNsRelIntr(pSession, hEvent, cNs);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
}
}
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "SUPSemEventWaitNsAbsIntr Accuracy");
RTTestValueF(hTest, SUPSemEventGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
RTTESTI_CHECK_RC(SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
{
uint64_t cNs = s_acNsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
uint64_t uAbsDeadline = (fGip ? u64Start : u64StartSys) + cNs;
int rcX = SUPSemEventWaitNsAbsIntr(pSession, hEvent, uAbsDeadline);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
}
}
RTTESTI_CHECK_RC(SUPSemEventClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
if (RTTestErrorCount(hTest) == 0)
{
RTTestSub(hTest, "SUPSemEventMultiWaitNsAbsIntr Accuracy");
RTTestValueF(hTest, SUPSemEventMultiGetResolution(pSession), RTTESTUNIT_NS, "MRE resolution");
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEvent), VINF_SUCCESS);
uint32_t cInterrupted = 0;
for (unsigned i = 0; i < RT_ELEMENTS(s_acNsIntervals); i++)
{
uint64_t cNs = s_acNsIntervals[i];
uint64_t cNsMinSys = UINT64_MAX;
uint64_t cNsMin = UINT64_MAX;
uint64_t cNsTotalSys= 0;
uint64_t cNsTotal = 0;
unsigned cLoops = 0;
while (cLoops < LOOP_COUNT)
{
uint64_t u64StartSys = RTTimeSystemNanoTS();
uint64_t u64Start = RTTimeNanoTS();
uint64_t uAbsDeadline = (fGip ? u64Start : u64StartSys) + cNs;
int rcX = SUPSemEventMultiWaitNsAbsIntr(pSession, hEvent, uAbsDeadline);
uint64_t cNsElapsedSys = RTTimeSystemNanoTS() - u64StartSys;
uint64_t cNsElapsed = RTTimeNanoTS() - u64Start;
if (rcX == VERR_INTERRUPTED)
{
cInterrupted++;
continue; /* retry */
}
if (rcX != VERR_TIMEOUT)
RTTestFailed(hTest, "%Rrc cLoops=%u cNs=%u", rcX, cLoops, cNs);
if (cNsElapsedSys < cNsMinSys)
cNsMinSys = cNsElapsedSys;
if (cNsElapsed < cNsMin)
cNsMin = cNsElapsed;
cNsTotalSys += cNsElapsedSys;
cNsTotal += cNsElapsed;
cLoops++;
}
if (fSys)
{
RTTestValueF(hTest, cNsMinSys, RTTESTUNIT_NS, "%'u ns min (clock=sys)", cNs);
RTTestValueF(hTest, cNsTotalSys / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=sys)", cNs);
}
if (fGip)
{
RTTestValueF(hTest, cNsMin, RTTESTUNIT_NS, "%'u ns min (clock=gip)", cNs);
RTTestValueF(hTest, cNsTotal / cLoops, RTTESTUNIT_NS, "%'u ns avg (clock=gip)", cNs);
}
}
RTTESTI_CHECK_RC(SUPSemEventMultiClose(pSession, hEvent), VINF_OBJECT_DESTROYED);
RTTestValueF(hTest, cInterrupted, RTTESTUNIT_OCCURRENCES, "VERR_INTERRUPTED returned");
}
}
/*
* Done.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
/*
* Parse args
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_INT32 },
{ "--hex", 'h', RTGETOPT_REQ_NOTHING },
{ "--decimal", 'd', RTGETOPT_REQ_NOTHING },
{ "--spin", 's', RTGETOPT_REQ_NOTHING },
{ "--reference", 'r', RTGETOPT_REQ_UINT64 }, /* reference value of CpuHz, display the
* CpuHz deviation in a separate column. */
};
uint32_t cIterations = 40;
bool fHex = true;
bool fSpin = false;
int ch;
uint64_t uCpuHzRef = 0;
uint64_t uCpuHzOverallDeviation = 0;
int64_t iCpuHzMaxDeviation = 0;
int32_t cCpuHzOverallDevCnt = 0;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'i':
cIterations = ValueUnion.u32;
break;
case 'd':
fHex = false;
break;
case 'h':
fHex = true;
break;
case 's':
fSpin = true;
break;
case 'r':
uCpuHzRef = ValueUnion.u64;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
/*
* Init
*/
PSUPDRVSESSION pSession = NIL_RTR0PTR;
int rc = SUPR3Init(&pSession);
if (RT_SUCCESS(rc))
{
if (g_pSUPGlobalInfoPage)
{
RTPrintf("tstGIP-2: cCpus=%d u32UpdateHz=%RU32 u32UpdateIntervalNS=%RU32 u64NanoTSLastUpdateHz=%RX64 u64CpuHz=%RU64 uCpuHzRef=%RU64 u32Mode=%d (%s) u32Version=%#x\n",
g_pSUPGlobalInfoPage->cCpus,
g_pSUPGlobalInfoPage->u32UpdateHz,
g_pSUPGlobalInfoPage->u32UpdateIntervalNS,
g_pSUPGlobalInfoPage->u64NanoTSLastUpdateHz,
g_pSUPGlobalInfoPage->u64CpuHz,
uCpuHzRef,
g_pSUPGlobalInfoPage->u32Mode,
SUPGetGIPModeName(g_pSUPGlobalInfoPage),
g_pSUPGlobalInfoPage->u32Version);
RTPrintf(fHex
? "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz %sTSC Interval History...\n"
: "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz %sTSC Interval History...\n",
uCpuHzRef ? " CpuHz deviation " : "");
static SUPGIPCPU s_aaCPUs[2][256];
for (uint32_t i = 0; i < cIterations; i++)
{
/* copy the data */
memcpy(&s_aaCPUs[i & 1][0], &g_pSUPGlobalInfoPage->aCPUs[0], g_pSUPGlobalInfoPage->cCpus * sizeof(g_pSUPGlobalInfoPage->aCPUs[0]));
/* display it & find something to spin on. */
uint32_t u32TransactionId = 0;
uint32_t volatile *pu32TransactionId = NULL;
for (unsigned iCpu = 0; iCpu < g_pSUPGlobalInfoPage->cCpus; iCpu++)
if ( g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz > 0
&& g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz != _4G + 1)
{
char szCpuHzDeviation[32];
PSUPGIPCPU pPrevCpu = &s_aaCPUs[!(i & 1)][iCpu];
PSUPGIPCPU pCpu = &s_aaCPUs[i & 1][iCpu];
if (uCpuHzRef)
{
int64_t iCpuHzDeviation = pCpu->u64CpuHz - uCpuHzRef;
uint64_t uCpuHzDeviation = RT_ABS(iCpuHzDeviation);
if (uCpuHzDeviation > 999999999)
RTStrPrintf(szCpuHzDeviation, sizeof(szCpuHzDeviation), "%17s ", "?");
else
{
/* Wait until the history validation code takes effect. */
if (pCpu->u32TransactionId > 23 + (8 * 2) + 1)
{
if (RT_ABS(iCpuHzDeviation) > RT_ABS(iCpuHzMaxDeviation))
iCpuHzMaxDeviation = iCpuHzDeviation;
uCpuHzOverallDeviation += uCpuHzDeviation;
cCpuHzOverallDevCnt++;
}
uint32_t uPct = (uint32_t)(uCpuHzDeviation * 100000 / uCpuHzRef + 5);
RTStrPrintf(szCpuHzDeviation, sizeof(szCpuHzDeviation), "%10RI64%3d.%02d%% ",
iCpuHzDeviation, uPct / 1000, (uPct % 1000) / 10);
}
}
else
szCpuHzDeviation[0] = '\0';
RTPrintf(fHex
? "tstGIP-2: %4d/%d: %016llx %09llx %016llx %08x %d %08x %15llu %s%08x %08x %08x %08x %08x %08x %08x %08x (%d)\n"
: "tstGIP-2: %4d/%d: %016llu %09llu %016llu %010u %d %010u %15llu %s%08x %08x %08x %08x %08x %08x %08x %08x (%d)\n",
i, iCpu,
pCpu->u64NanoTS,
i ? pCpu->u64NanoTS - pPrevCpu->u64NanoTS : 0,
pCpu->u64TSC,
pCpu->u32UpdateIntervalTSC,
pCpu->iTSCHistoryHead,
pCpu->u32TransactionId,
pCpu->u64CpuHz,
szCpuHzDeviation,
pCpu->au32TSCHistory[0],
pCpu->au32TSCHistory[1],
pCpu->au32TSCHistory[2],
pCpu->au32TSCHistory[3],
pCpu->au32TSCHistory[4],
pCpu->au32TSCHistory[5],
pCpu->au32TSCHistory[6],
pCpu->au32TSCHistory[7],
pCpu->cErrors);
if (!pu32TransactionId)
{
pu32TransactionId = &g_pSUPGlobalInfoPage->aCPUs[iCpu].u32TransactionId;
u32TransactionId = pCpu->u32TransactionId;
}
}
/* wait a bit / spin */
if (!fSpin)
RTThreadSleep(9);
else
{
if (pu32TransactionId)
{
uint32_t uTmp;
while ( u32TransactionId == (uTmp = *pu32TransactionId)
|| (uTmp & 1))
ASMNopPause();
}
else
RTThreadSleep(1);
}
}
/*
* Display TSC deltas.
*
* First iterative over the APIC ID array to get mostly consistent CPUID to APIC ID mapping.
* Then iterate over the offline CPUs. It is possible that there's a race between the online/offline
* states between the two iterations, but that cannot be helped from ring-3 anyway and not a biggie.
*/
RTPrintf("tstGIP-2: TSC deltas:\n");
RTPrintf("tstGIP-2: idApic: i64TSCDelta\n");
for (unsigned i = 0; i < RT_ELEMENTS(g_pSUPGlobalInfoPage->aiCpuFromApicId); i++)
{
uint16_t iCpu = g_pSUPGlobalInfoPage->aiCpuFromApicId[i];
if (iCpu != UINT16_MAX)
{
RTPrintf("tstGIP-2: %7d: %lld\n", g_pSUPGlobalInfoPage->aCPUs[iCpu].idApic,
g_pSUPGlobalInfoPage->aCPUs[iCpu].i64TSCDelta);
}
}
for (unsigned iCpu = 0; iCpu < g_pSUPGlobalInfoPage->cCpus; iCpu++)
if (g_pSUPGlobalInfoPage->aCPUs[iCpu].idApic == UINT16_MAX)
RTPrintf("tstGIP-2: offline: %lld\n", g_pSUPGlobalInfoPage->aCPUs[iCpu].i64TSCDelta);
RTPrintf("tstGIP-2: enmUseTscDelta=%d fGetGipCpu=%#x\n",
g_pSUPGlobalInfoPage->enmUseTscDelta, g_pSUPGlobalInfoPage->fGetGipCpu);
if ( uCpuHzRef
&& cCpuHzOverallDevCnt)
{
uint32_t uPct = (uint32_t)(uCpuHzOverallDeviation * 100000 / cCpuHzOverallDevCnt / uCpuHzRef + 5);
RTPrintf("tstGIP-2: Average CpuHz deviation: %d.%02d%%\n",
uPct / 1000, (uPct % 1000) / 10);
uint32_t uMaxPct = (uint32_t)(RT_ABS(iCpuHzMaxDeviation) * 100000 / uCpuHzRef + 5);
RTPrintf("tstGIP-2: Maximum CpuHz deviation: %d.%02d%% (%RI64 ticks)\n",
uMaxPct / 1000, (uMaxPct % 1000) / 10, iCpuHzMaxDeviation);
}
}
else
{
RTPrintf("tstGIP-2: g_pSUPGlobalInfoPage is NULL\n");
rc = -1;
}
SUPR3Term(false /*fForced*/);
}
else
RTPrintf("tstGIP-2: SUPR3Init failed: %Rrc\n", rc);
return !!rc;
}
int main(int argc, char **argv)
{
int rcRet = 0;
int i;
int rc;
int cIterations = argc > 1 ? RTStrToUInt32(argv[1]) : 32;
if (cIterations == 0)
cIterations = 64;
/*
* Init.
*/
RTR3InitExe(argc, &argv, 0);
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
rcRet += rc != 0;
RTPrintf("tstInt: SUPR3Init -> rc=%Rrc\n", rc);
char szFile[RTPATH_MAX];
if (!rc)
{
rc = RTPathExecDir(szFile, sizeof(szFile) - sizeof("/VMMR0.r0"));
}
char szAbsFile[RTPATH_MAX];
if (RT_SUCCESS(rc))
{
strcat(szFile, "/VMMR0.r0");
rc = RTPathAbs(szFile, szAbsFile, sizeof(szAbsFile));
}
if (RT_SUCCESS(rc))
{
/*
* Load VMM code.
*/
rc = SUPR3LoadVMM(szAbsFile);
if (RT_SUCCESS(rc))
{
/*
* Create a fake 'VM'.
*/
PVMR0 pVMR0 = NIL_RTR0PTR;
PVM pVM = NULL;
const unsigned cPages = RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT;
PSUPPAGE paPages = (PSUPPAGE)RTMemAllocZ(cPages * sizeof(SUPPAGE));
if (paPages)
rc = SUPR3LowAlloc(cPages, (void **)&pVM, &pVMR0, &paPages[0]);
else
rc = VERR_NO_MEMORY;
if (RT_SUCCESS(rc))
{
pVM->pVMRC = 0;
pVM->pVMR3 = pVM;
pVM->pVMR0 = pVMR0;
pVM->paVMPagesR3 = paPages;
pVM->pSession = pSession;
pVM->enmVMState = VMSTATE_CREATED;
rc = SUPR3SetVMForFastIOCtl(pVMR0);
if (!rc)
{
/*
* Call VMM code with invalid function.
*/
for (i = cIterations; i > 0; i--)
{
rc = SUPR3CallVMMR0(pVMR0, NIL_VMCPUID, VMMR0_DO_SLOW_NOP, NULL);
if (rc != VINF_SUCCESS)
{
RTPrintf("tstInt: SUPR3CallVMMR0 -> rc=%Rrc i=%d Expected VINF_SUCCESS!\n", rc, i);
rcRet++;
break;
}
}
RTPrintf("tstInt: Performed SUPR3CallVMMR0 %d times (rc=%Rrc)\n", cIterations, rc);
/*
* The fast path.
*/
if (rc == VINF_SUCCESS)
{
RTTimeNanoTS();
uint64_t StartTS = RTTimeNanoTS();
uint64_t StartTick = ASMReadTSC();
uint64_t MinTicks = UINT64_MAX;
for (i = 0; i < 1000000; i++)
{
uint64_t OneStartTick = ASMReadTSC();
rc = SUPR3CallVMMR0Fast(pVMR0, VMMR0_DO_NOP, 0);
uint64_t Ticks = ASMReadTSC() - OneStartTick;
if (Ticks < MinTicks)
MinTicks = Ticks;
if (RT_UNLIKELY(rc != VINF_SUCCESS))
{
RTPrintf("tstInt: SUPR3CallVMMR0Fast -> rc=%Rrc i=%d Expected VINF_SUCCESS!\n", rc, i);
rcRet++;
break;
}
}
uint64_t Ticks = ASMReadTSC() - StartTick;
uint64_t NanoSecs = RTTimeNanoTS() - StartTS;
RTPrintf("tstInt: SUPR3CallVMMR0Fast - %d iterations in %llu ns / %llu ticks. %llu ns / %#llu ticks per iteration. Min %llu ticks.\n",
i, NanoSecs, Ticks, NanoSecs / i, Ticks / i, MinTicks);
/*
* The ordinary path.
*/
RTTimeNanoTS();
StartTS = RTTimeNanoTS();
StartTick = ASMReadTSC();
MinTicks = UINT64_MAX;
for (i = 0; i < 1000000; i++)
{
uint64_t OneStartTick = ASMReadTSC();
rc = SUPR3CallVMMR0Ex(pVMR0, NIL_VMCPUID, VMMR0_DO_SLOW_NOP, 0, NULL);
uint64_t OneTicks = ASMReadTSC() - OneStartTick;
if (OneTicks < MinTicks)
MinTicks = OneTicks;
if (RT_UNLIKELY(rc != VINF_SUCCESS))
{
RTPrintf("tstInt: SUPR3CallVMMR0Ex -> rc=%Rrc i=%d Expected VINF_SUCCESS!\n", rc, i);
rcRet++;
break;
}
}
Ticks = ASMReadTSC() - StartTick;
NanoSecs = RTTimeNanoTS() - StartTS;
RTPrintf("tstInt: SUPR3CallVMMR0Ex - %d iterations in %llu ns / %llu ticks. %llu ns / %#llu ticks per iteration. Min %llu ticks.\n",
i, NanoSecs, Ticks, NanoSecs / i, Ticks / i, MinTicks);
}
}
else
{
RTPrintf("tstInt: SUPR3SetVMForFastIOCtl failed: %Rrc\n", rc);
rcRet++;
}
}
else
{
RTPrintf("tstInt: SUPR3ContAlloc(%#zx,,) failed\n", sizeof(*pVM));
rcRet++;
}
/*
* Unload VMM.
*/
rc = SUPR3UnloadVMM();
if (rc)
{
RTPrintf("tstInt: SUPR3UnloadVMM failed with rc=%Rrc\n", rc);
rcRet++;
}
}
else
{
RTPrintf("tstInt: SUPR3LoadVMM failed with rc=%Rrc\n", rc);
rcRet++;
}
/*
* Terminate.
*/
rc = SUPR3Term(false /*fForced*/);
rcRet += rc != 0;
RTPrintf("tstInt: SUPR3Term -> rc=%Rrc\n", rc);
}
/**
* rtR3Init worker.
*/
static int rtR3InitBody(uint32_t fFlags, int cArgs, char ***papszArgs, const char *pszProgramPath)
{
/*
* Early native initialization.
*/
int rc = rtR3InitNativeFirst(fFlags);
AssertMsgRCReturn(rc, ("rtR3InitNativeFirst failed with %Rrc\n", rc), rc);
/*
* Disable error popups.
*/
#if defined(RT_OS_OS2) /** @todo move to private code. */
DosError(FERR_DISABLEHARDERR);
#endif
/*
* Init C runtime locale before we do anything that may end up converting
* paths or we'll end up using the "C" locale for path conversion.
*/
setlocale(LC_CTYPE, "");
/*
* The Process ID.
*/
#ifdef _MSC_VER
g_ProcessSelf = _getpid(); /* crappy ansi compiler */
#else
g_ProcessSelf = getpid();
#endif
/*
* Save the init flags.
*/
g_fInitFlags |= fFlags;
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
# ifdef VBOX
/*
* This MUST be done as the very first thing, before any file is opened.
* The log is opened on demand, but the first log entries may be caused
* by rtThreadInit() below.
*/
const char *pszDisableHostCache = getenv("VBOX_DISABLE_HOST_DISK_CACHE");
if ( pszDisableHostCache != NULL
&& *pszDisableHostCache
&& strcmp(pszDisableHostCache, "0") != 0)
{
RTFileSetForceFlags(RTFILE_O_WRITE, RTFILE_O_WRITE_THROUGH, 0);
RTFileSetForceFlags(RTFILE_O_READWRITE, RTFILE_O_WRITE_THROUGH, 0);
}
# endif /* VBOX */
#endif /* !IN_GUEST && !RT_NO_GIP */
/*
* Thread Thread database and adopt the caller thread as 'main'.
* This must be done before everything else or else we'll call into threading
* without having initialized TLS entries and suchlike.
*/
rc = rtThreadInit();
AssertMsgRCReturn(rc, ("Failed to initialize threads, rc=%Rrc!\n", rc), rc);
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
if (fFlags & RTR3INIT_FLAGS_SUPLIB)
{
/*
* Init GIP first.
* (The more time for updates before real use, the better.)
*/
rc = SUPR3Init(NULL);
AssertMsgRCReturn(rc, ("Failed to initializable the support library, rc=%Rrc!\n", rc), rc);
}
#endif
/*
* The executable path, name and directory. Convert arguments.
*/
rc = rtR3InitProgramPath(pszProgramPath);
AssertLogRelMsgRCReturn(rc, ("Failed to get executable directory path, rc=%Rrc!\n", rc), rc);
rc = rtR3InitArgv(fFlags, cArgs, papszArgs);
AssertLogRelMsgRCReturn(rc, ("Failed to convert the arguments, rc=%Rrc!\n", rc), rc);
#if !defined(IN_GUEST) && !defined(RT_NO_GIP)
/*
* The threading is initialized we can safely sleep a bit if GIP
* needs some time to update itself updating.
*/
if ((fFlags & RTR3INIT_FLAGS_SUPLIB) && g_pSUPGlobalInfoPage)
{
RTThreadSleep(20);
RTTimeNanoTS();
}
#endif
/*
* Init the program start TSes.
* Do that here to be sure that the GIP time was properly updated the 1st time.
*/
g_u64ProgramStartNanoTS = RTTimeNanoTS();
g_u64ProgramStartMicroTS = g_u64ProgramStartNanoTS / 1000;
g_u64ProgramStartMilliTS = g_u64ProgramStartNanoTS / 1000000;
/*
* The remainder cannot easily be undone, so it has to go last.
*/
/* Fork and exit callbacks. */
#if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
rc = pthread_atfork(NULL, NULL, rtR3ForkChildCallback);
AssertMsg(rc == 0, ("%d\n", rc));
#endif
atexit(rtR3ExitCallback);
#ifdef IPRT_USE_SIG_CHILD_DUMMY
/*
* SIGCHLD must not be ignored (that's default), otherwise posix compliant waitpid
* implementations won't work right.
*/
for (;;)
{
struct sigaction saOld;
rc = sigaction(SIGCHLD, 0, &saOld); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
if ( rc != 0
|| (saOld.sa_flags & SA_SIGINFO)
|| ( saOld.sa_handler != SIG_IGN
&& saOld.sa_handler != SIG_DFL)
)
break;
/* Try install dummy handler. */
struct sigaction saNew = saOld;
saNew.sa_flags = SA_NOCLDSTOP | SA_RESTART;
saNew.sa_handler = rtR3SigChildHandler;
rc = sigemptyset(&saNew.sa_mask); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
struct sigaction saOld2;
rc = sigaction(SIGCHLD, &saNew, &saOld2); AssertMsg(rc == 0, ("%d/%d\n", rc, errno));
if ( rc != 0
|| ( saOld2.sa_handler == saOld.sa_handler
&& !(saOld2.sa_flags & SA_SIGINFO))
)
break;
/* Race during dynamic load, restore and try again... */
sigaction(SIGCHLD, &saOld2, NULL);
RTThreadYield();
}
#endif /* IPRT_USE_SIG_CHILD_DUMMY */
#ifdef IPRT_WITH_ALIGNMENT_CHECKS
/*
* Enable alignment checks.
*/
const char *pszAlignmentChecks = getenv("IPRT_ALIGNMENT_CHECKS");
g_fRTAlignmentChecks = pszAlignmentChecks != NULL
&& pszAlignmentChecks[0] == '1'
&& pszAlignmentChecks[1] == '\0';
if (g_fRTAlignmentChecks)
IPRT_ALIGNMENT_CHECKS_ENABLE();
#endif
/*
* Final native initialization.
*/
rc = rtR3InitNativeFinal(fFlags);
AssertMsgRCReturn(rc, ("rtR3InitNativeFinal failed with %Rrc\n", rc), rc);
return VINF_SUCCESS;
}
int main(int argc, char **argv)
{
int rc;
int rcRet = 0;
RTR3InitExe(argc, &argv, 0);
rc = SUPR3Init(NULL);
RTPrintf("tstContiguous: SUPR3Init -> rc=%Rrc\n", rc);
rcRet += rc != 0;
if (!rc)
{
/*
* Allocate a bit of contiguous memory.
*/
RTHCPHYS HCPhys;
void *pv = SUPR3ContAlloc(8, NIL_RTR0PTR, &HCPhys);
rcRet += pv == NULL || HCPhys == 0;
if (pv && HCPhys)
{
memset(pv, 0xff, PAGE_SIZE * 8);
pv = SUPR3ContAlloc(5, NIL_RTR0PTR, &HCPhys);
rcRet += pv == NULL || HCPhys == 0;
if (pv && HCPhys)
{
memset(pv, 0x7f, PAGE_SIZE * 5);
rc = SUPR3ContFree(pv, 5);
rcRet += rc != 0;
if (rc)
RTPrintf("tstContiguous: SUPR3ContFree failed! rc=%Rrc\n", rc);
void *apv[128];
for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
{
apv[i] = SUPR3ContAlloc(1 + (i % 11), NIL_RTR0PTR, &HCPhys);
if (!apv[i])
{
RTPrintf("tstContiguous: i=%d: failed to allocate %d pages\n", i, 1 + (i % 11));
rcRet++;
}
}
for (unsigned i = 0; i < RT_ELEMENTS(apv); i++)
if (apv[i])
{
rc = SUPR3ContFree(apv[i], 1 + (i % 11));
rcRet += rc != 0;
if (rc)
RTPrintf("tstContiguous: i=%d SUPR3ContFree failed! rc=%Rrc\n", i, rc);
}
}
else
RTPrintf("tstContiguous: SUPR3ContAlloc (2nd) failed!\n");
}
else
RTPrintf("tstContiguous: SUPR3ContAlloc failed!\n");
rc = SUPR3Term(false /*fForced*/);
RTPrintf("tstContiguous: SUPR3Term -> rc=%Rrc\n", rc);
rcRet += rc != 0;
}
return rcRet ? 1 : 0;
}
int main()
{
/*
* Init runtime.
*/
RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
/*
* Create empty VM structure and init SSM.
*/
PVM pVM;
int rc = SUPR3Init(NULL);
if (RT_SUCCESS(rc))
rc = SUPR3PageAlloc(RT_ALIGN_Z(sizeof(*pVM), PAGE_SIZE) >> PAGE_SHIFT, (void **)&pVM);
if (RT_FAILURE(rc))
{
RTPrintf("Fatal error: SUP Failure! rc=%Rrc\n", rc);
return 1;
}
static UVM s_UVM;
PUVM pUVM = &s_UVM;
pUVM->pVM = pVM;
pVM->pUVM = pUVM;
rc = STAMR3InitUVM(pUVM);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: STAMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
rc = MMR3InitUVM(pUVM);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: STAMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
rc = CFGMR3Init(pVM, NULL, NULL);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
if (!CFGMR3GetRoot(pVM))
{
RTPrintf("FAILURE: CFGMR3GetRoot failed\n");
return 1;
}
/* integer */
uint64_t u64;
rc = CFGMR3QueryU64(CFGMR3GetRoot(pVM), "RamSize", &u64);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3QueryU64(,\"RamSize\",) failed. rc=%Rrc\n", rc);
return 1;
}
size_t cb;
rc = CFGMR3QuerySize(CFGMR3GetRoot(pVM), "RamSize", &cb);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3QuerySize(,\"RamSize\",) failed. rc=%Rrc\n", rc);
return 1;
}
if (cb != sizeof(uint64_t))
{
RTPrintf("FAILURE: Incorrect valuesize %d for \"RamSize\" value.\n", cb);
return 1;
}
/* string */
char *pszName = NULL;
rc = CFGMR3QueryStringAlloc(CFGMR3GetRoot(pVM), "Name", &pszName);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3QueryStringAlloc(,\"Name\" failed. rc=%Rrc\n", rc);
return 1;
}
rc = CFGMR3QuerySize(CFGMR3GetRoot(pVM), "Name", &cb);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3QuerySize(,\"RamSize\",) failed. rc=%Rrc\n", rc);
return 1;
}
if (cb != strlen(pszName) + 1)
{
RTPrintf("FAILURE: Incorrect valuesize %d for \"Name\" value '%s'.\n", cb, pszName);
return 1;
}
MMR3HeapFree(pszName);
/* test multilevel node creation */
PCFGMNODE pChild = NULL;
rc = CFGMR3InsertNode(CFGMR3GetRoot(pVM), "First/Second/Third//Final", &pChild);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3InsertNode(,\"First/Second/Third//Final\" failed. rc=%Rrc\n", rc);
return 1;
}
rc = CFGMR3InsertInteger(pChild, "BoolValue", 1);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3InsertInteger(,\"BoolValue\", 1) failed. rc=%Rrc\n", rc);
return 1;
}
PCFGMNODE pNode = CFGMR3GetChild(CFGMR3GetRoot(pVM), "First/Second/Third/Final");
if (pNode != pChild)
{
RTPrintf("FAILURE: CFGMR3GetChild(,\"First/Second/Third/Final/BoolValue\") failed. pNode=%p expected %p\n", pNode, pChild);
return 1;
}
bool f = false;
rc = CFGMR3QueryBool(pNode, "BoolValue", &f);
if (RT_FAILURE(rc) || !f)
{
RTPrintf("FAILURE: CFGMR3QueryBool(,\"BoolValue\",) failed. rc=%Rrc f=%d\n", rc, f);
return 1;
}
/* done */
rc = CFGMR3Term(pVM);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3QueryU64(,\"RamSize\" failed. rc=%Rrc\n", rc);
return 1;
}
RTPrintf("tstCFGM: SUCCESS\n");
return rc;
}
int main(int argc, char **argv)
{
int rc;
int rcRet = 0;
RTR3InitExe(argc, &argv, 0);
RTPrintf("tstLow: TESTING...\n");
rc = SUPR3Init(NULL);
if (RT_SUCCESS(rc))
{
/*
* Allocate a bit of contiguous memory.
*/
SUPPAGE aPages0[128];
void *pvPages0 = (void *)0x77777777;
memset(&aPages0[0], 0x8f, sizeof(aPages0));
rc = SUPR3LowAlloc(RT_ELEMENTS(aPages0), &pvPages0, NULL, aPages0);
if (RT_SUCCESS(rc))
{
/* check that the pages are below 4GB and valid. */
for (unsigned iPage = 0; iPage < RT_ELEMENTS(aPages0); iPage++)
{
RTPrintf("%-4d: Phys=%RHp Reserved=%p\n", iPage, aPages0[iPage].Phys, aPages0[iPage].uReserved);
if (aPages0[iPage].uReserved != 0)
{
rcRet++;
RTPrintf("tstLow: error: aPages0[%d].uReserved=%#x expected 0!\n", iPage, aPages0[iPage].uReserved);
}
if ( aPages0[iPage].Phys >= _4G
|| (aPages0[iPage].Phys & PAGE_OFFSET_MASK))
{
rcRet++;
RTPrintf("tstLow: error: aPages0[%d].Phys=%RHp!\n", iPage, aPages0[iPage].Phys);
}
}
if (!rcRet)
{
for (unsigned iPage = 0; iPage < RT_ELEMENTS(aPages0); iPage++)
memset((char *)pvPages0 + iPage * PAGE_SIZE, iPage, PAGE_SIZE);
for (unsigned iPage = 0; iPage < RT_ELEMENTS(aPages0); iPage++)
for (uint8_t *pu8 = (uint8_t *)pvPages0 + iPage * PAGE_SIZE, *pu8End = pu8 + PAGE_SIZE; pu8 < pu8End; pu8++)
if (*pu8 != (uint8_t)iPage)
{
RTPrintf("tstLow: error: invalid page content %02x != %02x. iPage=%u off=%#x\n",
*pu8, (uint8_t)iPage, iPage, (uintptr_t)pu8 & PAGE_OFFSET_MASK);
rcRet++;
}
}
SUPR3LowFree(pvPages0, RT_ELEMENTS(aPages0));
}
else
{
RTPrintf("SUPR3LowAlloc(%d,,) failed -> rc=%Rrc\n", RT_ELEMENTS(aPages0), rc);
rcRet++;
}
/*
* Allocate odd amounts in from 1 to 127.
*/
for (unsigned cPages = 1; cPages <= 127; cPages++)
{
SUPPAGE aPages1[128];
void *pvPages1 = (void *)0x77777777;
memset(&aPages1[0], 0x8f, sizeof(aPages1));
rc = SUPR3LowAlloc(cPages, &pvPages1, NULL, aPages1);
if (RT_SUCCESS(rc))
{
/* check that the pages are below 4GB and valid. */
for (unsigned iPage = 0; iPage < cPages; iPage++)
{
RTPrintf("%-4d::%-4d: Phys=%RHp Reserved=%p\n", cPages, iPage, aPages1[iPage].Phys, aPages1[iPage].uReserved);
if (aPages1[iPage].uReserved != 0)
{
rcRet++;
RTPrintf("tstLow: error: aPages1[%d].uReserved=%#x expected 0!\n", iPage, aPages1[iPage].uReserved);
}
if ( aPages1[iPage].Phys >= _4G
|| (aPages1[iPage].Phys & PAGE_OFFSET_MASK))
{
rcRet++;
RTPrintf("tstLow: error: aPages1[%d].Phys=%RHp!\n", iPage, aPages1[iPage].Phys);
}
}
if (!rcRet)
{
for (unsigned iPage = 0; iPage < cPages; iPage++)
memset((char *)pvPages1 + iPage * PAGE_SIZE, iPage, PAGE_SIZE);
for (unsigned iPage = 0; iPage < cPages; iPage++)
for (uint8_t *pu8 = (uint8_t *)pvPages1 + iPage * PAGE_SIZE, *pu8End = pu8 + PAGE_SIZE; pu8 < pu8End; pu8++)
if (*pu8 != (uint8_t)iPage)
{
RTPrintf("tstLow: error: invalid page content %02x != %02x. iPage=%p off=%#x\n",
*pu8, (uint8_t)iPage, iPage, (uintptr_t)pu8 & PAGE_OFFSET_MASK);
rcRet++;
}
}
SUPR3LowFree(pvPages1, cPages);
}
else
{
RTPrintf("SUPR3LowAlloc(%d,,) failed -> rc=%Rrc\n", cPages, rc);
rcRet++;
}
}
}
else
{
RTPrintf("SUPR3Init -> rc=%Rrc\n", rc);
rcRet++;
}
return rcRet;
}
int VBoxNetBaseService::tryGoOnline(void)
{
/*
* Open the session, load ring-0 and issue the request.
*/
int rc = SUPR3Init(&m->m_pSession);
if (RT_FAILURE(rc))
{
m->m_pSession = NIL_RTR0PTR;
LogRel(("VBoxNetBaseService: SUPR3Init -> %Rrc\n", rc));
return rc;
}
char szPath[RTPATH_MAX];
rc = RTPathExecDir(szPath, sizeof(szPath) - sizeof("/VMMR0.r0"));
if (RT_FAILURE(rc))
{
LogRel(("VBoxNetBaseService: RTPathExecDir -> %Rrc\n", rc));
return rc;
}
rc = SUPR3LoadVMM(strcat(szPath, "/VMMR0.r0"));
if (RT_FAILURE(rc))
{
LogRel(("VBoxNetBaseService: SUPR3LoadVMM(\"%s\") -> %Rrc\n", szPath, rc));
return rc;
}
/*
* Create the open request.
*/
PINTNETBUF pBuf;
INTNETOPENREQ OpenReq;
OpenReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
OpenReq.Hdr.cbReq = sizeof(OpenReq);
OpenReq.pSession = m->m_pSession;
RTStrCopy(OpenReq.szNetwork, sizeof(OpenReq.szNetwork), m->m_NetworkName.c_str());
OpenReq.szNetwork[sizeof(OpenReq.szNetwork) - 1] = '\0';
RTStrCopy(OpenReq.szTrunk, sizeof(OpenReq.szTrunk), m->m_TrunkName.c_str());
OpenReq.szTrunk[sizeof(OpenReq.szTrunk) - 1] = '\0';
OpenReq.enmTrunkType = m->m_enmTrunkType;
OpenReq.fFlags = 0; /** @todo check this */
OpenReq.cbSend = m->m_cbSendBuf;
OpenReq.cbRecv = m->m_cbRecvBuf;
OpenReq.hIf = INTNET_HANDLE_INVALID;
/*
* Issue the request.
*/
Log2(("attempting to open/create network \"%s\"...\n", OpenReq.szNetwork));
rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_OPEN, 0, &OpenReq.Hdr);
if (RT_FAILURE(rc))
{
Log2(("VBoxNetBaseService: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_OPEN,) failed, rc=%Rrc\n", rc));
return rc;
}
m->m_hIf = OpenReq.hIf;
Log2(("successfully opened/created \"%s\" - hIf=%#x\n", OpenReq.szNetwork, m->m_hIf));
/*
* Get the ring-3 address of the shared interface buffer.
*/
INTNETIFGETBUFFERPTRSREQ GetBufferPtrsReq;
GetBufferPtrsReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
GetBufferPtrsReq.Hdr.cbReq = sizeof(GetBufferPtrsReq);
GetBufferPtrsReq.pSession = m->m_pSession;
GetBufferPtrsReq.hIf = m->m_hIf;
GetBufferPtrsReq.pRing3Buf = NULL;
GetBufferPtrsReq.pRing0Buf = NIL_RTR0PTR;
rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS, 0, &GetBufferPtrsReq.Hdr);
if (RT_FAILURE(rc))
{
Log2(("VBoxNetBaseService: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS,) failed, rc=%Rrc\n", rc));
return rc;
}
pBuf = GetBufferPtrsReq.pRing3Buf;
Log2(("pBuf=%p cbBuf=%d cbSend=%d cbRecv=%d\n",
pBuf, pBuf->cbBuf, pBuf->cbSend, pBuf->cbRecv));
m->m_pIfBuf = pBuf;
/*
* Activate the interface.
*/
INTNETIFSETACTIVEREQ ActiveReq;
ActiveReq.Hdr.u32Magic = SUPVMMR0REQHDR_MAGIC;
ActiveReq.Hdr.cbReq = sizeof(ActiveReq);
ActiveReq.pSession = m->m_pSession;
ActiveReq.hIf = m->m_hIf;
ActiveReq.fActive = true;
rc = SUPR3CallVMMR0Ex(NIL_RTR0PTR, NIL_VMCPUID, VMMR0_DO_INTNET_IF_SET_ACTIVE, 0, &ActiveReq.Hdr);
if (RT_SUCCESS(rc))
return 0;
/* bail out */
Log2(("VBoxNetBaseService: SUPR3CallVMMR0Ex(,VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE,) failed, rc=%Rrc\n", rc));
/* ignore this error */
return VINF_SUCCESS;
}
/**
* Entry point.
*/
extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv, char **envp)
{
/*
* Init runtime.
*/
RTR3InitExe(argc, &argv, 0);
/*
* Create empty VM structure and call MMR3Init().
*/
PVM pVM;
RTR0PTR pvR0;
SUPPAGE aPages[RT_ALIGN_Z(sizeof(*pVM) + NUM_CPUS * sizeof(VMCPU), PAGE_SIZE) >> PAGE_SHIFT];
int rc = SUPR3Init(NULL);
if (RT_SUCCESS(rc))
rc = SUPR3LowAlloc(RT_ELEMENTS(aPages), (void **)&pVM, &pvR0, &aPages[0]);
if (RT_FAILURE(rc))
{
RTPrintf("Fatal error: SUP Failure! rc=%Rrc\n", rc);
return 1;
}
memset(pVM, 0, sizeof(*pVM)); /* wtf? */
pVM->paVMPagesR3 = aPages;
pVM->pVMR0 = pvR0;
static UVM s_UVM;
PUVM pUVM = &s_UVM;
pUVM->pVM = pVM;
pVM->pUVM = pUVM;
pVM->cCpus = NUM_CPUS;
pVM->cbSelf = RT_UOFFSETOF(VM, aCpus[pVM->cCpus]);
rc = STAMR3InitUVM(pUVM);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: STAMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
rc = MMR3InitUVM(pUVM);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: STAMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
rc = CFGMR3Init(pVM, NULL, NULL);
if (RT_FAILURE(rc))
{
RTPrintf("FAILURE: CFGMR3Init failed. rc=%Rrc\n", rc);
return 1;
}
rc = MMR3Init(pVM);
if (RT_FAILURE(rc))
{
RTPrintf("Fatal error: MMR3Init failed! rc=%Rrc\n", rc);
return 1;
}
/*
* Try allocate.
*/
static struct
{
size_t cb;
unsigned uAlignment;
void *pvAlloc;
unsigned iFreeOrder;
} aOps[] =
{
{ 16, 0, NULL, 0 },
{ 16, 4, NULL, 1 },
{ 16, 8, NULL, 2 },
{ 16, 16, NULL, 5 },
{ 16, 32, NULL, 4 },
{ 32, 0, NULL, 3 },
{ 31, 0, NULL, 6 },
{ 1024, 0, NULL, 8 },
{ 1024, 32, NULL, 10 },
{ 1024, 32, NULL, 12 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 13 },
{ 1024, 32, NULL, 9 },
{ PAGE_SIZE, 32, NULL, 11 },
{ PAGE_SIZE, PAGE_SIZE, NULL, 14 },
{ 16, 0, NULL, 15 },
{ 9, 0, NULL, 7 },
{ 16, 0, NULL, 7 },
{ 36, 0, NULL, 7 },
{ 16, 0, NULL, 7 },
{ 12344, 0, NULL, 7 },
{ 50, 0, NULL, 7 },
{ 16, 0, NULL, 7 },
};
unsigned i;
#ifdef DEBUG
MMHyperHeapDump(pVM);
#endif
size_t cbBefore = MMHyperHeapGetFreeSize(pVM);
static char szFill[] = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
/* allocate */
for (i = 0; i < RT_ELEMENTS(aOps); i++)
{
rc = MMHyperAlloc(pVM, aOps[i].cb, aOps[i].uAlignment, MM_TAG_VM, &aOps[i].pvAlloc);
if (RT_FAILURE(rc))
{
RTPrintf("Failure: MMHyperAlloc(, %#x, %#x,) -> %d i=%d\n", aOps[i].cb, aOps[i].uAlignment, rc, i);
return 1;
}
memset(aOps[i].pvAlloc, szFill[i], aOps[i].cb);
if (RT_ALIGN_P(aOps[i].pvAlloc, (aOps[i].uAlignment ? aOps[i].uAlignment : 8)) != aOps[i].pvAlloc)
{
RTPrintf("Failure: MMHyperAlloc(, %#x, %#x,) -> %p, invalid alignment!\n", aOps[i].cb, aOps[i].uAlignment, aOps[i].pvAlloc);
return 1;
}
}
/* free and allocate the same node again. */
for (i = 0; i < RT_ELEMENTS(aOps); i++)
{
if ( !aOps[i].pvAlloc
|| aOps[i].uAlignment == PAGE_SIZE)
continue;
//size_t cbBeforeSub = MMHyperHeapGetFreeSize(pVM);
rc = MMHyperFree(pVM, aOps[i].pvAlloc);
if (RT_FAILURE(rc))
{
RTPrintf("Failure: MMHyperFree(, %p,) -> %d i=%d\n", aOps[i].pvAlloc, rc, i);
return 1;
}
//RTPrintf("debug: i=%d cbBeforeSub=%d now=%d\n", i, cbBeforeSub, MMHyperHeapGetFreeSize(pVM));
void *pv;
rc = MMHyperAlloc(pVM, aOps[i].cb, aOps[i].uAlignment, MM_TAG_VM_REQ, &pv);
if (RT_FAILURE(rc))
{
RTPrintf("Failure: MMHyperAlloc(, %#x, %#x,) -> %d i=%d\n", aOps[i].cb, aOps[i].uAlignment, rc, i);
return 1;
}
if (pv != aOps[i].pvAlloc)
{
RTPrintf("Failure: Free+Alloc returned different address. new=%p old=%p i=%d (doesn't work with delayed free)\n", pv, aOps[i].pvAlloc, i);
//return 1;
}
aOps[i].pvAlloc = pv;
#if 0 /* won't work :/ */
size_t cbAfterSub = MMHyperHeapGetFreeSize(pVM);
if (cbBeforeSub != cbAfterSub)
{
RTPrintf("Failure: cbBeforeSub=%d cbAfterSub=%d. i=%d\n", cbBeforeSub, cbAfterSub, i);
return 1;
}
#endif
}
/* free it in a specific order. */
int cFreed = 0;
for (i = 0; i < RT_ELEMENTS(aOps); i++)
{
unsigned j;
for (j = 0; j < RT_ELEMENTS(aOps); j++)
{
if ( aOps[j].iFreeOrder != i
|| !aOps[j].pvAlloc)
continue;
RTPrintf("j=%d i=%d free=%d cb=%d pv=%p\n", j, i, MMHyperHeapGetFreeSize(pVM), aOps[j].cb, aOps[j].pvAlloc);
if (aOps[j].uAlignment == PAGE_SIZE)
cbBefore -= aOps[j].cb;
else
{
rc = MMHyperFree(pVM, aOps[j].pvAlloc);
if (RT_FAILURE(rc))
{
RTPrintf("Failure: MMHyperFree(, %p,) -> %d j=%d i=%d\n", aOps[j].pvAlloc, rc, i, j);
return 1;
}
}
aOps[j].pvAlloc = NULL;
cFreed++;
}
}
Assert(cFreed == RT_ELEMENTS(aOps));
RTPrintf("i=done free=%d\n", MMHyperHeapGetFreeSize(pVM));
/* check that we're back at the right amount of free memory. */
size_t cbAfter = MMHyperHeapGetFreeSize(pVM);
if (cbBefore != cbAfter)
{
RTPrintf("Warning: Either we've split out an alignment chunk at the start, or we've got\n"
" an alloc/free accounting bug: cbBefore=%d cbAfter=%d\n", cbBefore, cbAfter);
#ifdef DEBUG
MMHyperHeapDump(pVM);
#endif
}
RTPrintf("tstMMHyperHeap: Success\n");
#ifdef LOG_ENABLED
RTLogFlush(NULL);
#endif
return 0;
}
int main (int argc, char **argv)
{
#ifndef VBOX
RTPrintf("tstSup: SKIPPED\n");
return 0;
#else
/*
* Init.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTR0DbgKrnlInfo", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
uint8_t *pbPage = (uint8_t *)RTTestGuardedAllocTail(hTest, PAGE_SIZE);
if (!pbPage)
{
RTTestFailed(hTest, "RTTestGuardedAllocTail failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
char szPath[RTPATH_MAX];
rc = RTPathExecDir(szPath, sizeof(szPath));
if (RT_SUCCESS(rc))
rc = RTPathAppend(szPath, sizeof(szPath), "tstRTR0DbgKrnlInfo.r0");
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "Failed constructing .r0 filename (rc=%Rrc)", rc);
return RTTestSummaryAndDestroy(hTest);
}
void *pvImageBase;
rc = SUPR3LoadServiceModule(szPath, "tstRTR0DbgKrnlInfo",
"TSTR0DbgKrnlInfoSrvReqHandler",
&pvImageBase);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3LoadServiceModule(%s,,,) failed with rc=%Rrc\n", szPath, rc);
return RTTestSummaryAndDestroy(hTest);
}
/* test request */
struct
{
SUPR0SERVICEREQHDR Hdr;
char szMsg[256];
} Req;
/*
* Sanity checks.
*/
RTTestSub(hTest, "Sanity");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_SANITY_OK, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(Req.szMsg[0] == '\0', ("%s", Req.szMsg));
if (Req.szMsg[0] != '\0')
return RTTestSummaryAndDestroy(hTest);
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_SANITY_FAILURE, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(!strncmp(Req.szMsg, RT_STR_TUPLE("!42failure42")), ("%s", Req.szMsg));
if (strncmp(Req.szMsg, RT_STR_TUPLE("!42failure42")))
return RTTestSummaryAndDestroy(hTest);
/*
* Basic tests, bail out on failure.
*/
RTTestSub(hTest, "Basics");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstRTR0DbgKrnlInfo", sizeof("tstRTR0DbgKrnlInfo") - 1,
TSTRTR0DBGKRNLINFO_BASIC, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
if (Req.szMsg[0] == '!')
{
RTTestIFailed("%s", &Req.szMsg[1]);
return RTTestSummaryAndDestroy(hTest);
}
if (Req.szMsg[0])
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
/*
* Done.
*/
return RTTestSummaryAndDestroy(hTest);
#endif
}
int main(int argc, char **argv)
{
#ifndef VBOX
RTPrintf("tstSup: SKIPPED\n");
return 0;
#else
/*
* Init.
*/
RTTEST hTest;
int rc = RTTestInitAndCreate("tstR0ThreadPreemption", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
char szPath[RTPATH_MAX];
rc = RTPathExecDir(szPath, sizeof(szPath));
if (RT_SUCCESS(rc))
rc = RTPathAppend(szPath, sizeof(szPath), "tstR0ThreadPreemption.r0");
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "Failed constructing .r0 filename (rc=%Rrc)", rc);
return RTTestSummaryAndDestroy(hTest);
}
void *pvImageBase;
rc = SUPR3LoadServiceModule(szPath, "tstR0ThreadPreemption",
"TSTR0ThreadPreemptionSrvReqHandler",
&pvImageBase);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3LoadServiceModule(%s,,,) failed with rc=%Rrc\n", szPath, rc);
return RTTestSummaryAndDestroy(hTest);
}
/* test request */
struct
{
SUPR0SERVICEREQHDR Hdr;
char szMsg[256];
} Req;
/*
* Sanity checks.
*/
RTTestSub(hTest, "Sanity");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstR0ThreadPreemption", sizeof("tstR0ThreadPreemption") - 1,
TSTR0THREADPREMEPTION_SANITY_OK, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(Req.szMsg[0] == '\0', ("%s", Req.szMsg));
if (Req.szMsg[0] != '\0')
return RTTestSummaryAndDestroy(hTest);
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstR0ThreadPreemption", sizeof("tstR0ThreadPreemption") - 1,
TSTR0THREADPREMEPTION_SANITY_FAILURE, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
RTTESTI_CHECK_MSG(!strncmp(Req.szMsg, "!42failure42", sizeof("!42failure42") - 1), ("%s", Req.szMsg));
if (strncmp(Req.szMsg, "!42failure42", sizeof("!42failure42") - 1))
return RTTestSummaryAndDestroy(hTest);
/*
* Basic tests, bail out on failure.
*/
RTTestSub(hTest, "Basics");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstR0ThreadPreemption", sizeof("tstR0ThreadPreemption") - 1,
TSTR0THREADPREMEPTION_BASIC, 0, &Req.Hdr), VINF_SUCCESS);
if (RT_FAILURE(rc))
return RTTestSummaryAndDestroy(hTest);
if (Req.szMsg[0] == '!')
{
RTTestIFailed("%s", &Req.szMsg[1]);
return RTTestSummaryAndDestroy(hTest);
}
if (Req.szMsg[0])
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
/*
* Stay in ring-0 until preemption is pending.
*/
RTThreadSleep(250); /** @todo fix GIP initialization? */
RTTestSub(hTest, "Pending Preemption");
for (int i = 0; ; i++)
{
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstR0ThreadPreemption", sizeof("tstR0ThreadPreemption") - 1,
TSTR0THREADPREMEPTION_IS_PENDING, 0, &Req.Hdr), VINF_SUCCESS);
if ( strcmp(Req.szMsg, "cLoops=1\n")
|| i >= 64)
{
if (Req.szMsg[0] == '!')
RTTestIFailed("%s", &Req.szMsg[1]);
else if (Req.szMsg[0])
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
break;
}
if ((i % 3) == 0)
RTThreadYield();
}
/*
* Test nested RTThreadPreemptDisable calls.
*/
RTTestSub(hTest, "Nested");
Req.Hdr.u32Magic = SUPR0SERVICEREQHDR_MAGIC;
Req.Hdr.cbReq = sizeof(Req);
Req.szMsg[0] = '\0';
RTTESTI_CHECK_RC(rc = SUPR3CallR0Service("tstR0ThreadPreemption", sizeof("tstR0ThreadPreemption") - 1,
TSTR0THREADPREMEPTION_NESTED, 0, &Req.Hdr), VINF_SUCCESS);
if (Req.szMsg[0] == '!')
RTTestIFailed("%s", &Req.szMsg[1]);
else if (Req.szMsg[0])
RTTestIPrintf(RTTESTLVL_ALWAYS, "%s", Req.szMsg);
/*
* Done.
*/
return RTTestSummaryAndDestroy(hTest);
#endif
}
int main(int argc, char **argv)
{
RTR3InitExe(argc, &argv, 0);
/*
* Parse args
*/
static const RTGETOPTDEF g_aOptions[] =
{
{ "--iterations", 'i', RTGETOPT_REQ_INT32 },
{ "--hex", 'h', RTGETOPT_REQ_NOTHING },
{ "--decimal", 'd', RTGETOPT_REQ_NOTHING },
{ "--spin", 's', RTGETOPT_REQ_NOTHING }
};
uint32_t cIterations = 40;
bool fHex = true;
bool fSpin = false;
int ch;
RTGETOPTUNION ValueUnion;
RTGETOPTSTATE GetState;
RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
while ((ch = RTGetOpt(&GetState, &ValueUnion)))
{
switch (ch)
{
case 'i':
cIterations = ValueUnion.u32;
break;
case 'd':
fHex = false;
break;
case 'h':
fHex = true;
break;
case 's':
fSpin = true;
break;
default:
return RTGetOptPrintError(ch, &ValueUnion);
}
}
/*
* Init
*/
PSUPDRVSESSION pSession = NIL_RTR0PTR;
int rc = SUPR3Init(&pSession);
if (RT_SUCCESS(rc))
{
if (g_pSUPGlobalInfoPage)
{
RTPrintf("tstGIP-2: u32UpdateHz=%RU32 u32UpdateIntervalNS=%RU32 u64NanoTSLastUpdateHz=%RX64 u32Mode=%d (%s) u32Version=%#x\n",
g_pSUPGlobalInfoPage->u32UpdateHz,
g_pSUPGlobalInfoPage->u32UpdateIntervalNS,
g_pSUPGlobalInfoPage->u64NanoTSLastUpdateHz,
g_pSUPGlobalInfoPage->u32Mode,
g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_SYNC_TSC ? "sync"
: g_pSUPGlobalInfoPage->u32Mode == SUPGIPMODE_ASYNC_TSC ? "async"
: "???",
g_pSUPGlobalInfoPage->u32Version);
RTPrintf(fHex
? "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz TSC Interval History...\n"
: "tstGIP-2: it: u64NanoTS delta u64TSC UpIntTSC H TransId CpuHz TSC Interval History...\n");
static SUPGIPCPU s_aaCPUs[2][RT_ELEMENTS(g_pSUPGlobalInfoPage->aCPUs)];
for (uint32_t i = 0; i < cIterations; i++)
{
/* copy the data */
memcpy(&s_aaCPUs[i & 1][0], &g_pSUPGlobalInfoPage->aCPUs[0], sizeof(g_pSUPGlobalInfoPage->aCPUs));
/* display it & find something to spin on. */
uint32_t u32TransactionId = 0;
uint32_t volatile *pu32TransactionId = NULL;
for (unsigned iCpu = 0; iCpu < RT_ELEMENTS(g_pSUPGlobalInfoPage->aCPUs); iCpu++)
if ( g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz > 0
&& g_pSUPGlobalInfoPage->aCPUs[iCpu].u64CpuHz != _4G + 1)
{
PSUPGIPCPU pPrevCpu = &s_aaCPUs[!(i & 1)][iCpu];
PSUPGIPCPU pCpu = &s_aaCPUs[i & 1][iCpu];
RTPrintf(fHex
? "tstGIP-2: %4d/%d: %016llx %09llx %016llx %08x %d %08x %15llu %08x %08x %08x %08x %08x %08x %08x %08x (%d)\n"
: "tstGIP-2: %4d/%d: %016llu %09llu %016llu %010u %d %010u %15llu %08x %08x %08x %08x %08x %08x %08x %08x (%d)\n",
i, iCpu,
pCpu->u64NanoTS,
i ? pCpu->u64NanoTS - pPrevCpu->u64NanoTS : 0,
pCpu->u64TSC,
pCpu->u32UpdateIntervalTSC,
pCpu->iTSCHistoryHead,
pCpu->u32TransactionId,
pCpu->u64CpuHz,
pCpu->au32TSCHistory[0],
pCpu->au32TSCHistory[1],
pCpu->au32TSCHistory[2],
pCpu->au32TSCHistory[3],
pCpu->au32TSCHistory[4],
pCpu->au32TSCHistory[5],
pCpu->au32TSCHistory[6],
pCpu->au32TSCHistory[7],
pCpu->cErrors);
if (!pu32TransactionId)
{
pu32TransactionId = &g_pSUPGlobalInfoPage->aCPUs[iCpu].u32TransactionId;
u32TransactionId = pCpu->u32TransactionId;
}
}
/* wait a bit / spin */
if (!fSpin)
RTThreadSleep(9);
else
while (u32TransactionId == *pu32TransactionId)
/* nop */;
}
}
else
{
RTPrintf("tstGIP-2: g_pSUPGlobalInfoPage is NULL\n");
rc = -1;
}
SUPR3Term(false /*fForced*/);
}
else
RTPrintf("tstGIP-2: SUPR3Init failed: %Rrc\n", rc);
return !!rc;
}
static int mainChild(void)
{
/*
* Init.
*/
int rc = RTR3InitExeNoArguments(RTR3INIT_FLAGS_SUPLIB);
if (RT_FAILURE(rc))
{
RTPrintf("tstSupSem-Zombie-Child: fatal error: RTR3InitExeNoArguments failed with rc=%Rrc\n", rc);
return 1;
}
RTTEST hTest;
rc = RTTestCreate("tstSupSem-Zombie-Child", &hTest);
if (RT_FAILURE(rc))
{
RTPrintf("tstSupSem-Zombie-Child: fatal error: RTTestCreate failed with rc=%Rrc\n", rc);
return 1;
}
g_hTest = hTest;
PSUPDRVSESSION pSession;
rc = SUPR3Init(&pSession);
if (RT_FAILURE(rc))
{
RTTestFailed(hTest, "SUPR3Init failed with rc=%Rrc\n", rc);
return RTTestSummaryAndDestroy(hTest);
}
g_pSession = pSession;
/*
* A semaphore of each kind and throw a bunch of threads on them.
*/
SUPSEMEVENT hEvent = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(rc = SUPSemEventCreate(pSession, &hEvent), VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
SUPSEMEVENTMULTI hEventMulti = NIL_SUPSEMEVENT;
RTTESTI_CHECK_RC(SUPSemEventMultiCreate(pSession, &hEventMulti), VINF_SUCCESS);
if (RT_SUCCESS(rc))
{
for (uint32_t cThreads = 0; cThreads < 5; cThreads++)
{
RTTHREAD hThread;
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemSRETimed, (void *)hEvent, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemMRETimed, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntMRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemSREInf, (void *)hEvent, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntSRE"), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTThreadCreate(&hThread, tstSupSemMREInf, (void *)hEventMulti, 0, RTTHREADTYPE_TIMER, 0 /*fFlags*/, "IntMRE"), VINF_SUCCESS);
RTThreadSleep(2);
}
RTThreadSleep(50);
/*
* This is where the test really starts...
*/
return 0;
}
}
return RTTestSummaryAndDestroy(hTest);
}