RTDECL(int) RTTimerCreate(PRTTIMER *ppTimer, unsigned uMilliesInterval, PFNRTTIMER pfnTimer, void *pvUser)
{
int rc = RTTimerCreateEx(ppTimer, uMilliesInterval * UINT64_C(1000000), 0, pfnTimer, pvUser);
if (RT_SUCCESS(rc))
{
rc = RTTimerStart(*ppTimer, 0);
if (RT_FAILURE(rc))
{
int rc2 = RTTimerDestroy(*ppTimer); AssertRC(rc2);
*ppTimer = NULL;
}
}
return rc;
}
RTDECL(int) RTTimerCreate(PRTTIMER *ppTimer, unsigned uMilliesInterval, PFNRTTIMER pfnTimer, void *pvUser)
{
int rc = RTTimerCreateEx(ppTimer, uMilliesInterval * RT_NS_1MS_64, 0 /* fFlags */, pfnTimer, pvUser);
if (RT_SUCCESS(rc))
{
rc = RTTimerStart(*ppTimer, 0 /* u64First */);
if (RT_FAILURE(rc))
{
int rc2 = RTTimerDestroy(*ppTimer); AssertRC(rc2);
*ppTimer = NULL;
}
}
return rc;
}
int main()
{
/*
* Init runtime
*/
unsigned cErrors = 0;
int rc = RTR3InitExeNoArguments(0);
if (RT_FAILURE(rc))
return RTMsgInitFailure(rc);
/*
* Check that the clock is reliable.
*/
RTPrintf("tstTimer: TESTING - RTTimeNanoTS() for 2sec\n");
uint64_t uTSMillies = RTTimeMilliTS();
uint64_t uTSBegin = RTTimeNanoTS();
uint64_t uTSLast = uTSBegin;
uint64_t uTSDiff;
uint64_t cIterations = 0;
do
{
uint64_t uTS = RTTimeNanoTS();
if (uTS < uTSLast)
{
RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. uTS=%RU64 uTSLast=%RU64\n", uTS, uTSLast);
cErrors++;
}
if (++cIterations > (2*1000*1000*1000))
{
RTPrintf("tstTimer: FAILURE - RTTimeNanoTS() is unreliable. cIterations=%RU64 uTS=%RU64 uTSBegin=%RU64\n", cIterations, uTS, uTSBegin);
return 1;
}
uTSLast = uTS;
uTSDiff = uTSLast - uTSBegin;
} while (uTSDiff < (2*1000*1000*1000));
uTSMillies = RTTimeMilliTS() - uTSMillies;
if (uTSMillies >= 2500 || uTSMillies <= 1500)
{
RTPrintf("tstTimer: FAILURE - uTSMillies=%RI64 uTSBegin=%RU64 uTSLast=%RU64 uTSDiff=%RU64\n",
uTSMillies, uTSBegin, uTSLast, uTSDiff);
cErrors++;
}
if (!cErrors)
RTPrintf("tstTimer: OK - RTTimeNanoTS()\n");
/*
* Tests.
*/
static struct
{
unsigned uMicroInterval;
unsigned uMilliesWait;
unsigned cLower;
unsigned cUpper;
} aTests[] =
{
{ 32000, 2000, 0, 0 },
{ 20000, 2000, 0, 0 },
{ 10000, 2000, 0, 0 },
{ 8000, 2000, 0, 0 },
{ 2000, 2000, 0, 0 },
{ 1000, 2000, 0, 0 },
{ 500, 5000, 0, 0 },
{ 200, 5000, 0, 0 },
{ 100, 5000, 0, 0 }
};
unsigned i = 0;
for (i = 0; i < RT_ELEMENTS(aTests); i++)
{
aTests[i].cLower = (aTests[i].uMilliesWait*1000 - aTests[i].uMilliesWait*100) / aTests[i].uMicroInterval;
aTests[i].cUpper = (aTests[i].uMilliesWait*1000 + aTests[i].uMilliesWait*100) / aTests[i].uMicroInterval;
gu64Norm = aTests[i].uMicroInterval*1000;
RTPrintf("\n"
"tstTimer: TESTING - %d us interval, %d ms wait, expects %d-%d ticks.\n",
aTests[i].uMicroInterval, aTests[i].uMilliesWait, aTests[i].cLower, aTests[i].cUpper);
/*
* Start timer which ticks every 10ms.
*/
gcTicks = 0;
PRTTIMER pTimer;
gu64Max = 0;
gu64Min = UINT64_MAX;
gu64Prev = 0;
RT_ZERO(cFrequency);
#ifdef RT_OS_WINDOWS
if (aTests[i].uMicroInterval < 1000)
continue;
rc = RTTimerCreate(&pTimer, aTests[i].uMicroInterval / 1000, TimerCallback, NULL);
#else
rc = RTTimerCreateEx(&pTimer, aTests[i].uMicroInterval * (uint64_t)1000, 0, TimerCallback, NULL);
#endif
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerCreateEx(,%u*1M,,,) -> %Rrc\n", aTests[i].uMicroInterval, rc);
cErrors++;
continue;
}
/*
* Start the timer and active waiting for the requested test period.
*/
uTSBegin = RTTimeNanoTS();
#ifndef RT_OS_WINDOWS
rc = RTTimerStart(pTimer, 0);
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerStart(,0) -> %Rrc\n", rc);
cErrors++;
}
#endif
while (RTTimeNanoTS() - uTSBegin < (uint64_t)aTests[i].uMilliesWait * 1000000)
/* nothing */;
/* destroy the timer */
uint64_t uTSEnd = RTTimeNanoTS();
uTSDiff = uTSEnd - uTSBegin;
rc = RTTimerDestroy(pTimer);
if (RT_FAILURE(rc))
{
RTPrintf("tstTimer: FAILURE - RTTimerDestroy() -> %d gcTicks=%d\n", rc, gcTicks);
cErrors++;
}
RTPrintf("tstTimer: uTS=%RI64 (%RU64 - %RU64)\n", uTSDiff, uTSBegin, uTSEnd);
unsigned cTicks = gcTicks;
RTThreadSleep(aTests[i].uMicroInterval/1000 * 3);
if (gcTicks != cTicks)
{
RTPrintf("tstTimer: FAILURE - RTTimerDestroy() didn't really stop the timer! gcTicks=%d cTicks=%d\n", gcTicks, cTicks);
cErrors++;
continue;
}
/*
* Check the number of ticks.
*/
if (gcTicks < aTests[i].cLower)
{
RTPrintf("tstTimer: FAILURE - Too few ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
cErrors++;
}
else if (gcTicks > aTests[i].cUpper)
{
RTPrintf("tstTimer: FAILURE - Too many ticks gcTicks=%d (expected %d-%d)", gcTicks, aTests[i].cUpper, aTests[i].cLower);
cErrors++;
}
else
RTPrintf("tstTimer: OK - gcTicks=%d", gcTicks);
RTPrintf(" min=%RU64 max=%RU64\n", gu64Min, gu64Max);
for (int j = 0; j < (int)RT_ELEMENTS(cFrequency); j++)
{
uint32_t len = cFrequency[j] * 70 / gcTicks;
uint32_t deviation = j - RT_ELEMENTS(cFrequency) / 2;
uint64_t u64FreqPercent = (uint64_t)cFrequency[j] * 10000 / gcTicks;
uint64_t u64FreqPercentFrac = u64FreqPercent % 100;
u64FreqPercent = u64FreqPercent / 100;
RTPrintf("%+4d%c %6u %3llu.%02llu%% ",
deviation, deviation == 0 ? ' ' : '%', cFrequency[j],
u64FreqPercent, u64FreqPercentFrac);
for (unsigned k = 0; k < len; k++)
RTPrintf("*");
RTPrintf("\n");
}
}
/*
* Summary.
*/
if (!cErrors)
RTPrintf("tstTimer: SUCCESS\n");
else
RTPrintf("tstTimer: FAILURE %d errors\n", cErrors);
return !!cErrors;
}
/**
* Attach entry point, to attach a device to the system or resume it.
*
* @param pDip The module structure instance.
* @param enmCmd Operation type (attach/resume).
*
* @return corresponding solaris error code.
*/
static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
{
LogFlowFunc(("VBoxDrvSolarisAttach\n"));
switch (enmCmd)
{
case DDI_ATTACH:
{
int rc;
#ifdef USE_SESSION_HASH
int instance = ddi_get_instance(pDip);
vbox_devstate_t *pState;
if (ddi_soft_state_zalloc(g_pVBoxDrvSolarisState, instance) != DDI_SUCCESS)
{
LogRel(("VBoxDrvSolarisAttach: state alloc failed\n"));
return DDI_FAILURE;
}
pState = ddi_get_soft_state(g_pVBoxDrvSolarisState, instance);
#endif
/*
* Register for suspend/resume notifications
*/
rc = ddi_prop_create(DDI_DEV_T_NONE, pDip, DDI_PROP_CANSLEEP /* kmem alloc can sleep */,
"pm-hardware-state", "needs-suspend-resume", sizeof("needs-suspend-resume"));
if (rc != DDI_PROP_SUCCESS)
LogRel(("vboxdrv: Suspend/Resume notification registration failed.\n"));
/*
* Register ourselves as a character device, pseudo-driver
*/
#ifdef VBOX_WITH_HARDENING
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, NULL, NULL, 0600);
#else
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_SYS, S_IFCHR, 0 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
#endif
if (rc == DDI_SUCCESS)
{
rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME_USR, S_IFCHR, 1 /*minor*/, DDI_PSEUDO,
0, "none", "none", 0666);
if (rc == DDI_SUCCESS)
{
#ifdef USE_SESSION_HASH
pState->pDip = pDip;
#endif
ddi_report_dev(pDip);
return DDI_SUCCESS;
}
ddi_remove_minor_node(pDip, NULL);
}
return DDI_FAILURE;
}
case DDI_RESUME:
{
#if 0
RTSemFastMutexRequest(g_DevExt.mtxGip);
if (g_DevExt.pGipTimer)
RTTimerStart(g_DevExt.pGipTimer, 0);
RTSemFastMutexRelease(g_DevExt.mtxGip);
#endif
RTPowerSignalEvent(RTPOWEREVENT_RESUME);
LogFlow(("vboxdrv: Awakened from suspend.\n"));
return DDI_SUCCESS;
}
default:
return DDI_FAILURE;
}
return DDI_FAILURE;
}