VirtualBox

Changeset 87766 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Feb 16, 2021 2:27:43 PM (4 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
142820
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/src/VBox/VMM/VMMAll
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • 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    {
Note: See TracChangeset for help on using the changeset viewer.

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