VirtualBox

Changeset 87813 in vbox


Ignore:
Timestamp:
Feb 19, 2021 9:40:11 PM (4 years ago)
Author:
vboxsync
Message:

VMM/TM: TMTIMER_HANDLE_TO_PTR_RETURN* -> TMTIMER_HANDLE_TO_VARS_RETURN*. bugref:9943

Location:
trunk/src/VBox/VMM
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r87812 r87813  
    11471147VMMDECL(int) TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy)
    11481148{
    1149     PTMTIMER pTimer;
    1150     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    1151     AssertPtr(pTimer);
    1152     AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED);
     1149    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     1150    AssertReturn(idxQueue == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED);
    11531151    return PDMCritSectEnter(&pVM->tm.s.VirtualSyncLock, rcBusy);
    11541152}
    … …  
    11631161VMMDECL(void) TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer)
    11641162{
    1165     PTMTIMER pTimer;
    1166     TMTIMER_HANDLE_TO_PTR_RETURN_VOID(pVM, hTimer, pTimer);
    1167     AssertReturnVoid(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC);
     1163    TMTIMER_HANDLE_TO_VARS_RETURN_VOID(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     1164    AssertReturnVoid(idxQueue == TMCLOCK_VIRTUAL_SYNC);
    11681165    PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock);
    11691166}
    … …  
    11791176VMMDECL(bool) TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer)
    11801177{
    1181     PTMTIMER pTimer;
    1182     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer);
    1183     AssertPtr(pTimer);
    1184     AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, false);
     1178    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, false); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     1179    AssertReturn(idxQueue == TMCLOCK_VIRTUAL_SYNC, false);
    11851180    return PDMCritSectIsOwner(&pVM->tm.s.VirtualSyncLock);
    11861181}
    … …  
    11961191 * @param   u64Expire       The new expire time.
    11971192 * @param   pQueue          Pointer to the shared timer queue data.
    1198  * @param   enmClock        The sanitized clock.
    1199  */
    1200 static int tmTimerSetOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t u64Expire, PTMTIMERQUEUE pQueue, TMCLOCK enmClock)
     1193 * @param   idxQueue        The queue index.
     1194 */
     1195static int tmTimerSetOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t u64Expire, PTMTIMERQUEUE pQueue, uint32_t idxQueue)
    12011196{
    12021197    Assert(pTimer->idxPrev == UINT32_MAX);
    … …  
    12071202     * Calculate and set the expiration time.
    12081203     */
    1209     if (enmClock == TMCLOCK_VIRTUAL_SYNC)
     1204    if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
    12101205    {
    12111206        uint64_t u64Last = ASMAtomicReadU64(&pVM->tm.s.u64VirtualSync);
    … …  
    12201215     * Link the timer into the active list.
    12211216     */
    1222     tmTimerQueueLinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, enmClock, pQueue), pQueue, pTimer, u64Expire);
     1217    tmTimerQueueLinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, idxQueue, pQueue), pQueue, pTimer, u64Expire);
    12231218
    12241219    STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetOpt);
    … …  
    13091304VMMDECL(int) TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire)
    13101305{
    1311     PTMTIMER pTimer;
    1312     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     1306    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    13131307    STAM_COUNTER_INC(&pTimer->StatSetAbsolute);
    13141308
    13151309    /* Treat virtual sync timers specially. */
    1316     if (pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC)
     1310    if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
    13171311        return tmTimerVirtualSyncSet(pVM, pTimer, u64Expire);
    13181312
    … …  
    13411335#endif
    13421336
     1337#if 1
    13431338    /*
    13441339     * The most common case is setting the timer again during the callback.
    13451340     * The second most common case is starting a timer at some other time.
    13461341     */
    1347 #if 1
    13481342    TMTIMERSTATE enmState1 = pTimer->enmState;
    13491343    if (    enmState1 == TMTIMERSTATE_EXPIRED_DELIVER
    … …  
    13521346    {
    13531347        /* Try take the TM lock and check the state again. */
    1354         TMCLOCK const       enmClock = pTimer->enmClock;
    1355         AssertReturn((unsigned)enmClock < TMCLOCK_MAX, VERR_TM_IPE_2);
    1356         PTMTIMERQUEUE const pQueue   = &pVM->tm.s.aTimerQueues[enmClock];
    1357 
    13581348        int rc = PDMCritSectTryEnter(&pQueue->TimerLock);
    13591349        if (RT_SUCCESS_NP(rc))
    … …  
    13611351            if (RT_LIKELY(tmTimerTry(pTimer, TMTIMERSTATE_ACTIVE, enmState1)))
    13621352            {
    1363                 tmTimerSetOptimizedStart(pVM, pTimer, u64Expire, pQueue, enmClock);
     1353                tmTimerSetOptimizedStart(pVM, pTimer, u64Expire, pQueue, idxQueue);
    13641354                STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSet), a);
    13651355                PDMCritSectLeave(&pQueue->TimerLock);
    … …  
    15091499 *                          Optional.
    15101500 * @param   pQueue          Pointer to the shared timer queue data.
    1511  * @param   enmClock        The sanitized clock.
     1501 * @param   idxQueue        The queue index.
    15121502 */
    15131503static int tmTimerSetRelativeOptimizedStart(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now,
    1514                                             PTMTIMERQUEUE pQueue, TMCLOCK enmClock)
     1504                                            PTMTIMERQUEUE pQueue, uint32_t idxQueue)
    15151505{
    15161506    Assert(pTimer->idxPrev == UINT32_MAX);
    … …  
    15211511     * Calculate and set the expiration time.
    15221512     */
    1523     uint64_t const  u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1513    uint64_t const  u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    15241514    pTimer->u64Expire         = u64Expire;
    15251515    Log2(("tmTimerSetRelativeOptimizedStart: %p:{.pszDesc='%s', .u64Expire=%'RU64} cTicksToNext=%'RU64\n", pTimer, pTimer->szName, u64Expire, cTicksToNext));
    … …  
    15291519     */
    15301520    DBGFTRACE_U64_TAG2(pVM, u64Expire, "tmTimerSetRelativeOptimizedStart", pTimer->szName);
    1531     tmTimerQueueLinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, enmClock, pQueue), pQueue, pTimer, u64Expire);
     1521    tmTimerQueueLinkActive(pVM, TM_GET_TIMER_QUEUE_CC(pVM, idxQueue, pQueue), pQueue, pTimer, u64Expire);
    15321522
    15331523    STAM_COUNTER_INC(&pVM->tm.s.StatTimerSetRelativeOpt);
     1524    RT_NOREF(idxQueue);
    15341525    return VINF_SUCCESS;
    15351526}
    … …  
    16241615 *                          Optional.
    16251616 */
    1626 static int tmTimerSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
     1617static int tmTimerSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now,
     1618                              PTMTIMERQUEUE pQueue, uint32_t idxQueue)
    16271619{
    16281620    STAM_COUNTER_INC(&pTimer->StatSetRelative);
    16291621
    16301622    /* Treat virtual sync timers specially. */
    1631     TMCLOCK enmClock = pTimer->enmClock;
    1632     if (enmClock == TMCLOCK_VIRTUAL_SYNC)
     1623    if (idxQueue == TMCLOCK_VIRTUAL_SYNC)
    16331624        return tmTimerVirtualSyncSetRelative(pVM, pTimer, cTicksToNext, pu64Now);
    1634     AssertReturn((unsigned)enmClock < (unsigned)TMCLOCK_MAX, VERR_TM_IPE_2);
    16351625
    16361626    STAM_PROFILE_START(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelative), a);
    … …  
    16681658     * longer as this isn't supported for any timers, critsect or not.)
    16691659     *
    1670      * Note! Lock ordering doesn't apply when we only tries to
     1660     * Note! Lock ordering doesn't apply when we only _try_ to
    16711661     *       get the innermost locks.
    16721662     */
    1673     PTMTIMERQUEUE pQueue = &pVM->tm.s.aTimerQueues[enmClock];
    16741663    bool fOwnTMLock = RT_SUCCESS_NP(PDMCritSectTryEnter(&pQueue->TimerLock));
    16751664#if 1
    … …  
    16821671                      && tmTimerTry(pTimer, TMTIMERSTATE_ACTIVE, enmState)))
    16831672        {
    1684             tmTimerSetRelativeOptimizedStart(pVM, pTimer, cTicksToNext, pu64Now, pQueue, enmClock);
     1673            tmTimerSetRelativeOptimizedStart(pVM, pTimer, cTicksToNext, pu64Now, pQueue, idxQueue);
    16851674            STAM_PROFILE_STOP(&pVM->tm.s.CTX_SUFF_Z(StatTimerSetRelative), a);
    16861675            PDMCritSectLeave(&pQueue->TimerLock);
    … …  
    17051694        {
    17061695            case TMTIMERSTATE_STOPPED:
    1707                 if (enmClock == TMCLOCK_VIRTUAL_SYNC)
     1696                if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
    17081697                {
    17091698                    /** @todo To fix assertion in tmR3TimerQueueRunVirtualSync:
    … …  
    17191708                    Assert(pTimer->idxPrev == UINT32_MAX);
    17201709                    Assert(pTimer->idxNext == UINT32_MAX);
    1721                     pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1710                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    17221711                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [EXP/STOP]\n",
    17231712                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    … …  
    17341723                if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_SCHEDULE_SET_EXPIRE, enmState))
    17351724                {
    1736                     pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1725                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    17371726                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_SCHED]\n",
    17381727                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    … …  
    17491738                if (tmTimerTryWithLink(pVM, pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
    17501739                {
    1751                     pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1740                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    17521741                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [ACTIVE]\n",
    17531742                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    … …  
    17641753                if (tmTimerTry(pTimer, TMTIMERSTATE_PENDING_RESCHEDULE_SET_EXPIRE, enmState))
    17651754                {
    1766                     pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1755                    pTimer->u64Expire = cTicksToNext + tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    17671756                    Log2(("TMTimerSetRelative: %p:{.enmState=%s, .pszDesc='%s', .u64Expire=%'RU64} cRetries=%d [PEND_RESCH/STOP]\n",
    17681757                          pTimer, tmTimerState(enmState), pTimer->szName, pTimer->u64Expire, cRetries));
    … …  
    18091798        if (rc != VERR_TRY_AGAIN)
    18101799        {
    1811             tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1800            tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    18121801            break;
    18131802        }
    … …  
    18161805            AssertMsgFailed(("Failed waiting for stable state. state=%d (%s)\n", pTimer->enmState, pTimer->szName));
    18171806            rc = VERR_TM_TIMER_UNSTABLE_STATE;
    1818             tmTimerSetRelativeNowWorker(pVM, enmClock, pu64Now);
     1807            tmTimerSetRelativeNowWorker(pVM, pQueue->enmClock, pu64Now);
    18191808            break;
    18201809        }
    … …  
    18511840VMMDECL(int) TMTimerSetRelative(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
    18521841{
    1853     PTMTIMER pTimer;
    1854     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    1855     return tmTimerSetRelative(pVM, pTimer, cTicksToNext, pu64Now);
     1842    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     1843    return tmTimerSetRelative(pVM, pTimer, cTicksToNext, pu64Now, pQueue, idxQueue);
    18561844}
    18571845
    … …  
    20832071VMMDECL(uint64_t) TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer)
    20842072{
    2085     PTMTIMER pTimer;
    2086     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer);
     2073    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    20872074    STAM_COUNTER_INC(&pTimer->StatGet);
    20882075
    20892076    uint64_t u64;
    2090     switch (pTimer->enmClock)
     2077    switch (pQueue->enmClock)
    20912078    {
    20922079        case TMCLOCK_VIRTUAL:
    … …  
    21002087            break;
    21012088        default:
    2102             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2089            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    21032090            return UINT64_MAX;
    21042091    }
    … …  
    21182105VMMDECL(uint64_t) TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer)
    21192106{
    2120     PTMTIMER pTimer;
    2121     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2122     switch (pTimer->enmClock)
     2107    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2108    switch (pQueue->enmClock)
    21232109    {
    21242110        case TMCLOCK_VIRTUAL:
    … …  
    21302116
    21312117        default:
    2132             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2118            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    21332119            return 0;
    21342120    }
    … …  
    21462132VMMDECL(uint64_t) TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer)
    21472133{
    2148     PTMTIMER pTimer;
    2149     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer);
     2134    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, UINT64_MAX); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    21502135    TMTIMER_ASSERT_CRITSECT(pVM, pTimer);
    21512136    int cRetries = 1000;
    21522137    do
    21532138    {
    2154         TMTIMERSTATE    enmState = pTimer->enmState;
     2139        TMTIMERSTATE enmState = pTimer->enmState;
    21552140        switch (enmState)
    21562141        {
    … …  
    22112196VMMDECL(bool) TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer)
    22122197{
    2213     PTMTIMER pTimer;
    2214     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer);
     2198    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, false); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    22152199    TMTIMERSTATE enmState = pTimer->enmState;
    22162200    switch (enmState)
    … …  
    22632247VMMDECL(int) TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext)
    22642248{
    2265     PTMTIMER pTimer;
    2266     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    2267     switch (pTimer->enmClock)
     2249    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2250    switch (pQueue->enmClock)
    22682251    {
    22692252        case TMCLOCK_VIRTUAL:
    22702253            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2271             return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
     2254            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL, pQueue, idxQueue);
    22722255
    22732256        case TMCLOCK_VIRTUAL_SYNC:
    22742257            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2275             return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL);
     2258            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL, pQueue, idxQueue);
    22762259
    22772260        case TMCLOCK_REAL:
    22782261            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2279             return tmTimerSetRelative(pVM, pTimer, cMilliesToNext, NULL);
     2262            return tmTimerSetRelative(pVM, pTimer, cMilliesToNext, NULL, pQueue, idxQueue);
    22802263
    22812264        default:
    2282             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2265            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    22832266            return VERR_TM_TIMER_BAD_CLOCK;
    22842267    }
    … …  
    22962279VMMDECL(int) TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
    22972280{
    2298     PTMTIMER pTimer;
    2299     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    2300     switch (pTimer->enmClock)
     2281    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2282    switch (pQueue->enmClock)
    23012283    {
    23022284        case TMCLOCK_VIRTUAL:
    23032285            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2304             return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL);
     2286            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL, pQueue, idxQueue);
    23052287
    23062288        case TMCLOCK_VIRTUAL_SYNC:
    23072289            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2308             return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL);
     2290            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL, pQueue, idxQueue);
    23092291
    23102292        case TMCLOCK_REAL:
    23112293            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2312             return tmTimerSetRelative(pVM, pTimer, cMicrosToNext / 1000, NULL);
     2294            return tmTimerSetRelative(pVM, pTimer, cMicrosToNext / 1000, NULL, pQueue, idxQueue);
    23132295
    23142296        default:
    2315             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2297            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    23162298            return VERR_TM_TIMER_BAD_CLOCK;
    23172299    }
    … …  
    23292311VMMDECL(int) TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
    23302312{
    2331     PTMTIMER pTimer;
    2332     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     2313    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    23332314    switch (pTimer->enmClock)
    23342315    {
    23352316        case TMCLOCK_VIRTUAL:
    23362317            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2337             return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL);
     2318            return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL, pQueue, idxQueue);
    23382319
    23392320        case TMCLOCK_VIRTUAL_SYNC:
    23402321            AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000);
    2341             return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL);
     2322            return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL, pQueue, idxQueue);
    23422323
    23432324        case TMCLOCK_REAL:
    23442325            AssertCompile(TMCLOCK_FREQ_REAL == 1000);
    2345             return tmTimerSetRelative(pVM, pTimer, cNanosToNext / 1000000, NULL);
     2326            return tmTimerSetRelative(pVM, pTimer, cNanosToNext / 1000000, NULL, pQueue, idxQueue);
    23462327
    23472328        default:
    … …  
    24032384VMMDECL(uint64_t) TMTimerToNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
    24042385{
    2405     PTMTIMER pTimer;
    2406     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2407     switch (pTimer->enmClock)
     2386    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2387    switch (pQueue->enmClock)
    24082388    {
    24092389        case TMCLOCK_VIRTUAL:
    … …  
    24172397
    24182398        default:
    2419             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2399            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    24202400            return 0;
    24212401    }
    … …  
    24352415VMMDECL(uint64_t) TMTimerToMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
    24362416{
    2437     PTMTIMER pTimer;
    2438     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2439     switch (pTimer->enmClock)
     2417    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2418    switch (pQueue->enmClock)
    24402419    {
    24412420        case TMCLOCK_VIRTUAL:
    … …  
    24492428
    24502429        default:
    2451             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2430            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    24522431            return 0;
    24532432    }
    … …  
    24672446VMMDECL(uint64_t) TMTimerToMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks)
    24682447{
    2469     PTMTIMER pTimer;
    2470     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2471     switch (pTimer->enmClock)
     2448    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2449    switch (pQueue->enmClock)
    24722450    {
    24732451        case TMCLOCK_VIRTUAL:
    … …  
    24812459
    24822460        default:
    2483             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2461            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    24842462            return 0;
    24852463    }
    … …  
    24982476VMMDECL(uint64_t) TMTimerFromNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
    24992477{
    2500     PTMTIMER pTimer;
    2501     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2502     switch (pTimer->enmClock)
     2478    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2479    switch (pQueue->enmClock)
    25032480    {
    25042481        case TMCLOCK_VIRTUAL:
    … …  
    25122489
    25132490        default:
    2514             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2491            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    25152492            return 0;
    25162493    }
    … …  
    25292506VMMDECL(uint64_t) TMTimerFromMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
    25302507{
    2531     PTMTIMER pTimer;
    2532     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2533     switch (pTimer->enmClock)
     2508    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2509    switch (pQueue->enmClock)
    25342510    {
    25352511        case TMCLOCK_VIRTUAL:
    … …  
    25432519
    25442520        default:
    2545             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2521            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    25462522            return 0;
    25472523    }
    … …  
    25602536VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMilliSecs)
    25612537{
    2562     PTMTIMER pTimer;
    2563     TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer);
    2564     switch (pTimer->enmClock)
     2538    TMTIMER_HANDLE_TO_VARS_RETURN_EX(pVM, hTimer, 0); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2539    switch (pQueue->enmClock)
    25652540    {
    25662541        case TMCLOCK_VIRTUAL:
    … …  
    25742549
    25752550        default:
    2576             AssertMsgFailed(("Invalid enmClock=%d\n", pTimer->enmClock));
     2551            AssertMsgFailed(("Invalid enmClock=%d\n", pQueue->enmClock));
    25772552            return 0;
    25782553    }

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

    r87812 r87813  
    18831883 * @returns VBox status code.
    18841884 * @param   pVM             The cross context VM structure.
     1885 * @param   pQueue          The queue the timer is on.
    18851886 * @param   pTimer          Timer handle as returned by one of the create functions.
    18861887 */
    1887 static int tmR3TimerDestroy(PVMCC pVM, PTMTIMER pTimer)
    1888 {
    1889     AssertReturn((unsigned)pTimer->enmClock < (unsigned)TMCLOCK_MAX, VERR_INTERNAL_ERROR_3);
    1890 
    1891     PTMTIMERQUEUE   pQueue   = &pVM->tm.s.aTimerQueues[pTimer->enmClock];
    1892     bool            fActive  = false;
    1893     bool            fPending = false;
     1888static int tmR3TimerDestroy(PVMCC pVM, PTMTIMERQUEUE pQueue, PTMTIMER pTimer)
     1889{
     1890    bool fActive  = false;
     1891    bool fPending = false;
    18941892
    18951893    AssertMsg(   !pTimer->pCritSect
    … …  
    20592057    if (hTimer == NIL_TMTIMERHANDLE)
    20602058        return VINF_SUCCESS;
    2061     PTMTIMER pTimer;
    2062     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
    2063     return tmR3TimerDestroy(pVM, pTimer);
     2059    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
     2060    return tmR3TimerDestroy(pVM, pQueue, pTimer);
    20642061}
    20652062
    … …  
    20922089                PDMCritSectRwLeaveShared(&pQueue->AllocLock);
    20932090
    2094                 int rc = tmR3TimerDestroy(pVM, pTimer);
     2091                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    20952092                AssertRC(rc);
    20962093
    … …  
    21332130                PDMCritSectRwLeaveShared(&pQueue->AllocLock);
    21342131
    2135                 int rc = tmR3TimerDestroy(pVM, pTimer);
     2132                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    21362133                AssertRC(rc);
    21372134
    … …  
    21742171                PDMCritSectRwLeaveShared(&pQueue->AllocLock);
    21752172
    2176                 int rc = tmR3TimerDestroy(pVM, pTimer);
     2173                int rc = tmR3TimerDestroy(pVM, pQueue, pTimer);
    21772174                AssertRC(rc);
    21782175
    … …  
    28832880{
    28842881    VM_ASSERT_EMT(pVM);
    2885     PTMTIMER pTimer;
    2886     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     2882    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    28872883    LogFlow(("TMR3TimerSave: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
    28882884
    … …  
    29312927{
    29322928    VM_ASSERT_EMT(pVM);
    2933     PTMTIMER pTimer;
    2934     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     2929    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    29352930    Assert(pSSM);
    29362931    LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .szName='%s'} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->szName, pSSM));
    … …  
    29572952
    29582953    /* Enter the critical sections to make TMTimerSet/Stop happy. */
    2959     if (pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC)
     2954    if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
    29602955        PDMCritSectEnter(&pVM->tm.s.VirtualSyncLock, VERR_IGNORED);
    29612956    PPDMCRITSECT pCritSect = pTimer->pCritSect;
    … …  
    29902985    if (pCritSect)
    29912986        PDMCritSectLeave(pCritSect);
    2992     if (pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC)
     2987    if (pQueue->enmClock == TMCLOCK_VIRTUAL_SYNC)
    29932988        PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock);
    29942989
    … …  
    30803075VMMR3DECL(int) TMR3TimerSetCritSect(PVM pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
    30813076{
    3082     PTMTIMER pTimer;
    3083     TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     3077    TMTIMER_HANDLE_TO_VARS_RETURN(pVM, hTimer); /* => pTimer, pQueueCC, pQueue, idxTimer, idxQueue */
    30843078    AssertPtrReturn(pCritSect, VERR_INVALID_PARAMETER);
    30853079    const char *pszName = PDMR3CritSectName(pCritSect); /* exploited for validation */

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

    r87812 r87813  
    211211#endif
    212212
    213 
    214213/** @def TMTIMER_HANDLE_TO_VARS_RETURN_EX
    215214 * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if
    … …  
    230229#define TMTIMER_HANDLE_TO_VARS_RETURN(a_pVM, a_hTimer) TMTIMER_HANDLE_TO_VARS_RETURN_EX(a_pVM, a_hTimer, VERR_INVALID_HANDLE)
    231230
    232 
    233 /** @def TMTIMER_HANDLE_TO_PTR_RETURN_EX
    234  * Converts a timer handle to a timer pointer, returning @a a_rcRet if the
     231/** @def TMTIMER_HANDLE_TO_VARS_RETURN_VOID
     232 * Converts a timer handle to a timer pointer, returning void if the
    235233 * handle is invalid.
    236234 *
    237  * @param   a_pVM       The cross context VM structure.
    238  * @param   a_hTimer    The timer handle to translate.
    239  * @param   a_rcRet     What to return on failure.
    240  * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
     235 * This defines the following variables:
     236 *      - idxQueue: The queue index.
     237 *      - pQueueCC: Pointer to the context specific queue data.
     238 *      - pTimer:   The timer pointer.
     239 *      - idxTimer: The timer index.
     240 *
     241 * @param   a_pVM           The cross context VM structure.
     242 * @param   a_hTimer        The timer handle to translate.
     243 *
     244 * @note    This macro has no scoping, so careful when using it around
     245 *          conditional statements!
    241246 */
    242247#ifdef IN_RING3
    243 # define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \
    244         uintptr_t const idxQueue = (uintptr_t)((a_hTimer) >> TMTIMERHANDLE_QUEUE_IDX_SHIFT) \
    245                                  & (uintptr_t)TMTIMERHANDLE_QUEUE_IDX_SMASK; \
    246         AssertReturn(idxQueue < RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues), a_rcRet); \
    247         \
    248         uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
    249         AssertReturn(idxQueue < (a_pVM)->tm.s.aTimerQueues[idxQueue].cTimersAlloc, a_rcRet); \
    250         \
    251         (a_pTimerVar) = &(a_pVM)->tm.s.aTimerQueues[idxQueue].paTimers[idxTimer]; \
    252         AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \
    253     } while (0)
    254 #else
    255 # define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \
    256         uintptr_t const idxQueue = (uintptr_t)((a_hTimer) >> TMTIMERHANDLE_QUEUE_IDX_SHIFT) \
    257                                  & (uintptr_t)TMTIMERHANDLE_QUEUE_IDX_SMASK; \
    258         AssertReturn(idxQueue < RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues), a_rcRet); \
    259         AssertCompile(RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues) == RT_ELEMENTS((a_pVM)->tmr0.s.aTimerQueues)); \
    260         \
    261         uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
    262         AssertReturn(idxQueue < (a_pVM)->tmr0.s.aTimerQueues[idxQueue].cTimersAlloc, a_rcRet); \
    263         \
    264         (a_pTimerVar) = &(a_pVM)->tmr0.s.aTimerQueues[idxQueue].paTimers[idxTimer]; \
    265         AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \
    266         Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \
    267         Assert(VM_IS_EMT(pVM)); \
    268     } while (0)
    269 #endif
    270 
    271 /** @def TMTIMER_HANDLE_TO_PTR_RETURN
    272  * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if
    273  * invalid.
    274  *
    275  * @param   a_pVM       The cross context VM structure.
    276  * @param   a_hTimer    The timer handle to translate.
    277  * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
    278  */
    279 #define TMTIMER_HANDLE_TO_PTR_RETURN(a_pVM, a_hTimer, a_pTimerVar) \
    280         TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, VERR_INVALID_HANDLE, a_pTimerVar)
    281 
    282 /** @def TMTIMER_HANDLE_TO_PTR_RETURN_VOID
    283  * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if
    284  * invalid.
    285  *
    286  * @param   a_pVM       The cross context VM structure.
    287  * @param   a_hTimer    The timer handle to translate.
    288  * @param   a_pTimerVar The timer variable to assign the resulting pointer to.
    289  */
    290 #ifdef IN_RING3
    291 # define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \
     248# define TMTIMER_HANDLE_TO_VARS_RETURN_VOID(a_pVM, a_hTimer) \
    292249        uintptr_t const idxQueue = (uintptr_t)((a_hTimer) >> TMTIMERHANDLE_QUEUE_IDX_SHIFT) \
    293250                                 & (uintptr_t)TMTIMERHANDLE_QUEUE_IDX_SMASK; \
    294251        AssertReturnVoid(idxQueue < RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues)); \
    295         \
    296         uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
    297         AssertReturnVoid(idxQueue < (a_pVM)->tm.s.aTimerQueues[idxQueue].cTimersAlloc); \
    298         \
    299         (a_pTimerVar) = &(a_pVM)->tm.s.aTimerQueues[idxQueue].paTimers[idxTimer]; \
    300         AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \
    301     } while (0)
    302 #else
    303 # define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \
     252        PTMTIMERQUEUE const pQueue = &(a_pVM)->tm.s.aTimerQueues[idxQueue]; \
     253        PTMTIMERQUEUE const pQueueCC = pQueue; RT_NOREF(pQueueCC); \
     254        \
     255        uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
     256        AssertReturnVoid(idxQueue < pQueue->cTimersAlloc); \
     257        \
     258        PTMTIMER const pTimer = &pQueue->paTimers[idxTimer]; \
     259        AssertReturnVoid(pTimer->hSelf == a_hTimer)
     260#else
     261# define TMTIMER_HANDLE_TO_VARS_RETURN_VOID(a_pVM, a_hTimer) \
    304262        uintptr_t const idxQueue = (uintptr_t)((a_hTimer) >> TMTIMERHANDLE_QUEUE_IDX_SHIFT) \
    305263                                 & (uintptr_t)TMTIMERHANDLE_QUEUE_IDX_SMASK; \
    306264        AssertReturnVoid(idxQueue < RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues)); \
    307265        AssertCompile(RT_ELEMENTS((a_pVM)->tm.s.aTimerQueues) == RT_ELEMENTS((a_pVM)->tmr0.s.aTimerQueues)); \
    308         \
    309         uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
    310         AssertReturnVoid(idxQueue < (a_pVM)->tmr0.s.aTimerQueues[idxQueue].cTimersAlloc); \
    311         \
    312         (a_pTimerVar) = &(a_pVM)->tmr0.s.aTimerQueues[idxQueue].paTimers[idxTimer]; \
    313         AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \
    314         Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \
    315         Assert(VM_IS_EMT(pVM)); \
    316     } while (0)
    317 #endif
    318 
     266        PTMTIMERQUEUE const   pQueue   = &(a_pVM)->tm.s.aTimerQueues[idxQueue]; RT_NOREF(pQueue); \
     267        PTMTIMERQUEUER0 const pQueueCC = &(a_pVM)->tmr0.s.aTimerQueues[idxQueue]; \
     268        \
     269        uintptr_t const idxTimer = (uintptr_t)((a_hTimer) & TMTIMERHANDLE_TIMER_IDX_MASK); \
     270        AssertReturnVoid(idxQueue < pQueueCC->cTimersAlloc); \
     271        \
     272        PTMTIMER const pTimer = &pQueueCC->paTimers[idxTimer]; \
     273        AssertReturnVoid(pTimer->hSelf == a_hTimer); \
     274        Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); \
     275        Assert(VM_IS_EMT(pVM))
     276#endif
    319277
    320278#endif /* !VMM_INCLUDED_SRC_include_TMInline_h */

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

    r87812 r87813  
    285285    /** Align on 64-byte boundrary. */
    286286    bool                    afAlignment1[7];
     287
    287288    /** Time spent doing scheduling and timer callbacks. */
    288289    STAMPROFILE             StatDo;
    … …  
    290291    uint32_t volatile       uMaxHzHint;
    291292    uint32_t                u64Alignment2[7];
     293
    292294    /** Lock serializing the active timer list and associated work. */
    293295    PDMCRITSECT             TimerLock;
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