VirtualBox

Changeset 87766 in vbox


Ignore:
Timestamp:
Feb 16, 2021 2:27:43 PM (4 years ago)
Author:
vboxsync
Message:

VMM/TM,VMM/*: Refactored the TM timer APIs to use 'handles' and take a pVM parameter. Only internal callbacks have been updated with a hTimer parameter, so far. bugref:9943

Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/tm.h

    r87765 r87766  
    215215 *
    216216 * @param   pVM             The cross context VM structure.
    217  * @param   pTimer          The timer handle.
     217 * @param   hTimer          The timer handle.
    218218 * @param   pvUser          User argument specified upon timer creation.
    219219 */
    220 typedef DECLCALLBACKTYPE(void, FNTMTIMERINT,(PVM pVM, PTMTIMER pTimer, void *pvUser));
     220typedef DECLCALLBACKTYPE(void, FNTMTIMERINT,(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser));
    221221/** Pointer to internal timer callback function. */
    222222typedef FNTMTIMERINT *PFNTMTIMERINT;
    … …  
    231231typedef FNTMTIMEREXT *PFNTMTIMEREXT;
    232232
    233 VMMDECL(PTMTIMERR3)     TMTimerR3Ptr(PTMTIMER pTimer);
    234 VMMDECL(PTMTIMERR0)     TMTimerR0Ptr(PTMTIMER pTimer);
    235 VMMDECL(PTMTIMERRC)     TMTimerRCPtr(PTMTIMER pTimer);
    236 VMMDECL(int)            TMTimerLock(PTMTIMER pTimer, int rcBusy);
    237 VMMDECL(void)           TMTimerUnlock(PTMTIMER pTimer);
    238 VMMDECL(bool)           TMTimerIsLockOwner(PTMTIMER pTimer);
    239 VMMDECL(int)            TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire);
    240 VMMDECL(int)            TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now);
    241 VMMDECL(int)            TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHz);
    242 VMMDECL(uint64_t)       TMTimerGet(PTMTIMER pTimer);
    243 VMMDECL(int)            TMTimerStop(PTMTIMER pTimer);
    244 VMMDECL(bool)           TMTimerIsActive(PTMTIMER pTimer);
    245 
    246 VMMDECL(int)            TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext);
    247 VMMDECL(int)            TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext);
    248 VMMDECL(int)            TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext);
    249 VMMDECL(uint64_t)       TMTimerGetNano(PTMTIMER pTimer);
    250 VMMDECL(uint64_t)       TMTimerGetMicro(PTMTIMER pTimer);
    251 VMMDECL(uint64_t)       TMTimerGetMilli(PTMTIMER pTimer);
    252 VMMDECL(uint64_t)       TMTimerGetFreq(PTMTIMER pTimer);
    253 VMMDECL(uint64_t)       TMTimerGetExpire(PTMTIMER pTimer);
    254 VMMDECL(uint64_t)       TMTimerToNano(PTMTIMER pTimer, uint64_t cTicks);
    255 VMMDECL(uint64_t)       TMTimerToMicro(PTMTIMER pTimer, uint64_t cTicks);
    256 VMMDECL(uint64_t)       TMTimerToMilli(PTMTIMER pTimer, uint64_t cTicks);
    257 VMMDECL(uint64_t)       TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs);
    258 VMMDECL(uint64_t)       TMTimerFromMicro(PTMTIMER pTimer, uint64_t cMicroSecs);
    259 VMMDECL(uint64_t)       TMTimerFromMilli(PVMCC pVM, PTMTIMER pTimer, uint64_t cMilliSecs);
     233VMMDECL(int)            TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy);
     234VMMDECL(void)           TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer);
     235VMMDECL(bool)           TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer);
     236VMMDECL(int)            TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire);
     237VMMDECL(int)            TMTimerSetRelative(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now);
     238VMMDECL(int)            TMTimerSetFrequencyHint(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t uHz);
     239VMMDECL(uint64_t)       TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer);
     240VMMDECL(int)            TMTimerStop(PVMCC pVM, TMTIMERHANDLE hTimer);
     241VMMDECL(bool)           TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer);
     242
     243VMMDECL(int)            TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext);
     244VMMDECL(int)            TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext);
     245VMMDECL(int)            TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext);
     246VMMDECL(uint64_t)       TMTimerGetNano(PVMCC pVM, TMTIMERHANDLE hTimer);
     247VMMDECL(uint64_t)       TMTimerGetMicro(PVMCC pVM, TMTIMERHANDLE hTimer);
     248VMMDECL(uint64_t)       TMTimerGetMilli(PVMCC pVM, TMTIMERHANDLE hTimer);
     249VMMDECL(uint64_t)       TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer);
     250VMMDECL(uint64_t)       TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer);
     251VMMDECL(uint64_t)       TMTimerToNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks);
     252VMMDECL(uint64_t)       TMTimerToMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks);
     253VMMDECL(uint64_t)       TMTimerToMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks);
     254VMMDECL(uint64_t)       TMTimerFromNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanoSecs);
     255VMMDECL(uint64_t)       TMTimerFromMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicroSecs);
     256VMMDECL(uint64_t)       TMTimerFromMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMilliSecs);
    260257
    261258VMMDECL(bool)           TMTimerPollBool(PVMCC pVM, PVMCPUCC pVCpu);
    … …  
    275272VMM_INT_DECL(void)      TMR3Reset(PVM pVM);
    276273VMM_INT_DECL(int)       TMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue);
    277 VMM_INT_DECL(int)       TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer);
    278 VMM_INT_DECL(int)       TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer);
    279 VMM_INT_DECL(int)       TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer);
     274VMM_INT_DECL(int)       TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback,
     275                                              void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
     276VMM_INT_DECL(int)       TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback,
     277                                           void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
     278VMM_INT_DECL(int)       TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback,
     279                                              void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer);
    280280VMMR3DECL(int)          TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, uint32_t fFlags,
    281                                         const char *pszDesc, PPTMTIMERR3 ppTimer);
    282 VMMR3DECL(int)          TMR3TimerDestroy(PTMTIMER pTimer);
     281                                        const char *pszDesc, PTMTIMERHANDLE phTimer);
     282VMMR3DECL(int)          TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer);
    283283VMM_INT_DECL(int)       TMR3TimerDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
    284284VMM_INT_DECL(int)       TMR3TimerDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns);
    285285VMM_INT_DECL(int)       TMR3TimerDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
    286 VMMR3DECL(int)          TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM);
    287 VMMR3DECL(int)          TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM);
     286VMMR3DECL(int)          TMR3TimerSave(PVMCC pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM);
     287VMMR3DECL(int)          TMR3TimerLoad(PVMCC pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM);
    288288VMMR3DECL(int)          TMR3TimerSkip(PSSMHANDLE pSSM, bool *pfActive);
    289 VMMR3DECL(int)          TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect);
     289VMMR3DECL(int)          TMR3TimerSetCritSect(PVMCC pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect);
    290290VMMR3DECL(void)         TMR3TimerQueuesDo(PVM pVM);
    291291VMMR3_INT_DECL(void)    TMR3VirtualSyncFF(PVM pVM, PVMCPU pVCpu);

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r87760 r87766  
    513513static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    514514{
    515     RT_NOREF(pDevIns);
     515    RT_NOREF(pDevIns, pTimer);
    516516    PVMMDEV pThis = (PVMMDEV)pvUser;
    517517    if (pThis->fHeartbeatActive)
    518518    {
    519         uint64_t cNsElapsed = TMTimerGetNano(pTimer) - pThis->nsLastHeartbeatTS;
     519        uint64_t cNsElapsed = PDMDevHlpTimerGetNano(pDevIns, pThis->hFlatlinedTimer) - pThis->nsLastHeartbeatTS;
    520520        if (   !pThis->fFlatlined
    521521            && cNsElapsed >= pThis->cNsHeartbeatInterval)

  • trunk/src/VBox/VMM/VMMAll/CPUMAllRegs.cpp

    r87361 r87766  
    23352335    VMCPU_ASSERT_EMT(pVCpu);
    23362336    uint64_t const cTicksToNext = uTimer << cShift;
    2337     return TMTimerSetRelative(pVCpu->cpum.s.CTX_SUFF(pNestedVmxPreemptTimer), cTicksToNext, pu64EntryTick);
     2337    return TMTimerSetRelative(pVCpu->CTX_SUFF(pVM), pVCpu->cpum.s.hNestedVmxPreemptTimer, cTicksToNext, pu64EntryTick);
    23382338}
    23392339
    … …  
    23532353    /*
    23542354     * CPUM gets initialized before TM, so we defer creation of timers till CPUMR3InitCompleted().
    2355      * However, we still get called during CPUMR3Init() and hence we need to check if we  have
     2355     * However, we still get called during CPUMR3Init() and hence we need to check if we have
    23562356     * a valid timer object before trying to stop it.
    23572357     */
    2358     PTMTIMER pTimer = pVCpu->cpum.s.CTX_SUFF(pNestedVmxPreemptTimer);
    2359     if (!pTimer)
    2360         return VERR_NOT_FOUND;
    2361 
    2362     int rc = TMTimerLock(pTimer, VERR_IGNORED);
    2363     if (rc == VINF_SUCCESS)
    2364     {
    2365         if (TMTimerIsActive(pTimer))
    2366             TMTimerStop(pTimer);
    2367         TMTimerUnlock(pTimer);
    2368     }
     2358    int rc;
     2359    TMTIMERHANDLE hTimer = pVCpu->cpum.s.hNestedVmxPreemptTimer;
     2360    if (hTimer != NIL_TMTIMERHANDLE)
     2361    {
     2362        PVMCC pVM = pVCpu->CTX_SUFF(pVM);
     2363        rc = TMTimerLock(pVM, hTimer, VERR_IGNORED);
     2364        if (rc == VINF_SUCCESS)
     2365        {
     2366            if (TMTimerIsActive(pVM, hTimer))
     2367                TMTimerStop(pVM, hTimer);
     2368            TMTimerUnlock(pVM, hTimer);
     2369        }
     2370    }
     2371    else
     2372        rc = VERR_NOT_FOUND;
    23692373    return rc;
    23702374}

  • trunk/src/VBox/VMM/VMMAll/GIMAllHv.cpp

    r82968 r87766  
    509509VMM_INT_DECL(void) gimHvStartStimer(PVMCPUCC pVCpu, PCGIMHVSTIMER pHvStimer)
    510510{
    511     PTMTIMER pTimer = pHvStimer->CTX_SUFF(pTimer);
    512     Assert(TMTimerIsLockOwner(pTimer));
     511    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
     512    TMTIMERHANDLE hTimer = pHvStimer->hTimer;
     513    Assert(TMTimerIsLockOwner(pVM, hTimer));
    513514
    514515    uint64_t const uTimerCount = pHvStimer->uStimerCountMsr;
    … …  
    520521        if (MSR_GIM_HV_STIMER_IS_PERIODIC(pHvStimer->uStimerConfigMsr))
    521522        {
    522             TMTimerSetNano(pTimer, uTimerCountNS);
     523            TMTimerSetNano(pVM, hTimer, uTimerCountNS);
    523524            LogFlow(("GIM%u: HyperV: Started relative periodic STIMER%u with uTimerCountNS=%RU64\n", pVCpu->idCpu,
    524525                     pHvStimer->idxStimer, uTimerCountNS));
    … …  
    532533            {
    533534                uint64_t const uRelativeNS = uTimerCountNS - uCurRefTimeNS;
    534                 TMTimerSetNano(pTimer, uRelativeNS);
     535                TMTimerSetNano(pVM, hTimer, uRelativeNS);
    535536                LogFlow(("GIM%u: HyperV: Started one-shot relative STIMER%u with uRelativeNS=%RU64\n", pVCpu->idCpu,
    536537                         pHvStimer->idxStimer, uRelativeNS));
    … …  
    554555{
    555556    VMCPU_ASSERT_EMT_OR_NOT_RUNNING(pVCpu);
    556     RT_NOREF(pVCpu);
    557 
    558     PTMTIMER pTimer = pHvStimer->CTX_SUFF(pTimer);
    559     Assert(TMTimerIsLockOwner(pTimer));
    560     RT_NOREF(pTimer);
    561 
    562     if (TMTimerIsActive(pHvStimer->CTX_SUFF(pTimer)))
    563         TMTimerStop(pHvStimer->CTX_SUFF(pTimer));
     557    PVMCC pVM = pVCpu->CTX_SUFF(pVM);
     558
     559    TMTIMERHANDLE hTimer = pHvStimer->hTimer;
     560    Assert(TMTimerIsLockOwner(pVM, hTimer));
     561
     562    if (TMTimerIsActive(pVM, hTimer))
     563        TMTimerStop(pVM, hTimer);
    564564}
    565565
    … …  
    757757{
    758758    NOREF(pRange);
    759     PVM    pVM = pVCpu->CTX_SUFF(pVM);
     759    PVMCC  pVM = pVCpu->CTX_SUFF(pVM);
    760760    PGIMHV pHv = &pVM->gim.s.u.Hv;
    761761
    … …  
    11531153                Assert(idxStimer < RT_ELEMENTS(pHvCpu->aStimers));
    11541154                PGIMHVSTIMER pHvStimer = &pHvCpu->aStimers[idxStimer];
    1155                 PTMTIMER     pTimer    = pHvStimer->CTX_SUFF(pTimer);
    11561155
    11571156                /* Lock to prevent concurrent access from the timer callback. */
    1158                 int rc = TMTimerLock(pTimer, VERR_IGNORED);
     1157                int rc = TMTimerLock(pVM, pHvStimer->hTimer, VERR_IGNORED);
    11591158                if (rc == VINF_SUCCESS)
    11601159                {
    … …  
    11761175                        if (!MSR_GIM_HV_STIMER_IS_AUTO_ENABLED(uRawValue))
    11771176                        {
    1178                             if (!TMTimerIsActive(pHvStimer->CTX_SUFF(pTimer)))
     1177                            if (!TMTimerIsActive(pVM, pHvStimer->hTimer))
    11791178                            {
    11801179                                gimHvStartStimer(pVCpu, pHvStimer);
    … …  
    11971196                    }
    11981197
    1199                     TMTimerUnlock(pTimer);
     1198                    TMTimerUnlock(pVM, pHvStimer->hTimer);
    12001199                }
    12011200                return rc;
    … …  
    12391238            if (MSR_GIM_HV_STIMER_IS_AUTO_ENABLED(pHvStimer->uStimerConfigMsr))
    12401239            {
    1241                 PTMTIMER pTimer = pHvStimer->CTX_SUFF(pTimer);
    1242                 int rc = TMTimerLock(pTimer, rcBusy);
     1240                int rc = TMTimerLock(pVM, pHvStimer->hTimer, rcBusy);
    12431241                if (rc == VINF_SUCCESS)
    12441242                {
    12451243                    pHvStimer->uStimerCountMsr = uRawValue;
    12461244                    gimHvStartStimer(pVCpu, pHvStimer);
    1247                     TMTimerUnlock(pTimer);
     1245                    TMTimerUnlock(pVM, pHvStimer->hTimer);
    12481246                    Log(("GIM%u: HyperV: Set STIMER_COUNT%u=%RU64 %RU64 msec, auto-started timer\n", pVCpu->idCpu, idxStimer,
    12491247                         uRawValue, (uRawValue * 100) / RT_NS_1MS_64));

  • trunk/src/VBox/VMM/VMMAll/PDMAllQueue.cpp

    r82968 r87766  
    111111#endif
    112112
    113     if (!pQueue->pTimer)
     113    if (pQueue->hTimer == NIL_TMTIMERHANDLE)
    114114        pdmQueueSetFF(pQueue);
    115115    STAM_REL_COUNTER_INC(&pQueue->StatInsert);

  • trunk/src/VBox/VMM/VMMAll/TMAll.cpp

    r87764 r87766  
    11021102
    11031103/**
    1104  * Gets the host context ring-3 pointer of the timer.
    1105  *
    1106  * @returns HC R3 pointer.
    1107  * @param   pTimer      Timer handle as returned by one of the create functions.
    1108  */
    1109 VMMDECL(PTMTIMERR3) TMTimerR3Ptr(PTMTIMER pTimer)
    1110 {
    1111 #ifdef IN_RING0
    1112     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1113 #endif
    1114     return (PTMTIMERR3)MMHyperCCToR3(pTimer->CTX_SUFF(pVM), pTimer);
    1115 }
    1116 
    1117 
    1118 /**
    1119  * Gets the host context ring-0 pointer of the timer.
    1120  *
    1121  * @returns HC R0 pointer.
    1122  * @param   pTimer      Timer handle as returned by one of the create functions.
    1123  */
    1124 VMMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer)
    1125 {
    1126 #ifdef IN_RING0
    1127     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1128 #endif
    1129     return (PTMTIMERR0)MMHyperCCToR0(pTimer->CTX_SUFF(pVM), pTimer);
    1130 }
    1131 
    1132 
    1133 /**
    1134  * Gets the RC pointer of the timer.
    1135  *
    1136  * @returns RC pointer.
    1137  * @param   pTimer      Timer handle as returned by one of the create functions.
    1138  */
    1139 VMMDECL(PTMTIMERRC) TMTimerRCPtr(PTMTIMER pTimer)
    1140 {
    1141 #ifdef IN_RING0
    1142     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1143 #endif
    1144     return (PTMTIMERRC)MMHyperCCToRC(pTimer->CTX_SUFF(pVM), pTimer);
    1145 }
    1146 
    1147 
    1148 /**
    11491104 * Locks the timer clock.
    11501105 *
    11511106 * @returns VINF_SUCCESS on success, @a rcBusy if busy, and VERR_NOT_SUPPORTED
    11521107 *          if the clock does not have a lock.
    1153  * @param   pTimer              The timer which clock lock we wish to take.
    1154  * @param   rcBusy              What to return in ring-0 and raw-mode context
    1155  *                              if the lock is busy.  Pass VINF_SUCCESS to
    1156  *                              acquired the critical section thru a ring-3
    1157                                call if necessary.
     1108 * @param   pVM         The cross context VM structure.
     1109 * @param   hTimer      Timer handle as returned by one of the create functions.
     1110 * @param   rcBusy      What to return in ring-0 and raw-mode context if the
     1111 *                      lock is busy.  Pass VINF_SUCCESS to acquired the
     1112 *                      critical section thru a ring-3 call if necessary.
    11581113 *
    11591114 * @remarks Currently only supported on timers using the virtual sync clock.
    11601115 */
    1161 VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy)
    1162 {
    1163 #ifdef IN_RING0
    1164     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1165 #endif
     1116VMMDECL(int) TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy)
     1117{
     1118    PTMTIMER pTimer;
     1119    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    11661120    AssertPtr(pTimer);
    11671121    AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED);
    1168     return PDMCritSectEnter(&pTimer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock, rcBusy);
     1122    return PDMCritSectEnter(&pVM->tm.s.VirtualSyncLock, rcBusy);
    11691123}
    11701124
    … …  
    11731127 * Unlocks a timer clock locked by TMTimerLock.
    11741128 *
    1175  * @param   pTimer              The timer which clock to unlock.
    1176  */
    1177 VMMDECL(void) TMTimerUnlock(PTMTIMER pTimer)
    1178 {
    1179 #ifdef IN_RING0
    1180     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1181 #endif
    1182     AssertPtr(pTimer);
     1129 * @param   pVM         The cross context VM structure.
     1130 * @param   hTimer      Timer handle as returned by one of the create functions.
     1131 */
     1132VMMDECL(void) TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer)
     1133{
     1134    PTMTIMER pTimer;
     1135    TMTIMER_HANDLE_TO_PTR_RETURN_VOID(pVM, hTimer, pTimer);
    11831136    AssertReturnVoid(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC);
    1184     PDMCritSectLeave(&pTimer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock);
     1137    PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock);
    11851138}
    11861139
    … …  
    11901143 *
    11911144 * @returns @c true if its the owner, @c false if not.
    1192  * @param   pTimer              The timer handle.
    1193  */
    1194 VMMDECL(bool) TMTimerIsLockOwner(PTMTIMER pTimer)
    1195 {
    1196 #ifdef IN_RING0
    1197     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1198 #endif
     1145 * @param   pVM         The cross context VM structure.
     1146 * @param   hTimer      Timer handle as returned by one of the create functions.
     1147 */
     1148VMMDECL(bool) TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer)
     1149{
     1150    PTMTIMER pTimer;
     1151    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer);
    11991152    AssertPtr(pTimer);
    12001153    AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, false);
    1201     return PDMCritSectIsOwner(&pTimer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock);
     1154    return PDMCritSectIsOwner(&pVM->tm.s.VirtualSyncLock);
    12021155}
    12031156
    … …  
    13191272 *
    13201273 * @returns VBox status code.
    1321  * @param   pTimer          Timer handle as returned by one of the create functions.
    1322  * @param   u64Expire       New expire time.
    1323  */
    1324 VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire)
    1325 {
    1326 #ifdef IN_RING0
    1327     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1328 #endif
    1329     PVMCC pVM = pTimer->CTX_SUFF(pVM);
     1274 * @param   pVM         The cross context VM structure.
     1275 * @param   hTimer      Timer handle as returned by one of the create functions.
     1276 * @param   u64Expire   New expire time.
     1277 */
     1278VMMDECL(int) TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire)
     1279{
     1280    PTMTIMER pTimer;
     1281    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    13301282    STAM_COUNTER_INC(&pTimer->StatSetAbsolute);
    13311283
    … …  
    16271579 *
    16281580 * @returns VBox status code.
    1629  * @param   pTimer          Timer handle as returned by one of the create functions.
     1581 * @param   pVM             The cross context VM structure.
     1582 * @param   hTimer          Timer handle as returned by one of the create functions.
    16301583 * @param   cTicksToNext    Clock ticks until the next time expiration.
    16311584 * @param   pu64Now         Where to return the current time stamp used.
    16321585 *                          Optional.
    16331586 */
    1634 VMMDECL(int) TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    1635 {
    1636 #ifdef IN_RING0
    1637     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1638 #endif
    1639     PVMCC pVM = pTimer->CTX_SUFF(pVM);
     1587static int tmTimerSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
     1588{
    16401589    STAM_COUNTER_INC(&pTimer->StatSetRelative);
    16411590
    … …  
    18491798
    18501799/**
     1800 * Arm a timer with a expire time relative to the current time.
     1801 *
     1802 * @returns VBox status code.
     1803 * @param   pVM             The cross context VM structure.
     1804 * @param   hTimer          Timer handle as returned by one of the create functions.
     1805 * @param   cTicksToNext    Clock ticks until the next time expiration.
     1806 * @param   pu64Now         Where to return the current time stamp used.
     1807 *                          Optional.
     1808 */
     1809VMMDECL(int) TMTimerSetRelative(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
     1810{
     1811    PTMTIMER pTimer;
     1812    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     1813    return tmTimerSetRelative(pVM, pTimer, cTicksToNext, pu64Now);
     1814}
     1815
     1816
     1817/**
    18511818 * Drops a hint about the frequency of the timer.
    18521819 *
    … …  
    18551822 *
    18561823 * @returns VBox status code.
    1857  * @param   pTimer          Timer handle as returned by one of the create
    1858  *                         functions.
    1859  * @param   uHzHint         The frequency hint.  Pass 0 to clear the hint.
     1824 * @param   pVM         The cross context VM structure.
     1825 * @param   hTimer      Timer handle as returned by one of the create functions.
     1826 * @param   uHzHint     The frequency hint.  Pass 0 to clear the hint.
    18601827 *
    18611828 * @remarks We're using an integer hertz value here since anything above 1 HZ
    … …  
    18631830 *          range where it makes sense is >= 100 HZ.
    18641831 */
    1865 VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHzHint)
    1866 {
    1867 #ifdef IN_RING0
    1868     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1869 #endif
     1832VMMDECL(int) TMTimerSetFrequencyHint(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t uHzHint)
     1833{
     1834    PTMTIMER pTimer;
     1835    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    18701836    TMTIMER_ASSERT_CRITSECT(pTimer);
    18711837
    … …  
    18731839    pTimer->uHzHint = uHzHint;
    18741840
    1875     PVM pVM = pTimer->CTX_SUFF(pVM);
    18761841    uint32_t const uMaxHzHint = pVM->tm.s.uMaxHzHint;
    18771842    if (   uHzHint    >  uMaxHzHint
    … …  
    19591924 *
    19601925 * @returns VBox status code.
    1961  * @param   pTimer          Timer handle as returned by one of the create functions.
    1962  */
    1963 VMMDECL(int) TMTimerStop(PTMTIMER pTimer)
    1964 {
    1965 #ifdef IN_RING0
    1966     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    1967 #endif
    1968     PVMCC pVM = pTimer->CTX_SUFF(pVM);
     1926 * @param   pVM         The cross context VM structure.
     1927 * @param   hTimer      Timer handle as returned by one of the create functions.
     1928 */
     1929VMMDECL(int) TMTimerStop(PVMCC pVM, TMTIMERHANDLE hTimer)
     1930{
     1931    PTMTIMER pTimer;
     1932    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    19691933    STAM_COUNTER_INC(&pTimer->StatStop);
    19701934
    … …  
    20702034 *
    20712035 * @returns Current clock time.
    2072  * @param   pTimer          Timer handle as returned by one of the create functions.
    2073  */
    2074 VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer)
    2075 {
    2076 #ifdef IN_RING0
    2077     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2078 #endif
    2079     PVMCC pVM = pTimer->CTX_SUFF(pVM);
     2036 * @param   pVM         The cross context VM structure.
     2037 * @param   hTimer      Timer handle as returned by one of the create functions.
     2038 */
     2039VMMDECL(uint64_t) TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer)
     2040{
     2041    PTMTIMER pTimer;
     2042    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer);
    20802043    STAM_COUNTER_INC(&pTimer->StatGet);
    20812044
    … …  
    21062069 *
    21072070 * @returns Clock frequency (as Hz of course).
    2108  * @param   pTimer          Timer handle as returned by one of the create functions.
    2109  */
    2110 VMMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer)
    2111 {
    2112 #ifdef IN_RING0
    2113     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2114 #endif
     2071 * @param   pVM         The cross context VM structure.
     2072 * @param   hTimer      Timer handle as returned by one of the create functions.
     2073 */
     2074VMMDECL(uint64_t) TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer)
     2075{
     2076    PTMTIMER pTimer;
     2077    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    21152078    switch (pTimer->enmClock)
    21162079    {
    … …  
    21342097 *
    21352098 * @returns Expire time of the timer.
    2136  * @param   pTimer          Timer handle as returned by one of the create functions.
    2137  */
    2138 VMMDECL(uint64_t) TMTimerGetExpire(PTMTIMER pTimer)
    2139 {
    2140 #ifdef IN_RING0
    2141     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2142 #endif
     2099 * @param   pVM         The cross context VM structure.
     2100 * @param   hTimer      Timer handle as returned by one of the create functions.
     2101 */
     2102VMMDECL(uint64_t) TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer)
     2103{
     2104    PTMTIMER pTimer;
     2105    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer);
    21432106    TMTIMER_ASSERT_CRITSECT(pTimer);
    21442107    int cRetries = 1000;
    … …  
    21552118                Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    21562119                      pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
    2157                 return ~(uint64_t)0;
     2120                return UINT64_MAX;
    21582121
    21592122            case TMTIMERSTATE_ACTIVE:
    … …  
    21802143                Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    21812144                      pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
    2182                 return ~(uint64_t)0;
     2145                return UINT64_MAX;
    21832146            default:
    21842147                AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc)));
    2185                 return ~(uint64_t)0;
     2148                return UINT64_MAX;
    21862149        }
    21872150    } while (cRetries-- > 0);
    … …  
    21902153    Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n",
    21912154          pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc)));
    2192     return ~(uint64_t)0;
     2155    return UINT64_MAX;
    21932156}
    21942157
    … …  
    21992162 * @returns True if active.
    22002163 * @returns False if not active.
    2201  * @param   pTimer          Timer handle as returned by one of the create functions.
    2202  */
    2203 VMMDECL(bool) TMTimerIsActive(PTMTIMER pTimer)
    2204 {
    2205 #ifdef IN_RING0
    2206     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2207 #endif
     2164 * @param   pVM         The cross context VM structure.
     2165 * @param   hTimer      Timer handle as returned by one of the create functions.
     2166 */
     2167VMMDECL(bool) TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer)
     2168{
     2169    PTMTIMER pTimer;
     2170    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer);
    22082171    TMTIMERSTATE enmState = pTimer->enmState;
    22092172    switch (enmState)
    … …  
    22502213 *
    22512214 * @returns VBox status code.
    2252  * @param   pTimer          Timer handle as returned by one of the create functions.
     2215 * @param   pVM             The cross context VM structure.
     2216 * @param   hTimer          Timer handle as returned by one of the create functions.
    22532217 * @param   cMilliesToNext  Number of milliseconds to the next tick.
    22542218 */
    2255 VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext)
    2256 {
     2219VMMDECL(int) TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext)
     2220{
     2221    PTMTIMER pTimer;
     2222    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    22572223    switch (pTimer->enmClock)
    22582224    {
    22592225        case TMCLOCK_VIRTUAL:
    22602226            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2261             return TMTimerSetRelative(pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
     2227            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
    22622228
    22632229        case TMCLOCK_VIRTUAL_SYNC:
    22642230            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2265             return TMTimerSetRelative(pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
     2231            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
    22662232
    22672233        case TMCLOCK_REAL:
    22682234            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2269             return TMTimerSetRelative(pTimer, cMilliesToNext, NULL);
     2235            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext, NULL);
    22702236
    22712237        default:
    … …  
    22802246 *
    22812247 * @returns VBox status code.
    2282  * @param   pTimer          Timer handle as returned by one of the create functions.
     2248 * @param   pVM             The cross context VM structure.
     2249 * @param   hTimer          Timer handle as returned by one of the create functions.
    22832250 * @param   cMicrosToNext   Number of microseconds to the next tick.
    22842251 */
    2285 VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext)
    2286 {
     2252VMMDECL(int) TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
     2253{
     2254    PTMTIMER pTimer;
     2255    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    22872256    switch (pTimer->enmClock)
    22882257    {
    22892258        case TMCLOCK_VIRTUAL:
    22902259            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2291             return TMTimerSetRelative(pTimer, cMicrosToNext * 1000, NULL);
     2260            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL);
    22922261
    22932262        case TMCLOCK_VIRTUAL_SYNC:
    22942263            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2295             return TMTimerSetRelative(pTimer, cMicrosToNext * 1000, NULL);
     2264            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL);
    22962265
    22972266        case TMCLOCK_REAL:
    22982267            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2299             return TMTimerSetRelative(pTimer, cMicrosToNext / 1000, NULL);
     2268            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext / 1000, NULL);
    23002269
    23012270        default:
    … …  
    23102279 *
    23112280 * @returns VBox status code.
    2312  * @param   pTimer          Timer handle as returned by one of the create functions.
     2281 * @param   pVM             The cross context VM structure.
     2282 * @param   hTimer          Timer handle as returned by one of the create functions.
    23132283 * @param   cNanosToNext    Number of nanoseconds to the next tick.
    23142284 */
    2315 VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext)
    2316 {
     2285VMMDECL(int) TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
     2286{
     2287    PTMTIMER pTimer;
     2288    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    23172289    switch (pTimer->enmClock)
    23182290    {
    23192291        case TMCLOCK_VIRTUAL:
    23202292            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2321             return TMTimerSetRelative(pTimer, cNanosToNext, NULL);
     2293            return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL);
    23222294
    23232295        case TMCLOCK_VIRTUAL_SYNC:
    23242296            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2325             return TMTimerSetRelative(pTimer, cNanosToNext, NULL);
     2297            return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL);
    23262298
    23272299        case TMCLOCK_REAL:
    23282300            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2329             return TMTimerSetRelative(pTimer, cNanosToNext / 1000000, NULL);
     2301            return tmTimerSetRelative(pVM, pTimer, cNanosToNext / 1000000, NULL);
    23302302
    23312303        default:
    … …  
    23402312 *
    23412313 * @returns The timer clock as nanoseconds.
    2342  * @param   pTimer          Timer handle as returned by one of the create functions.
    2343  */
    2344 VMMDECL(uint64_t) TMTimerGetNano(PTMTIMER pTimer)
    2345 {
    2346     return TMTimerToNano(pTimer, TMTimerGet(pTimer));
     2314 * @param   pVM         The cross context VM structure.
     2315 * @param   hTimer      Timer handle as returned by one of the create functions.
     2316 */
     2317VMMDECL(uint64_t) TMTimerGetNano(PVMCC pVM, TMTIMERHANDLE hTimer)
     2318{
     2319    return TMTimerToNano(pVM, hTimer, TMTimerGet(pVM, hTimer));
    23472320}
    23482321
    … …  
    23522325 *
    23532326 * @returns The timer clock as microseconds.
    2354  * @param   pTimer          Timer handle as returned by one of the create functions.
    2355  */
    2356 VMMDECL(uint64_t) TMTimerGetMicro(PTMTIMER pTimer)
    2357 {
    2358     return TMTimerToMicro(pTimer, TMTimerGet(pTimer));
     2327 * @param   pVM         The cross context VM structure.
     2328 * @param   hTimer      Timer handle as returned by one of the create functions.
     2329 */
     2330VMMDECL(uint64_t) TMTimerGetMicro(PVMCC pVM, TMTIMERHANDLE hTimer)
     2331{
     2332    return TMTimerToMicro(pVM, hTimer, TMTimerGet(pVM, hTimer));
    23592333}
    23602334
    … …  
    23642338 *
    23652339 * @returns The timer clock as milliseconds.
    2366  * @param   pTimer          Timer handle as returned by one of the create functions.
    2367  */
    2368 VMMDECL(uint64_t) TMTimerGetMilli(PTMTIMER pTimer)
    2369 {
    2370     return TMTimerToMilli(pTimer, TMTimerGet(pTimer));
     2340 * @param   pVM         The cross context VM structure.
     2341 * @param   hTimer      Timer handle as returned by one of the create functions.
     2342 */
     2343VMMDECL(uint64_t) TMTimerGetMilli(PVMCC pVM, TMTIMERHANDLE hTimer)
     2344{
     2345    return TMTimerToMilli(pVM, hTimer, TMTimerGet(pVM, hTimer));
    23712346}
    23722347
    … …  
    23762351 *
    23772352 * @returns nanoseconds.
    2378  * @param   pTimer          Timer handle as returned by one of the create functions.
    2379  * @param   u64Ticks        The clock ticks.
     2353 * @param   pVM         The cross context VM structure.
     2354 * @param   hTimer      Timer handle as returned by one of the create functions.
     2355 * @param   cTicks      The clock ticks.
    23802356 * @remark  There could be rounding errors here. We just do a simple integer divide
    23812357 *          without any adjustments.
    23822358 */
    2383 VMMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks)
    2384 {
    2385 #ifdef IN_RING0
    2386     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2387 #endif
     2359VMMDECL(uint64_t) TMTimerToNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
     2360{
     2361    PTMTIMER pTimer;
     2362    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    23882363    switch (pTimer->enmClock)
    23892364    {
    … …  
    23912366        case TMCLOCK_VIRTUAL_SYNC:
    23922367            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2393             return u64Ticks;
     2368            return cTicks;
    23942369
    23952370        case TMCLOCK_REAL:
    23962371            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2397             return u64Ticks * 1000000;
     2372            return cTicks * 1000000;
    23982373
    23992374        default:
    … …  
    24082383 *
    24092384 * @returns microseconds.
    2410  * @param   pTimer          Timer handle as returned by one of the create functions.
    2411  * @param   u64Ticks        The clock ticks.
     2385 * @param   pVM         The cross context VM structure.
     2386 * @param   hTimer      Timer handle as returned by one of the create functions.
     2387 * @param   cTicks      The clock ticks.
    24122388 * @remark  There could be rounding errors here. We just do a simple integer divide
    24132389 *          without any adjustments.
    24142390 */
    2415 VMMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks)
    2416 {
    2417 #ifdef IN_RING0
    2418     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2419 #endif
     2391VMMDECL(uint64_t) TMTimerToMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
     2392{
     2393    PTMTIMER pTimer;
     2394    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    24202395    switch (pTimer->enmClock)
    24212396    {
    … …  
    24232398        case TMCLOCK_VIRTUAL_SYNC:
    24242399            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2425             return u64Ticks / 1000;
     2400            return cTicks / 1000;
    24262401
    24272402        case TMCLOCK_REAL:
    24282403            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2429             return u64Ticks * 1000;
     2404            return cTicks * 1000;
    24302405
    24312406        default:
    … …  
    24402415 *
    24412416 * @returns milliseconds.
    2442  * @param   pTimer          Timer handle as returned by one of the create functions.
    2443  * @param   u64Ticks        The clock ticks.
     2417 * @param   pVM         The cross context VM structure.
     2418 * @param   hTimer      Timer handle as returned by one of the create functions.
     2419 * @param   cTicks      The clock ticks.
    24442420 * @remark  There could be rounding errors here. We just do a simple integer divide
    24452421 *          without any adjustments.
    24462422 */
    2447 VMMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks)
    2448 {
    2449 #ifdef IN_RING0
    2450     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2451 #endif
     2423VMMDECL(uint64_t) TMTimerToMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
     2424{
     2425    PTMTIMER pTimer;
     2426    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    24522427    switch (pTimer->enmClock)
    24532428    {
    … …  
    24552430        case TMCLOCK_VIRTUAL_SYNC:
    24562431            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2457             return u64Ticks / 1000000;
     2432            return cTicks / 1000000;
    24582433
    24592434        case TMCLOCK_REAL:
    24602435            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2461             return u64Ticks;
     2436            return cTicks;
    24622437
    24632438        default:
    … …  
    24722447 *
    24732448 * @returns timer clock ticks.
    2474  * @param   pTimer          Timer handle as returned by one of the create functions.
    2475  * @param   cNanoSecs       The nanosecond value ticks to convert.
     2449 * @param   pVM         The cross context VM structure.
     2450 * @param   hTimer      Timer handle as returned by one of the create functions.
     2451 * @param   cNanoSecs   The nanosecond value ticks to convert.
    24762452 * @remark  There could be rounding and overflow errors here.
    24772453 */
    2478 VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs)
    2479 {
    2480 #ifdef IN_RING0
    2481     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2482 #endif
     2454VMMDECL(uint64_t) TMTimerFromNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
     2455{
     2456    PTMTIMER pTimer;
     2457    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    24832458    switch (pTimer->enmClock)
    24842459    {
    … …  
    25032478 *
    25042479 * @returns timer clock ticks.
    2505  * @param   pTimer          Timer handle as returned by one of the create functions.
    2506  * @param   cMicroSecs      The microsecond value ticks to convert.
     2480 * @param   pVM         The cross context VM structure.
     2481 * @param   hTimer      Timer handle as returned by one of the create functions.
     2482 * @param   cMicroSecs  The microsecond value ticks to convert.
    25072483 * @remark  There could be rounding and overflow errors here.
    25082484 */
    2509 VMMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t cMicroSecs)
    2510 {
    2511 #ifdef IN_RING0
    2512     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2513 #endif
     2485VMMDECL(uint64_t) TMTimerFromMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
     2486{
     2487    PTMTIMER pTimer;
     2488    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    25142489    switch (pTimer->enmClock)
    25152490    {
    … …  
    25342509 *
    25352510 * @returns timer clock ticks.
    2536  * @param   pVM             The cross context VM structure.
    2537  * @param   pTimer          Timer handle as returned by one of the create functions.
    2538  * @param   cMilliSecs      The millisecond value ticks to convert.
     2511 * @param   pVM         The cross context VM structure.
     2512 * @param   hTimer      Timer handle as returned by one of the create functions.
     2513 * @param   cMilliSecs  The millisecond value ticks to convert.
    25392514 * @remark  There could be rounding and overflow errors here.
    25402515 */
    2541 VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, PTMTIMER pTimer, uint64_t cMilliSecs)
    2542 {
    2543     RT_NOREF(pVM);
    2544     Assert(pVM == pTimer->CTX_SUFF(pVM));
    2545 #ifdef IN_RING0
    2546     Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);
    2547 #endif
     2516VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
     2517{
     2518    PTMTIMER pTimer;
     2519    TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    25482520    switch (pTimer->enmClock)
    25492521    {

  • trunk/src/VBox/VMM/VMMR0/PDMR0DevHlp.cpp

    r87764 r87766  
    415415
    416416
    417 /** Converts a timer handle to a pointer (used to be exposed, will be
    418  *  rewritten later). */
    419 DECLINLINE(PTMTIMERR0) pdmR0DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    420 {
    421     PDMDEV_ASSERT_DEVINS(pDevIns);
    422     return (PTMTIMERR0)MMHyperR3ToCC(pDevIns->Internal.s.pGVM, hTimer);
    423 }
    424 
    425417/** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMicro} */
    426418static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
    427419{
    428     return TMTimerFromMicro(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMicroSecs);
     420    PDMDEV_ASSERT_DEVINS(pDevIns);
     421    return TMTimerFromMicro(pDevIns->Internal.s.pGVM, hTimer, cMicroSecs);
    429422}
    430423
    … …  
    434427{
    435428    PDMDEV_ASSERT_DEVINS(pDevIns);
    436     return TMTimerFromMilli(pDevIns->Internal.s.pGVM, pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMilliSecs);
     429    return TMTimerFromMilli(pDevIns->Internal.s.pGVM, hTimer, cMilliSecs);
    437430}
    438431
    … …  
    441434static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
    442435{
    443     return TMTimerFromNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cNanoSecs);
     436    PDMDEV_ASSERT_DEVINS(pDevIns);
     437    return TMTimerFromNano(pDevIns->Internal.s.pGVM, hTimer, cNanoSecs);
    444438}
    445439
    … …  
    447441static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    448442{
    449     return TMTimerGet(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     443    PDMDEV_ASSERT_DEVINS(pDevIns);
     444    return TMTimerGet(pDevIns->Internal.s.pGVM, hTimer);
    450445}
    451446
    … …  
    454449static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    455450{
    456     return TMTimerGetFreq(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     451    PDMDEV_ASSERT_DEVINS(pDevIns);
     452    return TMTimerGetFreq(pDevIns->Internal.s.pGVM, hTimer);
    457453}
    458454
    … …  
    461457static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    462458{
    463     return TMTimerGetNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     459    PDMDEV_ASSERT_DEVINS(pDevIns);
     460    return TMTimerGetNano(pDevIns->Internal.s.pGVM, hTimer);
    464461}
    465462
    … …  
    468465static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    469466{
    470     return TMTimerIsActive(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     467    PDMDEV_ASSERT_DEVINS(pDevIns);
     468    return TMTimerIsActive(pDevIns->Internal.s.pGVM, hTimer);
    471469}
    472470
    … …  
    475473static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    476474{
    477     return TMTimerIsLockOwner(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     475    PDMDEV_ASSERT_DEVINS(pDevIns);
     476    return TMTimerIsLockOwner(pDevIns->Internal.s.pGVM, hTimer);
    478477}
    479478
    … …  
    482481static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
    483482{
    484     return TMTimerLock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
     483    PDMDEV_ASSERT_DEVINS(pDevIns);
     484    return TMTimerLock(pDevIns->Internal.s.pGVM, hTimer, rcBusy);
    485485}
    486486
    … …  
    490490                                                              PPDMCRITSECT pCritSect, int rcBusy)
    491491{
    492     VBOXSTRICTRC rc = TMTimerLock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
     492    PDMDEV_ASSERT_DEVINS(pDevIns);
     493    VBOXSTRICTRC rc = TMTimerLock(pDevIns->Internal.s.pGVM, hTimer, rcBusy);
    493494    if (rc == VINF_SUCCESS)
    494495    {
    … …  
    497498            return rc;
    498499        AssertRC(VBOXSTRICTRC_VAL(rc));
    499         TMTimerUnlock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     500        TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer);
    500501    }
    501502    else
    … …  
    508509static DECLCALLBACK(int) pdmR0DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
    509510{
    510     return TMTimerSet(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), uExpire);
     511    PDMDEV_ASSERT_DEVINS(pDevIns);
     512    return TMTimerSet(pDevIns->Internal.s.pGVM, hTimer, uExpire);
    511513}
    512514
    … …  
    515517static DECLCALLBACK(int) pdmR0DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
    516518{
    517     return TMTimerSetFrequencyHint(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), uHz);
     519    PDMDEV_ASSERT_DEVINS(pDevIns);
     520    return TMTimerSetFrequencyHint(pDevIns->Internal.s.pGVM, hTimer, uHz);
    518521}
    519522
    … …  
    522525static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
    523526{
    524     return TMTimerSetMicro(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMicrosToNext);
     527    PDMDEV_ASSERT_DEVINS(pDevIns);
     528    return TMTimerSetMicro(pDevIns->Internal.s.pGVM, hTimer, cMicrosToNext);
    525529}
    526530
    … …  
    529533static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
    530534{
    531     return TMTimerSetMillies(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMilliesToNext);
     535    PDMDEV_ASSERT_DEVINS(pDevIns);
     536    return TMTimerSetMillies(pDevIns->Internal.s.pGVM, hTimer, cMilliesToNext);
    532537}
    533538
    … …  
    536541static DECLCALLBACK(int) pdmR0DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
    537542{
    538     return TMTimerSetNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cNanosToNext);
     543    PDMDEV_ASSERT_DEVINS(pDevIns);
     544    return TMTimerSetNano(pDevIns->Internal.s.pGVM, hTimer, cNanosToNext);
    539545}
    540546
    … …  
    543549static DECLCALLBACK(int) pdmR0DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    544550{
    545     return TMTimerSetRelative(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cTicksToNext, pu64Now);
     551    PDMDEV_ASSERT_DEVINS(pDevIns);
     552    return TMTimerSetRelative(pDevIns->Internal.s.pGVM, hTimer, cTicksToNext, pu64Now);
    546553}
    547554
    … …  
    550557static DECLCALLBACK(int) pdmR0DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    551558{
    552     return TMTimerStop(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     559    PDMDEV_ASSERT_DEVINS(pDevIns);
     560    return TMTimerStop(pDevIns->Internal.s.pGVM, hTimer);
    553561}
    554562
    … …  
    557565static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    558566{
    559     TMTimerUnlock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     567    PDMDEV_ASSERT_DEVINS(pDevIns);
     568    TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer);
    560569}
    561570
    … …  
    564573static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    565574{
    566     TMTimerUnlock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer));
     575    PDMDEV_ASSERT_DEVINS(pDevIns);
     576    TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer);
    567577    int rc = PDMCritSectLeave(pCritSect);
    568578    AssertRC(rc);

  • trunk/src/VBox/VMM/VMMR3/CPUM.cpp

    r87765 r87766  
    20992099
    21002100/**
    2101  * Callback that fires when the nested VMX-preemption timer expired.
    2102  *
    2103  * @param   pVM     The cross context VM structure.
    2104  * @param   pTimer  Pointer to timer.
    2105  * @param   pvUser  Opaque pointer to the virtual-CPU.
    2106  */
    2107 static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
    2108 {
    2109     RT_NOREF2(pVM, pTimer);
    2110     Assert(pvUser);
    2111 
     2101 * @callback_method_impl{FNTMTIMERINT,
     2102 *  Callback that fires when the nested VMX-preemption timer expired.}
     2103 */
     2104static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
     2105{
     2106    RT_NOREF(pVM, hTimer);
    21122107    PVMCPU pVCpu = (PVMCPUR3)pvUser;
     2108    AssertPtr(pVCpu);
    21132109    VMCPU_FF_SET(pVCpu, VMCPU_FF_VMX_PREEMPT_TIMER);
    21142110}
    … …  
    22242220
    22252221        pVCpu->cpum.s.Host.fXStateMask = fXStateHostMask;
     2222
     2223        pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE;
    22262224    }
    22272225
    … …  
    23342332        {
    23352333            PVMCPU pVCpu = pVM->apCpusR3[idCpu];
    2336             int rc = TMR3TimerDestroy(pVCpu->cpum.s.pNestedVmxPreemptTimerR3); AssertRC(rc);
    2337             pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = NIL_RTR0PTR;
     2334            if (pVCpu->cpum.s.hNestedVmxPreemptTimer != NIL_TMTIMERHANDLE)
     2335            {
     2336                int rc = TMR3TimerDestroy(pVM, pVCpu->cpum.s.hNestedVmxPreemptTimer); AssertRC(rc);
     2337                pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE;
     2338            }
    23382339        }
    23392340
    … …  
    45024503            cpumR3MsrRegStats(pVM);
    45034504
    4504             /* Create VMX-preemption timer for nested guests if required. */
    4505 /** @todo r=bird: this should be one in CPUMR3Init, not here.  */
     4505            /* Create VMX-preemption timer for nested guests if required.  Must be
     4506               done here as CPUM is initialized before TM. */
    45064507            if (pVM->cpum.s.GuestFeatures.fVmx)
    45074508            {
    … …  
    45134514                    char *pszTimerName = MMR3HeapAPrintf(pVM, MM_TAG_CPUM_CTX, "Nested Guest VMX-preempt. timer %u", idCpu);
    45144515                    int rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, cpumR3VmxPreemptTimerCallback, pVCpu,
    4515                                              TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.pNestedVmxPreemptTimerR3);
     4516                                             TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.hNestedVmxPreemptTimer);
    45164517                    AssertLogRelRCReturn(rc, rc);
    4517                     pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = TMTimerR0Ptr(pVCpu->cpum.s.pNestedVmxPreemptTimerR3);
    45184518                }
    45194519            }

  • trunk/src/VBox/VMM/VMMR3/GIMHv.cpp

    r87765 r87766  
    187187static int    gimR3HvInitDebugSupport(PVM pVM);
    188188static void   gimR3HvTermDebugSupport(PVM pVM);
    189 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser);
     189static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE pTimer, void *pvUser);
    190190
    191191/**
    … …  
    202202
    203203    PGIMHV pHv = &pVM->gim.s.u.Hv;
     204
     205    /*
     206     * Initialize timer handles and such.
     207     */
     208    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
     209    {
     210        PVMCPU       pVCpu     = pVM->apCpusR3[idCpu];
     211        PGIMHVCPU    pHvCpu    = &pVCpu->gim.s.u.HvCpu;
     212        for (uint8_t idxStimer = 0; idxStimer < RT_ELEMENTS(pHvCpu->aStimers); idxStimer++)
     213            pHvCpu->aStimers[idxStimer].hTimer = NIL_TMTIMERHANDLE;
     214    }
    204215
    205216    /*
    … …  
    510521                            idxStimer);
    511522                rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, gimR3HvTimerCallback, pHvStimer /* pvUser */,
    512                                      TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->pTimerR3);
     523                                     TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->hTimer);
    513524                AssertLogRelRCReturn(rc, rc);
    514                 pHvStimer->pTimerR0 = TMTimerR0Ptr(pHvStimer->pTimerR3);
    515525            }
    516526        }
    … …  
    605615            {
    606616                PGIMHVSTIMER pHvStimer = &pHvCpu->aStimers[idxStimer];
    607                 TMR3TimerDestroy(pHvStimer->pTimerR3);
     617                TMR3TimerDestroy(pVM, pHvStimer->hTimer);
     618                pHvStimer->hTimer = NIL_TMTIMERHANDLE;
    608619            }
    609620        }
    … …  
    10821093
    10831094/**
    1084  * Hyper-V synthetic timer callback.
    1085  *
    1086  * @param   pVM         The cross context VM structure.
    1087  * @param   pTimer      Pointer to timer.
    1088  * @param   pvUser      Pointer to the synthetic timer.
    1089  */
    1090 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
     1095 * @callback_method_impl{FNTMTIMERINT, Hyper-V synthetic timer callback.}
     1096 */
     1097static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
    10911098{
    10921099    PGIMHVSTIMER pHvStimer = (PGIMHVSTIMER)pvUser;
    10931100    Assert(pHvStimer);
    1094     Assert(TMTimerIsLockOwner(pTimer)); RT_NOREF(pTimer);
     1101    Assert(TMTimerIsLockOwner(pVM, hTimer));
    10951102    Assert(pHvStimer->idCpu < pVM->cCpus);
     1103    Assert(pHvStimer->hTimer == hTimer);
     1104    RT_NOREF(hTimer);
    10961105
    10971106    PVMCPU    pVCpu  = pVM->apCpusR3[pHvStimer->idCpu];

  • trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFile.cpp

    r87765 r87766  
    363363                {
    364364                    ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, tsDelay);
    365                     TMTimerSetMillies(pEpClassFile->pTimer, tsDelay);
     365                    TMTimerSetMillies(pVM, pEpClassFile->hTimer, tsDelay);
    366366                }
    367367
    … …  
    733733}
    734734
    735 static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
    736 {
     735/**
     736 * @callback_method_impl{FNTMTIMERINT, }
     737 */
     738static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
     739{
     740    Assert(hTimer == pEpClassFile->hTimer);
    737741    uint64_t tsCur = RTTimeProgramMilliTS();
    738742    uint64_t cMilliesNext = UINT64_MAX;
    … …  
    784788    {
    785789        ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, cMilliesNext);
    786         TMTimerSetMillies(pEpClassFile->pTimer, cMilliesNext);
     790        TMTimerSetMillies(pVM, hTimer, cMilliesNext);
    787791    }
    788792}
    … …  
    868872# ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
    869873    rc = TMR3TimerCreate(pEpClassFile->Core.pVM, TMCLOCK_REAL, pdmacR3TimerCallback, pEpClassFile,
    870                          TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile->pTimer);
     874                         TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile->hTimer);
    871875    AssertRC(rc);
    872876    pEpClassFile->cMilliesNext = UINT64_MAX;

  • trunk/src/VBox/VMM/VMMR3/PDMBlkCache.cpp

    r87765 r87766  
    736736    if (   !(cbDirtyOld - cbCommitted)
    737737        && pBlkCache->pCache->u32CommitTimeoutMs != 0)
    738         TMTimerStop(pBlkCache->pCache->pTimerCommit);
     738        TMTimerStop(pBlkCache->pCache->pVM, pBlkCache->pCache->hTimerCommit);
    739739}
    740740
    … …  
    808808        {
    809809            /* Arm the commit timer. */
    810             TMTimerSetMillies(pCache->pTimerCommit, pCache->u32CommitTimeoutMs);
     810            TMTimerSetMillies(pCache->pVM, pCache->hTimerCommit, pCache->u32CommitTimeoutMs);
    811811        }
    812812    }
    … …  
    833833
    834834/**
    835  * Commit timer callback.
    836  */
    837 static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
     835 * @callback_method_impl{FNTMTIMERINT, Commit timer callback.}
     836 */
     837static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
    838838{
    839839    PPDMBLKCACHEGLOBAL pCache = (PPDMBLKCACHEGLOBAL)pvUser;
    840     NOREF(pVM); NOREF(pTimer);
     840    RT_NOREF(pVM, hTimer);
    841841
    842842    LogFlowFunc(("Commit interval expired, commiting dirty entries\n"));
    … …  
    11581158        if (pBlkCacheGlobal->u32CommitTimeoutMs > 0)
    11591159            rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmBlkCacheCommitTimerCallback, pBlkCacheGlobal,
    1160                                  TMTIMER_FLAGS_NO_RING0,  "BlkCache-Commit", &pBlkCacheGlobal->pTimerCommit);
     1160                                 TMTIMER_FLAGS_NO_RING0,  "BlkCache-Commit", &pBlkCacheGlobal->hTimerCommit);
    11611161
    11621162        if (RT_SUCCESS(rc))
    … …  
    27782778VMMR3DECL(int) PDMR3BlkCacheClear(PPDMBLKCACHE pBlkCache)
    27792779{
    2780     int rc = VINF_SUCCESS;
    27812780    PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
    27822781
    … …  
    27962795
    27972796    pdmBlkCacheLockLeave(pCache);
    2798     return rc;
    2799 }
    2800 
     2797    return VINF_SUCCESS;
     2798}
     2799

  • trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp

    r87764 r87766  
    439439        Assert(fFlags & TMTIMER_FLAGS_NO_RING0 /* just to make sure all devices has been considered */);
    440440
    441     PTMTIMER pTimer = NULL;
    442     int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
    443     *phTimer = (uintptr_t)pTimer;
     441    int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
    444442
    445443    LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    446444    return rc;
    447 }
    448 
    449 
    450 /** Converts timer handle to pointer (used to exposed, will be replace soon.) */
    451 DECLINLINE(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    452 {
    453     PDMDEV_ASSERT_DEVINS(pDevIns);
    454     RT_NOREF(pDevIns);
    455     return (PTMTIMERR3)hTimer;
    456445}
    457446
    … …  
    460449static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
    461450{
    462     return TMTimerFromMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicroSecs);
     451    PDMDEV_ASSERT_DEVINS(pDevIns);
     452    return TMTimerFromMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicroSecs);
    463453}
    464454
    … …  
    468458{
    469459    PDMDEV_ASSERT_DEVINS(pDevIns);
    470     return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliSecs);
     460    return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, hTimer, cMilliSecs);
    471461}
    472462
    … …  
    475465static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
    476466{
    477     return TMTimerFromNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanoSecs);
     467    PDMDEV_ASSERT_DEVINS(pDevIns);
     468    return TMTimerFromNano(pDevIns->Internal.s.pVMR3, hTimer, cNanoSecs);
    478469}
    479470
    … …  
    481472static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    482473{
    483     return TMTimerGet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     474    PDMDEV_ASSERT_DEVINS(pDevIns);
     475    return TMTimerGet(pDevIns->Internal.s.pVMR3, hTimer);
    484476}
    485477
    … …  
    488480static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    489481{
    490     return TMTimerGetFreq(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     482    PDMDEV_ASSERT_DEVINS(pDevIns);
     483    return TMTimerGetFreq(pDevIns->Internal.s.pVMR3, hTimer);
    491484}
    492485
    … …  
    495488static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    496489{
    497     return TMTimerGetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     490    PDMDEV_ASSERT_DEVINS(pDevIns);
     491    return TMTimerGetNano(pDevIns->Internal.s.pVMR3, hTimer);
    498492}
    499493
    … …  
    502496static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    503497{
    504     return TMTimerIsActive(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     498    PDMDEV_ASSERT_DEVINS(pDevIns);
     499    return TMTimerIsActive(pDevIns->Internal.s.pVMR3, hTimer);
    505500}
    506501
    … …  
    509504static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    510505{
    511     return TMTimerIsLockOwner(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     506    PDMDEV_ASSERT_DEVINS(pDevIns);
     507    return TMTimerIsLockOwner(pDevIns->Internal.s.pVMR3, hTimer);
    512508}
    513509
    … …  
    516512static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
    517513{
    518     return TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
     514    PDMDEV_ASSERT_DEVINS(pDevIns);
     515    return TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy);
    519516}
    520517
    … …  
    524521                                                              PPDMCRITSECT pCritSect, int rcBusy)
    525522{
    526     VBOXSTRICTRC rc = TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
     523    PDMDEV_ASSERT_DEVINS(pDevIns);
     524    VBOXSTRICTRC rc = TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy);
    527525    if (rc == VINF_SUCCESS)
    528526    {
    … …  
    531529            return rc;
    532530        AssertRC(VBOXSTRICTRC_VAL(rc));
    533         TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     531        TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
    534532    }
    535533    else
    … …  
    542540static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
    543541{
    544     return TMTimerSet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uExpire);
     542    PDMDEV_ASSERT_DEVINS(pDevIns);
     543    return TMTimerSet(pDevIns->Internal.s.pVMR3, hTimer, uExpire);
    545544}
    546545
    … …  
    549548static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
    550549{
    551     return TMTimerSetFrequencyHint(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uHz);
     550    PDMDEV_ASSERT_DEVINS(pDevIns);
     551    return TMTimerSetFrequencyHint(pDevIns->Internal.s.pVMR3, hTimer, uHz);
    552552}
    553553
    … …  
    556556static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
    557557{
    558     return TMTimerSetMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicrosToNext);
     558    PDMDEV_ASSERT_DEVINS(pDevIns);
     559    return TMTimerSetMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicrosToNext);
    559560}
    560561
    … …  
    563564static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
    564565{
    565     return TMTimerSetMillies(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliesToNext);
     566    PDMDEV_ASSERT_DEVINS(pDevIns);
     567    return TMTimerSetMillies(pDevIns->Internal.s.pVMR3, hTimer, cMilliesToNext);
    566568}
    567569
    … …  
    570572static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
    571573{
    572     return TMTimerSetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanosToNext);
     574    PDMDEV_ASSERT_DEVINS(pDevIns);
     575    return TMTimerSetNano(pDevIns->Internal.s.pVMR3, hTimer, cNanosToNext);
    573576}
    574577
    … …  
    577580static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    578581{
    579     return TMTimerSetRelative(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cTicksToNext, pu64Now);
     582    PDMDEV_ASSERT_DEVINS(pDevIns);
     583    return TMTimerSetRelative(pDevIns->Internal.s.pVMR3, hTimer, cTicksToNext, pu64Now);
    580584}
    581585
    … …  
    584588static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    585589{
    586     return TMTimerStop(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     590    PDMDEV_ASSERT_DEVINS(pDevIns);
     591    return TMTimerStop(pDevIns->Internal.s.pVMR3, hTimer);
    587592}
    588593
    … …  
    591596static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    592597{
    593     TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     598    PDMDEV_ASSERT_DEVINS(pDevIns);
     599    TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
    594600}
    595601
    … …  
    598604static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    599605{
    600     TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     606    PDMDEV_ASSERT_DEVINS(pDevIns);
     607    TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
    601608    int rc = PDMCritSectLeave(pCritSect);
    602609    AssertRC(rc);
    … …  
    607614static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    608615{
    609     return TMR3TimerSetCritSect(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pCritSect);
     616    PDMDEV_ASSERT_DEVINS(pDevIns);
     617    return TMR3TimerSetCritSect(pDevIns->Internal.s.pVMR3, hTimer, pCritSect);
    610618}
    611619
    … …  
    614622static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
    615623{
    616     return TMR3TimerSave(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM);
     624    PDMDEV_ASSERT_DEVINS(pDevIns);
     625    return TMR3TimerSave(pDevIns->Internal.s.pVMR3, hTimer, pSSM);
    617626}
    618627
    … …  
    621630static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
    622631{
    623     return TMR3TimerLoad(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM);
     632    PDMDEV_ASSERT_DEVINS(pDevIns);
     633    return TMR3TimerLoad(pDevIns->Internal.s.pVMR3, hTimer, pSSM);
    624634}
    625635
    … …  
    628638static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
    629639{
    630     return TMR3TimerDestroy(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
     640    PDMDEV_ASSERT_DEVINS(pDevIns);
     641    return TMR3TimerDestroy(pDevIns->Internal.s.pVMR3, hTimer);
    631642}
    632643

  • trunk/src/VBox/VMM/VMMR3/PDMDriver.cpp

    r87761 r87766  
    13371337        fFlags |= TMTIMER_FLAGS_NO_RING0;
    13381338
    1339     PTMTIMERR3 pTimer = NULL;
    1340     int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
    1341     if (RT_SUCCESS(rc))
    1342         *phTimer = (TMTIMERHANDLE)pTimer;
     1339    int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
    13431340
    13441341    LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc *phTimer=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, *phTimer));

  • trunk/src/VBox/VMM/VMMR3/PDMQueue.cpp

    r87765 r87766  
    3939DECLINLINE(void)            pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem);
    4040static bool                 pdmR3QueueFlush(PPDMQUEUE pQueue);
    41 static DECLCALLBACK(void)   pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
     41static DECLCALLBACK(void)   pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
    4242
    4343
    … …  
    8989    pQueue->pszName = pszName;
    9090    pQueue->cMilliesInterval = cMilliesInterval;
    91     //pQueue->pTimer = NULL;
     91    pQueue->hTimer = NIL_TMTIMERHANDLE;
    9292    pQueue->cbItem = (uint32_t)cbItem;
    9393    pQueue->cItems = cItems;
    … …  
    113113    if (cMilliesInterval)
    114114    {
    115         rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->pTimer);
     115        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->hTimer);
    116116        if (RT_SUCCESS(rc))
    117117        {
    118             rc = TMTimerSetMillies(pQueue->pTimer, cMilliesInterval);
     118            rc = TMTimerSetMillies(pVM, pQueue->hTimer, cMilliesInterval);
    119119            if (RT_FAILURE(rc))
    120120            {
    121121                AssertMsgFailed(("TMTimerSetMillies failed rc=%Rrc\n", rc));
    122                 int rc2 = TMR3TimerDestroy(pQueue->pTimer); AssertRC(rc2);
     122                int rc2 = TMR3TimerDestroy(pVM, pQueue->hTimer); AssertRC(rc2);
    123123            }
    124124        }
    … …  
    398398     * Unlink it.
    399399     */
    400     if (pQueue->pTimer)
     400    if (pQueue->hTimer != NIL_TMTIMERHANDLE)
    401401    {
    402402        if (pUVM->pdm.s.pQueuesTimer != pQueue)
    … …  
    448448     * Destroy the timer and free it.
    449449     */
    450     if (pQueue->pTimer)
    451     {
    452         TMR3TimerDestroy(pQueue->pTimer);
    453         pQueue->pTimer = NULL;
     450    if (pQueue->hTimer != NIL_TMTIMERHANDLE)
     451    {
     452        TMR3TimerDestroy(pVM, pQueue->hTimer);
     453        pQueue->hTimer = NIL_TMTIMERHANDLE;
    454454    }
    455455    if (pQueue->pVMRC)
    … …  
    856856
    857857/**
    858  * Timer handler for PDM queues.
    859  * This is called by for a single queue.
    860  *
    861  * @param   pVM     The cross context VM structure.
    862  * @param   pTimer  Pointer to timer.
    863  * @param   pvUser  Pointer to the queue.
    864  */
    865 static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
     858 * @callback_method_impl{FNTMTIMERINT, Timer handler for one PDM queue.}
     859 */
     860static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
    866861{
    867862    PPDMQUEUE pQueue = (PPDMQUEUE)pvUser;
    868     Assert(pTimer == pQueue->pTimer); NOREF(pTimer); NOREF(pVM);
     863    Assert(hTimer == pQueue->hTimer);
    869864
    870865    if (   pQueue->pPendingR3
    … …  
    872867        || pQueue->pPendingRC)
    873868        pdmR3QueueFlush(pQueue);
    874     int rc = TMTimerSetMillies(pQueue->pTimer, pQueue->cMilliesInterval);
     869    int rc = TMTimerSetMillies(pVM, hTimer, pQueue->cMilliesInterval);
    875870    AssertRC(rc);
    876871}

  • trunk/src/VBox/VMM/VMMR3/PDMUsb.cpp

    r87764 r87766  
    18331833        pszDesc = pszDesc2;
    18341834
    1835     PTMTIMERR3 pTimer = NULL;
    1836     int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
    1837     if (RT_SUCCESS(rc))
    1838         *phTimer = (TMTIMERHANDLE)pTimer;
     1835    int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
    18391836
    18401837    LogFlow(("pdmR3UsbHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc *phTimer=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc, *phTimer));
    … …  
    18431840
    18441841
    1845 /** Converts timer handle to pointer (will be replace soon.) */
    1846 DECLINLINE(PTMTIMERR3) pdmR3UsbHlp_TimerToPtr(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    1847 {
    1848     PDMUSB_ASSERT_USBINS(pUsbIns);
    1849     RT_NOREF(pUsbIns);
    1850     return (PTMTIMERR3)hTimer;
    1851 }
    1852 
    1853 
    18541842/** @interface_method_impl{PDMUSBHLP,pfnTimerFromMicro} */
    18551843static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
    18561844{
    1857     return TMTimerFromMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicroSecs);
     1845    PDMUSB_ASSERT_USBINS(pUsbIns);
     1846    return TMTimerFromMicro(pUsbIns->Internal.s.pVM, hTimer, cMicroSecs);
    18581847}
    18591848
    … …  
    18631852{
    18641853    PDMUSB_ASSERT_USBINS(pUsbIns);
    1865     return TMTimerFromMilli(pUsbIns->Internal.s.pVM, pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliSecs);
     1854    return TMTimerFromMilli(pUsbIns->Internal.s.pVM, hTimer, cMilliSecs);
    18661855}
    18671856
    … …  
    18701859static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
    18711860{
    1872     return TMTimerFromNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanoSecs);
     1861    PDMUSB_ASSERT_USBINS(pUsbIns);
     1862    return TMTimerFromNano(pUsbIns->Internal.s.pVM, hTimer, cNanoSecs);
    18731863}
    18741864
    … …  
    18761866static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    18771867{
    1878     return TMTimerGet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1868    PDMUSB_ASSERT_USBINS(pUsbIns);
     1869    return TMTimerGet(pUsbIns->Internal.s.pVM, hTimer);
    18791870}
    18801871
    … …  
    18831874static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetFreq(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    18841875{
    1885     return TMTimerGetFreq(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1876    PDMUSB_ASSERT_USBINS(pUsbIns);
     1877    return TMTimerGetFreq(pUsbIns->Internal.s.pVM, hTimer);
    18861878}
    18871879
    … …  
    18901882static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    18911883{
    1892     return TMTimerGetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1884    PDMUSB_ASSERT_USBINS(pUsbIns);
     1885    return TMTimerGetNano(pUsbIns->Internal.s.pVM, hTimer);
    18931886}
    18941887
    … …  
    18971890static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsActive(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    18981891{
    1899     return TMTimerIsActive(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1892    PDMUSB_ASSERT_USBINS(pUsbIns);
     1893    return TMTimerIsActive(pUsbIns->Internal.s.pVM, hTimer);
    19001894}
    19011895
    … …  
    19041898static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsLockOwner(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    19051899{
    1906     return TMTimerIsLockOwner(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1900    PDMUSB_ASSERT_USBINS(pUsbIns);
     1901    return TMTimerIsLockOwner(pUsbIns->Internal.s.pVM, hTimer);
    19071902}
    19081903
    … …  
    19111906static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    19121907{
    1913     return TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED);
     1908    PDMUSB_ASSERT_USBINS(pUsbIns);
     1909    return TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED);
    19141910}
    19151911
    … …  
    19181914static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    19191915{
    1920     int rc = TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED);
     1916    PDMUSB_ASSERT_USBINS(pUsbIns);
     1917    int rc = TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED);
    19211918    if (rc == VINF_SUCCESS)
    19221919    {
    … …  
    19251922            return rc;
    19261923        AssertRC(rc);
    1927         TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1924        TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
    19281925    }
    19291926    else
    … …  
    19361933static DECLCALLBACK(int) pdmR3UsbHlp_TimerSet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
    19371934{
    1938     return TMTimerSet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uExpire);
     1935    PDMUSB_ASSERT_USBINS(pUsbIns);
     1936    return TMTimerSet(pUsbIns->Internal.s.pVM, hTimer, uExpire);
    19391937}
    19401938
    … …  
    19431941static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetFrequencyHint(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint32_t uHz)
    19441942{
    1945     return TMTimerSetFrequencyHint(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uHz);
     1943    PDMUSB_ASSERT_USBINS(pUsbIns);
     1944    return TMTimerSetFrequencyHint(pUsbIns->Internal.s.pVM, hTimer, uHz);
    19461945}
    19471946
    … …  
    19501949static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
    19511950{
    1952     return TMTimerSetMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicrosToNext);
     1951    PDMUSB_ASSERT_USBINS(pUsbIns);
     1952    return TMTimerSetMicro(pUsbIns->Internal.s.pVM, hTimer, cMicrosToNext);
    19531953}
    19541954
    … …  
    19571957static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMillies(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
    19581958{
    1959     return TMTimerSetMillies(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliesToNext);
     1959    PDMUSB_ASSERT_USBINS(pUsbIns);
     1960    return TMTimerSetMillies(pUsbIns->Internal.s.pVM, hTimer, cMilliesToNext);
    19601961}
    19611962
    … …  
    19641965static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
    19651966{
    1966     return TMTimerSetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanosToNext);
     1967    PDMUSB_ASSERT_USBINS(pUsbIns);
     1968    return TMTimerSetNano(pUsbIns->Internal.s.pVM, hTimer, cNanosToNext);
    19671969}
    19681970
    … …  
    19711973static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetRelative(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    19721974{
    1973     return TMTimerSetRelative(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cTicksToNext, pu64Now);
     1975    PDMUSB_ASSERT_USBINS(pUsbIns);
     1976    return TMTimerSetRelative(pUsbIns->Internal.s.pVM, hTimer, cTicksToNext, pu64Now);
    19741977}
    19751978
    … …  
    19781981static DECLCALLBACK(int) pdmR3UsbHlp_TimerStop(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    19791982{
    1980     return TMTimerStop(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1983    PDMUSB_ASSERT_USBINS(pUsbIns);
     1984    return TMTimerStop(pUsbIns->Internal.s.pVM, hTimer);
    19811985}
    19821986
    … …  
    19851989static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    19861990{
    1987     TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1991    PDMUSB_ASSERT_USBINS(pUsbIns);
     1992    TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
    19881993}
    19891994
    … …  
    19921997static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    19931998{
    1994     TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     1999    PDMUSB_ASSERT_USBINS(pUsbIns);
     2000    TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
    19952001    int rc = PDMCritSectLeave(pCritSect);
    19962002    AssertRC(rc);
    … …  
    20012007static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetCritSect(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    20022008{
    2003     return TMR3TimerSetCritSect(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pCritSect);
     2009    PDMUSB_ASSERT_USBINS(pUsbIns);
     2010    return TMR3TimerSetCritSect(pUsbIns->Internal.s.pVM, hTimer, pCritSect);
    20042011}
    20052012
    … …  
    20082015static DECLCALLBACK(int) pdmR3UsbHlp_TimerSave(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
    20092016{
    2010     return TMR3TimerSave(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM);
     2017    PDMUSB_ASSERT_USBINS(pUsbIns);
     2018    return TMR3TimerSave(pUsbIns->Internal.s.pVM, hTimer, pSSM);
    20112019}
    20122020
    … …  
    20152023static DECLCALLBACK(int) pdmR3UsbHlp_TimerLoad(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
    20162024{
    2017     return TMR3TimerLoad(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM);
     2025    PDMUSB_ASSERT_USBINS(pUsbIns);
     2026    return TMR3TimerLoad(pUsbIns->Internal.s.pVM, hTimer, pSSM);
    20182027}
    20192028
    … …  
    20222031static DECLCALLBACK(int) pdmR3UsbHlp_TimerDestroy(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
    20232032{
    2024     return TMR3TimerDestroy(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
     2033    PDMUSB_ASSERT_USBINS(pUsbIns);
     2034    return TMR3TimerDestroy(pUsbIns->Internal.s.pVM, hTimer);
    20252035}
    20262036

  • trunk/src/VBox/VMM/VMMR3/TM.cpp

    r87765 r87766  
    180180static DECLCALLBACK(int)    tmR3SetWarpDrive(PUVM pUVM, uint32_t u32Percent);
    181181#ifndef VBOX_WITHOUT_NS_ACCOUNTING
    182 static DECLCALLBACK(void)   tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
     182static DECLCALLBACK(void)   tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
    183183#endif
    184184static DECLCALLBACK(void)   tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
    … …  
    11001100     * Create a timer for refreshing the CPU load stats.
    11011101     */
    1102     PTMTIMER pTimer;
    1103     rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", &pTimer);
     1102    TMTIMERHANDLE hTimer;
     1103    rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", &hTimer);
    11041104    if (RT_SUCCESS(rc))
    1105         rc = TMTimerSetMillies(pTimer, 1000);
     1105        rc = TMTimerSetMillies(pVM, hTimer, 1000);
    11061106#endif
    11071107
    … …  
    15421542    pTimer->u64Expire       = 0;
    15431543    pTimer->enmClock        = enmClock;
     1544    pTimer->hSelf           = (TMTIMERHANDLE)pTimer;
    15441545    pTimer->pVMR3           = pVM;
    15451546    pTimer->pVMR0           = pVM->pVMR0ForCall; /** @todo fix properly */
    … …  
    16021603 * @param   pszDesc         Pointer to description string which must stay around
    16031604 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    1604  * @param   ppTimer         Where to store the timer on success.
     1605 * @param   phTimer         Where to store the timer handle on success.
    16051606 */
    16061607VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock,
    16071608                                        PFNTMTIMERDEV pfnCallback, void *pvUser,
    1608                                         uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1609                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    16091610{
    16101611    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
    … …  
    16141615     * Allocate and init stuff.
    16151616     */
    1616     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
     1617    PTMTIMER pTimer;
     1618    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
    16171619    if (RT_SUCCESS(rc))
    16181620    {
    1619         (*ppTimer)->enmType         = TMTIMERTYPE_DEV;
    1620         (*ppTimer)->u.Dev.pfnTimer  = pfnCallback;
    1621         (*ppTimer)->u.Dev.pDevIns   = pDevIns;
    1622         (*ppTimer)->pvUser          = pvUser;
     1621        pTimer->enmType         = TMTIMERTYPE_DEV;
     1622        pTimer->u.Dev.pfnTimer  = pfnCallback;
     1623        pTimer->u.Dev.pDevIns   = pDevIns;
     1624        pTimer->pvUser          = pvUser;
    16231625        if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT))
    1624             (*ppTimer)->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
    1625         Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
     1626            pTimer->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
     1627        *phTimer = pTimer->hSelf;
     1628        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszDesc));
    16261629    }
    16271630
    … …  
    16441647 * @param   pszDesc         Pointer to description string which must stay around
    16451648 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    1646  * @param   ppTimer         Where to store the timer on success.
     1649 * @param   phTimer         Where to store the timer handle on success.
    16471650 */
    16481651VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock,
    16491652                                     PFNTMTIMERUSB pfnCallback, void *pvUser,
    1650                                      uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1653                                     uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    16511654{
    16521655    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER);
    … …  
    16551658     * Allocate and init stuff.
    16561659     */
    1657     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
     1660    PTMTIMER pTimer;
     1661    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
    16581662    if (RT_SUCCESS(rc))
    16591663    {
    1660         (*ppTimer)->enmType         = TMTIMERTYPE_USB;
    1661         (*ppTimer)->u.Usb.pfnTimer  = pfnCallback;
    1662         (*ppTimer)->u.Usb.pUsbIns   = pUsbIns;
    1663         (*ppTimer)->pvUser          = pvUser;
     1664        pTimer->enmType         = TMTIMERTYPE_USB;
     1665        pTimer->u.Usb.pfnTimer  = pfnCallback;
     1666        pTimer->u.Usb.pUsbIns   = pUsbIns;
     1667        pTimer->pvUser          = pvUser;
    16641668        //if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT))
    16651669        //{
    16661670        //    if (pDevIns->pCritSectR3)
    1667         //        (*ppTimer)->pCritSect = pUsbIns->pCritSectR3;
     1671        //        pTimer->pCritSect = pUsbIns->pCritSectR3;
    16681672        //    else
    1669         //        (*ppTimer)->pCritSect = IOMR3GetCritSect(pVM);
     1673        //        pTimer->pCritSect = IOMR3GetCritSect(pVM);
    16701674        //}
    1671         Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
     1675        *phTimer = pTimer->hSelf;
     1676        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
    16721677    }
    16731678
    … …  
    16881693 * @param   pszDesc         Pointer to description string which must stay around
    16891694 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    1690  * @param   ppTimer         Where to store the timer on success.
     1695 * @param   phTimer         Where to store the timer handle on success.
    16911696 */
    16921697VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
    1693                                         uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1698                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    16941699{
    16951700    AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
    … …  
    16991704     * Allocate and init stuff.
    17001705     */
    1701     int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
     1706    PTMTIMER pTimer;
     1707    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
    17021708    if (RT_SUCCESS(rc))
    17031709    {
    1704         (*ppTimer)->enmType         = TMTIMERTYPE_DRV;
    1705         (*ppTimer)->u.Drv.pfnTimer  = pfnCallback;
    1706         (*ppTimer)->u.Drv.pDrvIns   = pDrvIns;
    1707         (*ppTimer)->pvUser          = pvUser;
    1708         Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
     1710        pTimer->enmType         = TMTIMERTYPE_DRV;
     1711        pTimer->u.Drv.pfnTimer  = pfnCallback;
     1712        pTimer->u.Drv.pDrvIns   = pDrvIns;
     1713        pTimer->pvUser          = pvUser;
     1714        *phTimer = pTimer->hSelf;
     1715        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
    17091716    }
    17101717
    … …  
    17241731 * @param   pszDesc         Pointer to description string which must stay around
    17251732 *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
    1726  * @param   ppTimer         Where to store the timer on success.
     1733 * @param   phTimer         Where to store the timer handle on success.
    17271734 */
    17281735VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser,
    1729                                uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
     1736                               uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
    17301737{
    17311738    AssertReturn(fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0), VERR_INVALID_FLAGS);
    … …  
    17431750        pTimer->u.Internal.pfnTimer = pfnCallback;
    17441751        pTimer->pvUser              = pvUser;
    1745         *ppTimer = pTimer;
     1752        *phTimer = pTimer->hSelf;
    17461753        Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
    17471754    }
    … …  
    17571764 * @param   pTimer          Timer handle as returned by one of the create functions.
    17581765 */
    1759 VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer)
    1760 {
    1761     /*
    1762      * Be extra careful here.
    1763      */
    1764     if (!pTimer)
    1765         return VINF_SUCCESS;
    1766     AssertPtr(pTimer);
     1766static int tmR3TimerDestroy(PVMCC pVM, PTMTIMER pTimer)
     1767{
    17671768    Assert((unsigned)pTimer->enmClock < (unsigned)TMCLOCK_MAX);
    17681769
    1769     PVM             pVM      = pTimer->CTX_SUFF(pVM);
    17701770    PTMTIMERQUEUE   pQueue   = &pVM->tm.s.CTX_SUFF(paTimerQueues)[pTimer->enmClock];
    17711771    bool            fActive  = false;
    … …  
    19251925
    19261926/**
     1927 * Destroy a timer
     1928 *
     1929 * @returns VBox status code.
     1930 * @param   pVM         The cross context VM structure.
     1931 * @param   hTimer      Timer handle as returned by one of the create functions.
     1932 */
     1933VMMR3DECL(int) TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer)
     1934{
     1935    /* We ignore NILs here. */
     1936    if (hTimer == NIL_TMTIMERHANDLE)
     1937        return VINF_SUCCESS;
     1938    PTMTIMER pTimer;
     1939    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     1940    return tmR3TimerDestroy(pVM, pTimer);
     1941}
     1942
     1943
     1944/**
    19271945 * Destroy all timers owned by a device.
    19281946 *
    … …  
    19461964            &&  pDestroy->u.Dev.pDevIns == pDevIns)
    19471965        {
    1948             int rc = TMR3TimerDestroy(pDestroy);
     1966            int rc = tmR3TimerDestroy(pVM, pDestroy);
    19491967            AssertRC(rc);
    19501968        }
    … …  
    19791997            &&  pDestroy->u.Usb.pUsbIns == pUsbIns)
    19801998        {
    1981             int rc = TMR3TimerDestroy(pDestroy);
     1999            int rc = tmR3TimerDestroy(pVM, pDestroy);
    19822000            AssertRC(rc);
    19832001        }
    … …  
    20122030            &&  pDestroy->u.Drv.pDrvIns == pDrvIns)
    20132031        {
    2014             int rc = TMR3TimerDestroy(pDestroy);
     2032            int rc = tmR3TimerDestroy(pVM, pDestroy);
    20152033            AssertRC(rc);
    20162034        }
    … …  
    22882306                case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
    22892307                case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
    2290                 case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
     2308                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    22912309                default:
    22922310                    AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
    … …  
    24722490            case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
    24732491            case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
    2474             case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
     2492            case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
    24752493            default:
    24762494                AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
    … …  
    26962714 *
    26972715 * @returns VBox status code.
    2698  * @param   pTimer          Timer to save.
     2716 * @param   pVM             The cross context VM structure.
     2717 * @param   hTimer          Timer to save.
    26992718 * @param   pSSM            Save State Manager handle.
    27002719 */
    2701 VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
    2702 {
     2720VMMR3DECL(int) TMR3TimerSave(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
     2721{
     2722    VM_ASSERT_EMT(pVM);
     2723    PTMTIMER pTimer;
     2724    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    27032725    LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
     2726
    27042727    switch (pTimer->enmState)
    27052728    {
    … …  
    27382761 *
    27392762 * @returns VBox status code.
    2740  * @param   pTimer          Timer to restore.
     2763 * @param   pVM             The cross context VM structure.
     2764 * @param   hTimer          Handle of Timer to restore.
    27412765 * @param   pSSM            Save State Manager handle.
    27422766 */
    2743 VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
    2744 {
    2745     Assert(pTimer); Assert(pSSM); VM_ASSERT_EMT(pTimer->pVMR3);
     2767VMMR3DECL(int) TMR3TimerLoad(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
     2768{
     2769    VM_ASSERT_EMT(pVM);
     2770    PTMTIMER pTimer;
     2771    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     2772    Assert(pSSM);
    27462773    LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
    27472774
    … …  
    27872814         */
    27882815        Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
    2789         rc = TMTimerSet(pTimer, u64Expire);
     2816        rc = TMTimerSet(pVM, hTimer, u64Expire);
    27902817    }
    27912818    else
    … …  
    27952822         */
    27962823        Log(("u8State=%d\n", u8State));
    2797         rc = TMTimerStop(pTimer);
     2824        rc = TMTimerStop(pVM, hTimer);
    27982825    }
    27992826
    … …  
    28872914 *          active.
    28882915 */
    2889 VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
    2890 {
    2891     AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
     2916VMMR3DECL(int) TMR3TimerSetCritSect(PVM pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
     2917{
     2918    PTMTIMER pTimer;
     2919    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    28922920    AssertPtrReturn(pCritSect, VERR_INVALID_PARAMETER);
    28932921    const char *pszName = PDMR3CritSectName(pCritSect); /* exploited for validation */
    … …  
    34143442
    34153443/**
    3416  * Timer callback that calculates the CPU load since the last time it was
    3417  * called.
    3418  *
    3419  * @param   pVM                 The cross context VM structure.
    3420  * @param   pTimer              The timer.
    3421  * @param   pvUser              NULL, unused.
    3422  */
    3423 static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
     3444 * @callback_method_impl{FNTMTIMERINT,
     3445 *      Timer callback that calculates the CPU load since the last
     3446 *      time it was called.}
     3447 */
     3448static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
    34243449{
    34253450    /*
    34263451     * Re-arm the timer first.
    34273452     */
    3428     int rc = TMTimerSetMillies(pTimer, 1000);
     3453    int rc = TMTimerSetMillies(pVM, hTimer, 1000);
    34293454    AssertLogRelRC(rc);
    34303455    NOREF(pvUser);
    … …  
    36803705                        pTimer->offScheduleNext,
    36813706                        tmR3Get5CharClockName(pTimer->enmClock),
    3682                         TMTimerGet(pTimer),
     3707                        TMTimerGet(pVM, pTimer->hSelf),
    36833708                        pTimer->u64Expire,
    36843709                        pTimer->uHzHint,
    … …  
    37263751                            pTimer->offScheduleNext,
    37273752                            tmR3Get5CharClockName(pTimer->enmClock),
    3728                             TMTimerGet(pTimer),
     3753                            TMTimerGet(pVM, pTimer->hSelf),
    37293754                            pTimer->u64Expire,
    37303755                            pTimer->uHzHint,

  • trunk/src/VBox/VMM/VMMR3/VMM.cpp

    r87765 r87766  
    169169static DECLCALLBACK(int)    vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
    170170static DECLCALLBACK(int)    vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
    171 static DECLCALLBACK(void)   vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);
     171static DECLCALLBACK(void)   vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
    172172static VBOXSTRICTRC         vmmR3EmtRendezvousCommon(PVM pVM, PVMCPU pVCpu, bool fIsCaller,
    173173                                                     uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser);
    … …  
    661661             */
    662662            rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, vmmR3YieldEMT, NULL, TMTIMER_FLAGS_NO_RING0,
    663                                  "EMT Yielder", &pVM->vmm.s.pYieldTimer);
     663                                 "EMT Yielder", &pVM->vmm.s.hYieldTimer);
    664664            AssertRCReturn(rc, rc);
    665665
    666             rc = TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldEveryMillies);
     666            rc = TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldEveryMillies);
    667667            AssertRCReturn(rc, rc);
    668668            break;
    … …  
    998998    if (!pVM->vmm.s.cYieldResumeMillies)
    999999    {
    1000         uint64_t u64Now = TMTimerGet(pVM->vmm.s.pYieldTimer);
    1001         uint64_t u64Expire = TMTimerGetExpire(pVM->vmm.s.pYieldTimer);
     1000        uint64_t u64Now = TMTimerGet(pVM, pVM->vmm.s.hYieldTimer);
     1001        uint64_t u64Expire = TMTimerGetExpire(pVM, pVM->vmm.s.hYieldTimer);
    10021002        if (u64Now >= u64Expire || u64Expire == ~(uint64_t)0)
    10031003            pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
    10041004        else
    1005             pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM->vmm.s.pYieldTimer, u64Expire - u64Now);
    1006         TMTimerStop(pVM->vmm.s.pYieldTimer);
     1005            pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM, pVM->vmm.s.hYieldTimer, u64Expire - u64Now);
     1006        TMTimerStop(pVM, pVM->vmm.s.hYieldTimer);
    10071007    }
    10081008    pVM->vmm.s.u64LastYield = RTTimeNanoTS();
    … …  
    10181018{
    10191019    if (!pVM->vmm.s.cYieldResumeMillies)
    1020         TMTimerStop(pVM->vmm.s.pYieldTimer);
     1020        TMTimerStop(pVM, pVM->vmm.s.hYieldTimer);
    10211021    pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
    10221022    pVM->vmm.s.u64LastYield = RTTimeNanoTS();
    … …  
    10331033    if (pVM->vmm.s.cYieldResumeMillies)
    10341034    {
    1035         TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldResumeMillies);
     1035        TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldResumeMillies);
    10361036        pVM->vmm.s.cYieldResumeMillies = 0;
    10371037    }
    … …  
    10401040
    10411041/**
    1042  * Internal timer callback function.
    1043  *
    1044  * @param   pVM             The cross context VM structure.
    1045  * @param   pTimer          The timer handle.
    1046  * @param   pvUser          User argument specified upon timer creation.
    1047  */
    1048 static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser)
     1042 * @callback_method_impl{FNTMTIMERINT, EMT yielder}
     1043 *
     1044 * @todo This is a UNI core/thread thing, really...   Should be reconsidered.
     1045 */
     1046static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
    10491047{
    10501048    NOREF(pvUser);
    … …  
    10771075#endif
    10781076    }
    1079     TMTimerSetMillies(pTimer, pVM->vmm.s.cYieldEveryMillies);
     1077    TMTimerSetMillies(pVM, hTimer, pVM->vmm.s.cYieldEveryMillies);
    10801078}
    10811079

  • trunk/src/VBox/VMM/include/CPUMInternal.h

    r87361 r87766  
    417417    CPUMCTXMSRS             GuestMsrs;
    418418
    419     /** Nested VMX: VMX-preemption timer - R0 ptr. */
    420     PTMTIMERR0              pNestedVmxPreemptTimerR0;
    421     /** Nested VMX: VMX-preemption timer - R3 ptr. */
    422     PTMTIMERR3              pNestedVmxPreemptTimerR3;
     419    /** Nested VMX: VMX-preemption timer. */
     420    TMTIMERHANDLE           hNestedVmxPreemptTimer;
    423421
    424422    /** Use flags.
    … …  
    459457
    460458    /** Align the next member on a 64-byte boundary. */
    461     uint8_t                 abPadding2[64 - (16 + 12 + 4 + 8 + 1 + 1)];
     459    uint8_t                 abPadding2[64 - (8 + 12 + 4 + 8 + 1 + 1)];
    462460
    463461    /** Saved host context.  Only valid while inside RC or HM contexts.

  • trunk/src/VBox/VMM/include/CPUMInternal.mac

    r87522 r87766  
    259259    ; Other stuff.
    260260    ;
    261     .pNestedVmxPreemptTimerR0   RTR0PTR_RES    1
    262     .pNestedVmxPreemptTimerR3   RTR3PTR_RES    1
     261    .hNestedVmxPreemptTimer   resq    1
    263262
    264263    .fUseFlags            resd    1
    … …  
    275274
    276275    .fCpuIdApicFeatureVisible   resb    1
    277 
    278     .abPadding2           resb    (64 - (RTR0PTR_CB + RTR3PTR_CB + 12 + 4 + RTR0PTR_CB + 1 + 1))
    279276
    280277    ;

  • trunk/src/VBox/VMM/include/GIMHvInternal.h

    r82968 r87766  
    12631263typedef struct GIMHVSTIMER
    12641264{
    1265     /** Synthetic timer object - R0 ptr. */
    1266     PTMTIMERR0                  pTimerR0;
    1267     /** Synthetic timer object - R3 ptr. */
    1268     PTMTIMERR3                  pTimerR3;
     1265    /** Synthetic timer handle. */
     1266    TMTIMERHANDLE               hTimer;
    12691267    /** Virtual CPU ID this timer belongs to (for reverse mapping). */
    12701268    VMCPUID                     idCpu;

  • trunk/src/VBox/VMM/include/PDMAsyncCompletionFileInternal.h

    r85121 r87766  
    277277#ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
    278278    /** Timer for delayed request completion. */
    279     PTMTIMERR3                          pTimer;
     279    TMTIMERHANDLE                       hTimer;
    280280    /** Milliseconds until the next delay expires. */
    281281    volatile uint64_t                   cMilliesNext;

  • trunk/src/VBox/VMM/include/PDMBlkCacheInternal.h

    r82968 r87766  
    134134    volatile bool       fCommitInProgress;
    135135    /** Commit interval timer */
    136     PTMTIMERR3          pTimerCommit;
     136    TMTIMERHANDLE       hTimerCommit;
    137137    /** Number of endpoints using the cache. */
    138138    uint32_t            cRefs;

  • trunk/src/VBox/VMM/include/PDMInternal.h

    r87494 r87766  
    10441044    uint32_t                        cMilliesInterval;
    10451045    /** Interval timer. Only used if cMilliesInterval is non-zero. */
    1046     PTMTIMERR3                      pTimer;
     1046    TMTIMERHANDLE                   hTimer;
    10471047    /** Pointer to the VM - R3. */
    10481048    PVMR3                           pVMR3;

  • trunk/src/VBox/VMM/include/TMInline.h

    r82968 r87766  
    5656}
    5757
     58
     59/** @def TMTIMER_HANDLE_TO_PTR_RETURN_EX
     60 * Converts a timer handle to a timer pointer, returning @a a_rcRet if the
     61 * handle is invalid.
     62 *
     63 * @param   a_pVM       The cross context VM structure.
     64 * @param   a_hTimer    The timer handle to translate.
     65 * @param   a_rcRet     What to return on failure.
     66 * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
     67 */
     68#ifdef IN_RING3
     69# define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \
     70        RT_NOREF(a_pVM); \
     71        (a_pTimerVar) = (PTMTIMER)hTimer; \
     72        AssertPtrReturn((a_pTimerVar), a_rcRet); \
     73        AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \
     74    } while (0)
     75#else
     76# define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \
     77        (a_pTimerVar) = (PTMTIMER)MMHyperR3ToCC(pVM, (RTR3PTR)hTimer); \
     78        AssertPtrReturn((a_pTimerVar), a_rcRet); \
     79        AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \
     80        Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \
     81    } while (0)
     82#endif
     83
     84/** @def TMTIMER_HANDLE_TO_PTR_RETURN
     85 * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if
     86 * invalid.
     87 *
     88 * @param   a_pVM       The cross context VM structure.
     89 * @param   a_hTimer    The timer handle to translate.
     90 * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
     91 */
     92#define TMTIMER_HANDLE_TO_PTR_RETURN(a_pVM, a_hTimer, a_pTimerVar) \
     93        TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, VERR_INVALID_HANDLE, a_pTimerVar)
     94
     95/** @def TMTIMER_HANDLE_TO_PTR_RETURN_VOID
     96 * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if
     97 * invalid.
     98 *
     99 * @param   a_pVM       The cross context VM structure.
     100 * @param   a_hTimer    The timer handle to translate.
     101 * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
     102 */
     103#ifdef IN_RING3
     104# define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \
     105        RT_NOREF(a_pVM); \
     106        (a_pTimerVar) = (PTMTIMER)hTimer; \
     107        AssertPtrReturnVoid((a_pTimerVar)); \
     108        AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \
     109    } while (0)
     110#else
     111# define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \
     112        (a_pTimerVar) = (PTMTIMER)MMHyperR3ToCC(pVM, (RTR3PTR)hTimer); \
     113        AssertPtrReturnVoid((a_pTimerVar)); \
     114        AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \
     115        Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \
     116    } while (0)
     117#endif
     118
     119
    58120#endif /* !VMM_INCLUDED_SRC_include_TMInline_h */
    59121

  • trunk/src/VBox/VMM/include/TMInternal.h

    r87763 r87766  
    174174    int32_t                 offPrev;
    175175
     176    /** It's own handle value. */
     177    TMTIMERHANDLE           hSelf;
    176178    /** Pointer to the VM the timer belongs to - R3 Ptr. */
    177179    PVMR3                   pVMR3;
    … …  
    200202    /** TMTIMER_FLAGS_XXX.   */
    201203    uint32_t                fFlags;
    202     uint32_t                u32Pading;
     204    uint32_t                u32Padding;
    203205
    204206#ifdef VBOX_WITH_STATISTICS

  • trunk/src/VBox/VMM/include/VMMInternal.h

    r85121 r87766  
    193193
    194194    /** The EMT yield timer. */
    195     PTMTIMERR3                  pYieldTimer;
     195    TMTIMERHANDLE               hYieldTimer;
    196196    /** The period to the next timeout when suspended or stopped.
    197197     * This is 0 when running. */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette