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

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/VMMR3

Files:

• CPUM.cpp (modified) (5 diffs)
• GIMHv.cpp (modified) (5 diffs)
• PDMAsyncCompletionFile.cpp (modified) (4 diffs)
• PDMBlkCache.cpp (modified) (6 diffs)
• PDMDevHlp.cpp (modified) (25 diffs)
• PDMDriver.cpp (modified) (1 diff)
• PDMQueue.cpp (modified) (7 diffs)
• PDMUsb.cpp (modified) (25 diffs)
• TM.cpp (modified) (26 diffs)
• VMM.cpp (modified) (7 diffs)

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

@@ -2099 +2099 @@
 
 /**
- * Callback that fires when the nested VMX-preemption timer expired.
- *
- * @param   pVM     The cross context VM structure.
- * @param   pTimer  Pointer to timer.
- * @param   pvUser  Opaque pointer to the virtual-CPU.
- */
-static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
-{
-    RT_NOREF2(pVM, pTimer);
-    Assert(pvUser);
-
+ * @callback_method_impl{FNTMTIMERINT,
+ *  Callback that fires when the nested VMX-preemption timer expired.}
+ */
+static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
+{
+    RT_NOREF(pVM, hTimer);
     PVMCPU pVCpu = (PVMCPUR3)pvUser;
+    AssertPtr(pVCpu);
     VMCPU_FF_SET(pVCpu, VMCPU_FF_VMX_PREEMPT_TIMER);
 }
@@ -2224 +2220 @@
 
         pVCpu->cpum.s.Host.fXStateMask = fXStateHostMask;
+
+        pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE;
     }
 
@@ -2334 +2332 @@
         {
             PVMCPU pVCpu = pVM->apCpusR3[idCpu];
-            int rc = TMR3TimerDestroy(pVCpu->cpum.s.pNestedVmxPreemptTimerR3); AssertRC(rc);
-            pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = NIL_RTR0PTR;
+            if (pVCpu->cpum.s.hNestedVmxPreemptTimer != NIL_TMTIMERHANDLE)
+            {
+                int rc = TMR3TimerDestroy(pVM, pVCpu->cpum.s.hNestedVmxPreemptTimer); AssertRC(rc);
+                pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE;
+            }
         }
 
@@ -4502 +4503 @@
             cpumR3MsrRegStats(pVM);
 
-            /* Create VMX-preemption timer for nested guests if required. */
-/** @todo r=bird: this should be one in CPUMR3Init, not here.   */
+            /* Create VMX-preemption timer for nested guests if required.  Must be
+               done here as CPUM is initialized before TM. */
             if (pVM->cpum.s.GuestFeatures.fVmx)
             {
@@ -4513 +4514 @@
                     char *pszTimerName = MMR3HeapAPrintf(pVM, MM_TAG_CPUM_CTX, "Nested Guest VMX-preempt. timer %u", idCpu);
                     int rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, cpumR3VmxPreemptTimerCallback, pVCpu,
-                                             TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.pNestedVmxPreemptTimerR3);
+                                             TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.hNestedVmxPreemptTimer);
                     AssertLogRelRCReturn(rc, rc);
-                    pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = TMTimerR0Ptr(pVCpu->cpum.s.pNestedVmxPreemptTimerR3);
                 }
             }

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

@@ -187 +187 @@
 static int    gimR3HvInitDebugSupport(PVM pVM);
 static void   gimR3HvTermDebugSupport(PVM pVM);
-static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser);
+static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE pTimer, void *pvUser);
 
 /**
@@ -202 +202 @@
 
     PGIMHV pHv = &pVM->gim.s.u.Hv;
+
+    /*
+     * Initialize timer handles and such.
+     */
+    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
+    {
+        PVMCPU       pVCpu     = pVM->apCpusR3[idCpu];
+        PGIMHVCPU    pHvCpu    = &pVCpu->gim.s.u.HvCpu;
+        for (uint8_t idxStimer = 0; idxStimer < RT_ELEMENTS(pHvCpu->aStimers); idxStimer++)
+            pHvCpu->aStimers[idxStimer].hTimer = NIL_TMTIMERHANDLE;
+    }
 
     /*
@@ -510 +521 @@
                             idxStimer);
                 rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, gimR3HvTimerCallback, pHvStimer /* pvUser */,
-                                     TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->pTimerR3);
+                                     TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->hTimer);
                 AssertLogRelRCReturn(rc, rc);
-                pHvStimer->pTimerR0 = TMTimerR0Ptr(pHvStimer->pTimerR3);
             }
         }
@@ -605 +615 @@
             {
                 PGIMHVSTIMER pHvStimer = &pHvCpu->aStimers[idxStimer];
-                TMR3TimerDestroy(pHvStimer->pTimerR3);
+                TMR3TimerDestroy(pVM, pHvStimer->hTimer);
+                pHvStimer->hTimer = NIL_TMTIMERHANDLE;
             }
         }
@@ -1082 +1093 @@
 
 /**
- * Hyper-V synthetic timer callback.
- *
- * @param   pVM         The cross context VM structure.
- * @param   pTimer      Pointer to timer.
- * @param   pvUser      Pointer to the synthetic timer.
- */
-static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
+ * @callback_method_impl{FNTMTIMERINT, Hyper-V synthetic timer callback.}
+ */
+static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
 {
     PGIMHVSTIMER pHvStimer = (PGIMHVSTIMER)pvUser;
     Assert(pHvStimer);
-    Assert(TMTimerIsLockOwner(pTimer)); RT_NOREF(pTimer);
+    Assert(TMTimerIsLockOwner(pVM, hTimer));
     Assert(pHvStimer->idCpu < pVM->cCpus);
+    Assert(pHvStimer->hTimer == hTimer);
+    RT_NOREF(hTimer);
 
     PVMCPU    pVCpu  = pVM->apCpusR3[pHvStimer->idCpu];

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

@@ -363 +363 @@
                 {
                     ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, tsDelay);
-                    TMTimerSetMillies(pEpClassFile->pTimer, tsDelay);
+                    TMTimerSetMillies(pVM, pEpClassFile->hTimer, tsDelay);
                 }
 
@@ -733 +733 @@
 }
 
-static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
-{
+/**
+ * @callback_method_impl{FNTMTIMERINT, }
+ */
+static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
+{
+    Assert(hTimer == pEpClassFile->hTimer);
     uint64_t tsCur = RTTimeProgramMilliTS();
     uint64_t cMilliesNext = UINT64_MAX;
@@ -784 +788 @@
     {
         ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, cMilliesNext);
-        TMTimerSetMillies(pEpClassFile->pTimer, cMilliesNext);
+        TMTimerSetMillies(pVM, hTimer, cMilliesNext);
     }
 }
@@ -868 +872 @@
 # ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY
     rc = TMR3TimerCreate(pEpClassFile->Core.pVM, TMCLOCK_REAL, pdmacR3TimerCallback, pEpClassFile,
-                         TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile->pTimer);
+                         TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile->hTimer);
     AssertRC(rc);
     pEpClassFile->cMilliesNext = UINT64_MAX;

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

@@ -736 +736 @@
     if (   !(cbDirtyOld - cbCommitted)
         && pBlkCache->pCache->u32CommitTimeoutMs != 0)
-        TMTimerStop(pBlkCache->pCache->pTimerCommit);
+        TMTimerStop(pBlkCache->pCache->pVM, pBlkCache->pCache->hTimerCommit);
 }
 
@@ -808 +808 @@
         {
             /* Arm the commit timer. */
-            TMTimerSetMillies(pCache->pTimerCommit, pCache->u32CommitTimeoutMs);
+            TMTimerSetMillies(pCache->pVM, pCache->hTimerCommit, pCache->u32CommitTimeoutMs);
         }
     }
@@ -833 +833 @@
 
 /**
- * Commit timer callback.
- */
-static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)
+ * @callback_method_impl{FNTMTIMERINT, Commit timer callback.}
+ */
+static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
 {
     PPDMBLKCACHEGLOBAL pCache = (PPDMBLKCACHEGLOBAL)pvUser;
-    NOREF(pVM); NOREF(pTimer);
+    RT_NOREF(pVM, hTimer);
 
     LogFlowFunc(("Commit interval expired, commiting dirty entries\n"));
@@ -1158 +1158 @@
         if (pBlkCacheGlobal->u32CommitTimeoutMs > 0)
             rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmBlkCacheCommitTimerCallback, pBlkCacheGlobal,
-                                 TMTIMER_FLAGS_NO_RING0,  "BlkCache-Commit", &pBlkCacheGlobal->pTimerCommit);
+                                 TMTIMER_FLAGS_NO_RING0,  "BlkCache-Commit", &pBlkCacheGlobal->hTimerCommit);
 
         if (RT_SUCCESS(rc))
@@ -2778 +2778 @@
 VMMR3DECL(int) PDMR3BlkCacheClear(PPDMBLKCACHE pBlkCache)
 {
-    int rc = VINF_SUCCESS;
     PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache;
 
@@ -2796 +2795 @@
 
     pdmBlkCacheLockLeave(pCache);
-    return rc;
-}
-
+    return VINF_SUCCESS;
+}
+

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

@@ -439 +439 @@
         Assert(fFlags & TMTIMER_FLAGS_NO_RING0 /* just to make sure all devices has been considered */);
 
-    PTMTIMER pTimer = NULL;
-    int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
-    *phTimer = (uintptr_t)pTimer;
+    int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
 
     LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     return rc;
-}
-
-
-/** Converts timer handle to pointer (used to exposed, will be replace soon.) */
-DECLINLINE(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
-{
-    PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(pDevIns);
-    return (PTMTIMERR3)hTimer;
 }
 
@@ -460 +449 @@
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
 {
-    return TMTimerFromMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicroSecs);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerFromMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicroSecs);
 }
 
@@ -468 +458 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliSecs);
+    return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, hTimer, cMilliSecs);
 }
 
@@ -475 +465 @@
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
 {
-    return TMTimerFromNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanoSecs);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerFromNano(pDevIns->Internal.s.pVMR3, hTimer, cNanoSecs);
 }
 
@@ -481 +472 @@
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerGet(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -488 +480 @@
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGetFreq(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerGetFreq(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -495 +488 @@
 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerGetNano(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -502 +496 @@
 static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerIsActive(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerIsActive(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -509 +504 @@
 static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerIsLockOwner(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerIsLockOwner(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -516 +512 @@
 static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy)
 {
-    return TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy);
 }
 
@@ -524 +521 @@
                                                               PPDMCRITSECT pCritSect, int rcBusy)
 {
-    VBOXSTRICTRC rc = TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    VBOXSTRICTRC rc = TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy);
     if (rc == VINF_SUCCESS)
     {
@@ -531 +529 @@
             return rc;
         AssertRC(VBOXSTRICTRC_VAL(rc));
-        TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+        TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
     }
     else
@@ -542 +540 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
 {
-    return TMTimerSet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uExpire);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSet(pDevIns->Internal.s.pVMR3, hTimer, uExpire);
 }
 
@@ -549 +548 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz)
 {
-    return TMTimerSetFrequencyHint(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uHz);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSetFrequencyHint(pDevIns->Internal.s.pVMR3, hTimer, uHz);
 }
 
@@ -556 +556 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
 {
-    return TMTimerSetMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicrosToNext);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSetMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicrosToNext);
 }
 
@@ -563 +564 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
 {
-    return TMTimerSetMillies(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliesToNext);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSetMillies(pDevIns->Internal.s.pVMR3, hTimer, cMilliesToNext);
 }
 
@@ -570 +572 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
 {
-    return TMTimerSetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanosToNext);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSetNano(pDevIns->Internal.s.pVMR3, hTimer, cNanosToNext);
 }
 
@@ -577 +580 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
 {
-    return TMTimerSetRelative(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cTicksToNext, pu64Now);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerSetRelative(pDevIns->Internal.s.pVMR3, hTimer, cTicksToNext, pu64Now);
 }
 
@@ -584 +588 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerStop(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMTimerStop(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -591 +596 @@
 static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
 }
 
@@ -598 +604 @@
 static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
 {
-    TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer);
     int rc = PDMCritSectLeave(pCritSect);
     AssertRC(rc);
@@ -607 +614 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
 {
-    return TMR3TimerSetCritSect(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pCritSect);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMR3TimerSetCritSect(pDevIns->Internal.s.pVMR3, hTimer, pCritSect);
 }
 
@@ -614 +622 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
 {
-    return TMR3TimerSave(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMR3TimerSave(pDevIns->Internal.s.pVMR3, hTimer, pSSM);
 }
 
@@ -621 +630 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
 {
-    return TMR3TimerLoad(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM);
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMR3TimerLoad(pDevIns->Internal.s.pVMR3, hTimer, pSSM);
 }
 
@@ -628 +638 @@
 static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)
 {
-    return TMR3TimerDestroy(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer));
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    return TMR3TimerDestroy(pDevIns->Internal.s.pVMR3, hTimer);
 }
 

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

@@ -1337 +1337 @@
         fFlags |= TMTIMER_FLAGS_NO_RING0;
 
-    PTMTIMERR3 pTimer = NULL;
-    int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
-    if (RT_SUCCESS(rc))
-        *phTimer = (TMTIMERHANDLE)pTimer;
+    int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
 
     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

@@ -39 +39 @@
 DECLINLINE(void)            pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem);
 static bool                 pdmR3QueueFlush(PPDMQUEUE pQueue);
-static DECLCALLBACK(void)   pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
+static DECLCALLBACK(void)   pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
 
 
@@ -89 +89 @@
     pQueue->pszName = pszName;
     pQueue->cMilliesInterval = cMilliesInterval;
-    //pQueue->pTimer = NULL;
+    pQueue->hTimer = NIL_TMTIMERHANDLE;
     pQueue->cbItem = (uint32_t)cbItem;
     pQueue->cItems = cItems;
@@ -113 +113 @@
     if (cMilliesInterval)
     {
-        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->pTimer);
+        rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->hTimer);
         if (RT_SUCCESS(rc))
         {
-            rc = TMTimerSetMillies(pQueue->pTimer, cMilliesInterval);
+            rc = TMTimerSetMillies(pVM, pQueue->hTimer, cMilliesInterval);
             if (RT_FAILURE(rc))
             {
                 AssertMsgFailed(("TMTimerSetMillies failed rc=%Rrc\n", rc));
-                int rc2 = TMR3TimerDestroy(pQueue->pTimer); AssertRC(rc2);
+                int rc2 = TMR3TimerDestroy(pVM, pQueue->hTimer); AssertRC(rc2);
             }
         }
@@ -398 +398 @@
      * Unlink it.
      */
-    if (pQueue->pTimer)
+    if (pQueue->hTimer != NIL_TMTIMERHANDLE)
     {
         if (pUVM->pdm.s.pQueuesTimer != pQueue)
@@ -448 +448 @@
      * Destroy the timer and free it.
      */
-    if (pQueue->pTimer)
-    {
-        TMR3TimerDestroy(pQueue->pTimer);
-        pQueue->pTimer = NULL;
+    if (pQueue->hTimer != NIL_TMTIMERHANDLE)
+    {
+        TMR3TimerDestroy(pVM, pQueue->hTimer);
+        pQueue->hTimer = NIL_TMTIMERHANDLE;
     }
     if (pQueue->pVMRC)
@@ -856 +856 @@
 
 /**
- * Timer handler for PDM queues.
- * This is called by for a single queue.
- *
- * @param   pVM     The cross context VM structure.
- * @param   pTimer  Pointer to timer.
- * @param   pvUser  Pointer to the queue.
- */
-static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
+ * @callback_method_impl{FNTMTIMERINT, Timer handler for one PDM queue.}
+ */
+static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
 {
     PPDMQUEUE pQueue = (PPDMQUEUE)pvUser;
-    Assert(pTimer == pQueue->pTimer); NOREF(pTimer); NOREF(pVM);
+    Assert(hTimer == pQueue->hTimer);
 
     if (   pQueue->pPendingR3
@@ -872 +867 @@
         || pQueue->pPendingRC)
         pdmR3QueueFlush(pQueue);
-    int rc = TMTimerSetMillies(pQueue->pTimer, pQueue->cMilliesInterval);
+    int rc = TMTimerSetMillies(pVM, hTimer, pQueue->cMilliesInterval);
     AssertRC(rc);
 }

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

@@ -1833 +1833 @@
         pszDesc = pszDesc2;
 
-    PTMTIMERR3 pTimer = NULL;
-    int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer);
-    if (RT_SUCCESS(rc))
-        *phTimer = (TMTIMERHANDLE)pTimer;
+    int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer);
 
     LogFlow(("pdmR3UsbHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc *phTimer=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc, *phTimer));
@@ -1843 +1840 @@
 
 
-/** Converts timer handle to pointer (will be replace soon.) */
-DECLINLINE(PTMTIMERR3) pdmR3UsbHlp_TimerToPtr(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
-{
-    PDMUSB_ASSERT_USBINS(pUsbIns);
-    RT_NOREF(pUsbIns);
-    return (PTMTIMERR3)hTimer;
-}
-
-
 /** @interface_method_impl{PDMUSBHLP,pfnTimerFromMicro} */
 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs)
 {
-    return TMTimerFromMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicroSecs);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerFromMicro(pUsbIns->Internal.s.pVM, hTimer, cMicroSecs);
 }
 
@@ -1863 +1852 @@
 {
     PDMUSB_ASSERT_USBINS(pUsbIns);
-    return TMTimerFromMilli(pUsbIns->Internal.s.pVM, pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliSecs);
+    return TMTimerFromMilli(pUsbIns->Internal.s.pVM, hTimer, cMilliSecs);
 }
 
@@ -1870 +1859 @@
 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs)
 {
-    return TMTimerFromNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanoSecs);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerFromNano(pUsbIns->Internal.s.pVM, hTimer, cNanoSecs);
 }
 
@@ -1876 +1866 @@
 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerGet(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1883 +1874 @@
 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetFreq(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGetFreq(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerGetFreq(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1890 +1882 @@
 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerGetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerGetNano(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1897 +1890 @@
 static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsActive(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerIsActive(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerIsActive(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1904 +1898 @@
 static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsLockOwner(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerIsLockOwner(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerIsLockOwner(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1911 +1906 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED);
 }
 
@@ -1918 +1914 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
 {
-    int rc = TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    int rc = TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED);
     if (rc == VINF_SUCCESS)
     {
@@ -1925 +1922 @@
             return rc;
         AssertRC(rc);
-        TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+        TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
     }
     else
@@ -1936 +1933 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t uExpire)
 {
-    return TMTimerSet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uExpire);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSet(pUsbIns->Internal.s.pVM, hTimer, uExpire);
 }
 
@@ -1943 +1941 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetFrequencyHint(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint32_t uHz)
 {
-    return TMTimerSetFrequencyHint(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uHz);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSetFrequencyHint(pUsbIns->Internal.s.pVM, hTimer, uHz);
 }
 
@@ -1950 +1949 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext)
 {
-    return TMTimerSetMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicrosToNext);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSetMicro(pUsbIns->Internal.s.pVM, hTimer, cMicrosToNext);
 }
 
@@ -1957 +1957 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMillies(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext)
 {
-    return TMTimerSetMillies(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliesToNext);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSetMillies(pUsbIns->Internal.s.pVM, hTimer, cMilliesToNext);
 }
 
@@ -1964 +1965 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext)
 {
-    return TMTimerSetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanosToNext);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSetNano(pUsbIns->Internal.s.pVM, hTimer, cNanosToNext);
 }
 
@@ -1971 +1973 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetRelative(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now)
 {
-    return TMTimerSetRelative(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cTicksToNext, pu64Now);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerSetRelative(pUsbIns->Internal.s.pVM, hTimer, cTicksToNext, pu64Now);
 }
 
@@ -1978 +1981 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerStop(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMTimerStop(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMTimerStop(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1985 +1989 @@
 static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
 }
 
@@ -1992 +1997 @@
 static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
 {
-    TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer);
     int rc = PDMCritSectLeave(pCritSect);
     AssertRC(rc);
@@ -2001 +2007 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetCritSect(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
 {
-    return TMR3TimerSetCritSect(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pCritSect);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMR3TimerSetCritSect(pUsbIns->Internal.s.pVM, hTimer, pCritSect);
 }
 
@@ -2008 +2015 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSave(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
 {
-    return TMR3TimerSave(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMR3TimerSave(pUsbIns->Internal.s.pVM, hTimer, pSSM);
 }
 
@@ -2015 +2023 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLoad(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
 {
-    return TMR3TimerLoad(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM);
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMR3TimerLoad(pUsbIns->Internal.s.pVM, hTimer, pSSM);
 }
 
@@ -2022 +2031 @@
 static DECLCALLBACK(int) pdmR3UsbHlp_TimerDestroy(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)
 {
-    return TMR3TimerDestroy(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));
+    PDMUSB_ASSERT_USBINS(pUsbIns);
+    return TMR3TimerDestroy(pUsbIns->Internal.s.pVM, hTimer);
 }
 

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

@@ -180 +180 @@
 static DECLCALLBACK(int)    tmR3SetWarpDrive(PUVM pUVM, uint32_t u32Percent);
 #ifndef VBOX_WITHOUT_NS_ACCOUNTING
-static DECLCALLBACK(void)   tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);
+static DECLCALLBACK(void)   tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
 #endif
 static DECLCALLBACK(void)   tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
@@ -1100 +1100 @@
      * Create a timer for refreshing the CPU load stats.
      */
-    PTMTIMER pTimer;
-    rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", &pTimer);
+    TMTIMERHANDLE hTimer;
+    rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", &hTimer);
     if (RT_SUCCESS(rc))
-        rc = TMTimerSetMillies(pTimer, 1000);
+        rc = TMTimerSetMillies(pVM, hTimer, 1000);
 #endif
 
@@ -1542 +1542 @@
     pTimer->u64Expire       = 0;
     pTimer->enmClock        = enmClock;
+    pTimer->hSelf           = (TMTIMERHANDLE)pTimer;
     pTimer->pVMR3           = pVM;
     pTimer->pVMR0           = pVM->pVMR0ForCall; /** @todo fix properly */
@@ -1602 +1603 @@
  * @param   pszDesc         Pointer to description string which must stay around
  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
- * @param   ppTimer         Where to store the timer on success.
+ * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock,
                                         PFNTMTIMERDEV pfnCallback, void *pvUser,
-                                        uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
+                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
@@ -1614 +1615 @@
      * Allocate and init stuff.
      */
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
+    PTMTIMER pTimer;
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     if (RT_SUCCESS(rc))
     {
-        (*ppTimer)->enmType         = TMTIMERTYPE_DEV;
-        (*ppTimer)->u.Dev.pfnTimer  = pfnCallback;
-        (*ppTimer)->u.Dev.pDevIns   = pDevIns;
-        (*ppTimer)->pvUser          = pvUser;
+        pTimer->enmType         = TMTIMERTYPE_DEV;
+        pTimer->u.Dev.pfnTimer  = pfnCallback;
+        pTimer->u.Dev.pDevIns   = pDevIns;
+        pTimer->pvUser          = pvUser;
         if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT))
-            (*ppTimer)->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
-        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
+            pTimer->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns);
+        *phTimer = pTimer->hSelf;
+        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszDesc));
     }
 
@@ -1644 +1647 @@
  * @param   pszDesc         Pointer to description string which must stay around
  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
- * @param   ppTimer         Where to store the timer on success.
+ * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock,
                                      PFNTMTIMERUSB pfnCallback, void *pvUser,
-                                     uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
+                                     uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER);
@@ -1655 +1658 @@
      * Allocate and init stuff.
      */
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
+    PTMTIMER pTimer;
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     if (RT_SUCCESS(rc))
     {
-        (*ppTimer)->enmType         = TMTIMERTYPE_USB;
-        (*ppTimer)->u.Usb.pfnTimer  = pfnCallback;
-        (*ppTimer)->u.Usb.pUsbIns   = pUsbIns;
-        (*ppTimer)->pvUser          = pvUser;
+        pTimer->enmType         = TMTIMERTYPE_USB;
+        pTimer->u.Usb.pfnTimer  = pfnCallback;
+        pTimer->u.Usb.pUsbIns   = pUsbIns;
+        pTimer->pvUser          = pvUser;
         //if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT))
         //{
         //    if (pDevIns->pCritSectR3)
-        //        (*ppTimer)->pCritSect = pUsbIns->pCritSectR3;
+        //        pTimer->pCritSect = pUsbIns->pCritSectR3;
         //    else
-        //        (*ppTimer)->pCritSect = IOMR3GetCritSect(pVM);
+        //        pTimer->pCritSect = IOMR3GetCritSect(pVM);
         //}
-        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
+        *phTimer = pTimer->hSelf;
+        Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
     }
 
@@ -1688 +1693 @@
  * @param   pszDesc         Pointer to description string which must stay around
  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
- * @param   ppTimer         Where to store the timer on success.
+ * @param   phTimer         Where to store the timer handle on success.
  */
 VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser,
-                                        uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
+                                        uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)),
@@ -1699 +1704 @@
      * Allocate and init stuff.
      */
-    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer);
+    PTMTIMER pTimer;
+    int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer);
     if (RT_SUCCESS(rc))
     {
-        (*ppTimer)->enmType         = TMTIMERTYPE_DRV;
-        (*ppTimer)->u.Drv.pfnTimer  = pfnCallback;
-        (*ppTimer)->u.Drv.pDrvIns   = pDrvIns;
-        (*ppTimer)->pvUser          = pvUser;
-        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc));
+        pTimer->enmType         = TMTIMERTYPE_DRV;
+        pTimer->u.Drv.pfnTimer  = pfnCallback;
+        pTimer->u.Drv.pDrvIns   = pDrvIns;
+        pTimer->pvUser          = pvUser;
+        *phTimer = pTimer->hSelf;
+        Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc));
     }
 
@@ -1724 +1731 @@
  * @param   pszDesc         Pointer to description string which must stay around
  *                          until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()).
- * @param   ppTimer         Where to store the timer on success.
+ * @param   phTimer         Where to store the timer handle on success.
  */
 VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser,
-                               uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer)
+                               uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer)
 {
     AssertReturn(fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0), VERR_INVALID_FLAGS);
@@ -1743 +1750 @@
         pTimer->u.Internal.pfnTimer = pfnCallback;
         pTimer->pvUser              = pvUser;
-        *ppTimer = pTimer;
+        *phTimer = pTimer->hSelf;
         Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc));
     }
@@ -1757 +1764 @@
  * @param   pTimer          Timer handle as returned by one of the create functions.
  */
-VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer)
-{
-    /*
-     * Be extra careful here.
-     */
-    if (!pTimer)
-        return VINF_SUCCESS;
-    AssertPtr(pTimer);
+static int tmR3TimerDestroy(PVMCC pVM, PTMTIMER pTimer)
+{
     Assert((unsigned)pTimer->enmClock < (unsigned)TMCLOCK_MAX);
 
-    PVM             pVM      = pTimer->CTX_SUFF(pVM);
     PTMTIMERQUEUE   pQueue   = &pVM->tm.s.CTX_SUFF(paTimerQueues)[pTimer->enmClock];
     bool            fActive  = false;
@@ -1925 +1925 @@
 
 /**
+ * Destroy a timer
+ *
+ * @returns VBox status code.
+ * @param   pVM         The cross context VM structure.
+ * @param   hTimer      Timer handle as returned by one of the create functions.
+ */
+VMMR3DECL(int) TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer)
+{
+    /* We ignore NILs here. */
+    if (hTimer == NIL_TMTIMERHANDLE)
+        return VINF_SUCCESS;
+    PTMTIMER pTimer;
+    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
+    return tmR3TimerDestroy(pVM, pTimer);
+}
+
+
+/**
  * Destroy all timers owned by a device.
  *
@@ -1946 +1964 @@
             &&  pDestroy->u.Dev.pDevIns == pDevIns)
         {
-            int rc = TMR3TimerDestroy(pDestroy);
+            int rc = tmR3TimerDestroy(pVM, pDestroy);
             AssertRC(rc);
         }
@@ -1979 +1997 @@
             &&  pDestroy->u.Usb.pUsbIns == pUsbIns)
         {
-            int rc = TMR3TimerDestroy(pDestroy);
+            int rc = tmR3TimerDestroy(pVM, pDestroy);
             AssertRC(rc);
         }
@@ -2012 +2030 @@
             &&  pDestroy->u.Drv.pDrvIns == pDrvIns)
         {
-            int rc = TMR3TimerDestroy(pDestroy);
+            int rc = tmR3TimerDestroy(pVM, pDestroy);
             AssertRC(rc);
         }
@@ -2288 +2306 @@
                 case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
                 case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
-                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
+                case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
                 default:
                     AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
@@ -2472 +2490 @@
             case TMTIMERTYPE_USB:       pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break;
             case TMTIMERTYPE_DRV:       pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break;
-            case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer, pTimer->pvUser); break;
+            case TMTIMERTYPE_INTERNAL:  pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break;
             default:
                 AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc));
@@ -2696 +2714 @@
  *
  * @returns VBox status code.
- * @param   pTimer          Timer to save.
+ * @param   pVM             The cross context VM structure.
+ * @param   hTimer          Timer to save.
  * @param   pSSM            Save State Manager handle.
  */
-VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
+VMMR3DECL(int) TMR3TimerSave(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
+{
+    VM_ASSERT_EMT(pVM);
+    PTMTIMER pTimer;
+    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
+
     switch (pTimer->enmState)
     {
@@ -2738 +2761 @@
  *
  * @returns VBox status code.
- * @param   pTimer          Timer to restore.
+ * @param   pVM             The cross context VM structure.
+ * @param   hTimer          Handle of Timer to restore.
  * @param   pSSM            Save State Manager handle.
  */
-VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM)
-{
-    Assert(pTimer); Assert(pSSM); VM_ASSERT_EMT(pTimer->pVMR3);
+VMMR3DECL(int) TMR3TimerLoad(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM)
+{
+    VM_ASSERT_EMT(pVM);
+    PTMTIMER pTimer;
+    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
+    Assert(pSSM);
     LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM));
 
@@ -2787 +2814 @@
          */
         Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire));
-        rc = TMTimerSet(pTimer, u64Expire);
+        rc = TMTimerSet(pVM, hTimer, u64Expire);
     }
     else
@@ -2795 +2822 @@
          */
         Log(("u8State=%d\n", u8State));
-        rc = TMTimerStop(pTimer);
+        rc = TMTimerStop(pVM, hTimer);
     }
 
@@ -2887 +2914 @@
  *          active.
  */
-VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect)
-{
-    AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
+VMMR3DECL(int) TMR3TimerSetCritSect(PVM pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect)
+{
+    PTMTIMER pTimer;
+    TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer);
     AssertPtrReturn(pCritSect, VERR_INVALID_PARAMETER);
     const char *pszName = PDMR3CritSectName(pCritSect); /* exploited for validation */
@@ -3414 +3442 @@
 
 /**
- * Timer callback that calculates the CPU load since the last time it was
- * called.
- *
- * @param   pVM                 The cross context VM structure.
- * @param   pTimer              The timer.
- * @param   pvUser              NULL, unused.
- */
-static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser)
+ * @callback_method_impl{FNTMTIMERINT,
+ *      Timer callback that calculates the CPU load since the last
+ *      time it was called.}
+ */
+static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
 {
     /*
      * Re-arm the timer first.
      */
-    int rc = TMTimerSetMillies(pTimer, 1000);
+    int rc = TMTimerSetMillies(pVM, hTimer, 1000);
     AssertLogRelRC(rc);
     NOREF(pvUser);
@@ -3680 +3705 @@
                         pTimer->offScheduleNext,
                         tmR3Get5CharClockName(pTimer->enmClock),
-                        TMTimerGet(pTimer),
+                        TMTimerGet(pVM, pTimer->hSelf),
                         pTimer->u64Expire,
                         pTimer->uHzHint,
@@ -3726 +3751 @@
                             pTimer->offScheduleNext,
                             tmR3Get5CharClockName(pTimer->enmClock),
-                            TMTimerGet(pTimer),
+                            TMTimerGet(pVM, pTimer->hSelf),
                             pTimer->u64Expire,
                             pTimer->uHzHint,

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

@@ -169 +169 @@
 static DECLCALLBACK(int)    vmmR3Save(PVM pVM, PSSMHANDLE pSSM);
 static DECLCALLBACK(int)    vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
-static DECLCALLBACK(void)   vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);
+static DECLCALLBACK(void)   vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser);
 static VBOXSTRICTRC         vmmR3EmtRendezvousCommon(PVM pVM, PVMCPU pVCpu, bool fIsCaller,
                                                      uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser);
@@ -661 +661 @@
              */
             rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, vmmR3YieldEMT, NULL, TMTIMER_FLAGS_NO_RING0,
-                                 "EMT Yielder", &pVM->vmm.s.pYieldTimer);
+                                 "EMT Yielder", &pVM->vmm.s.hYieldTimer);
             AssertRCReturn(rc, rc);
 
-            rc = TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldEveryMillies);
+            rc = TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldEveryMillies);
             AssertRCReturn(rc, rc);
             break;
@@ -998 +998 @@
     if (!pVM->vmm.s.cYieldResumeMillies)
     {
-        uint64_t u64Now = TMTimerGet(pVM->vmm.s.pYieldTimer);
-        uint64_t u64Expire = TMTimerGetExpire(pVM->vmm.s.pYieldTimer);
+        uint64_t u64Now = TMTimerGet(pVM, pVM->vmm.s.hYieldTimer);
+        uint64_t u64Expire = TMTimerGetExpire(pVM, pVM->vmm.s.hYieldTimer);
         if (u64Now >= u64Expire || u64Expire == ~(uint64_t)0)
             pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
         else
-            pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM->vmm.s.pYieldTimer, u64Expire - u64Now);
-        TMTimerStop(pVM->vmm.s.pYieldTimer);
+            pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM, pVM->vmm.s.hYieldTimer, u64Expire - u64Now);
+        TMTimerStop(pVM, pVM->vmm.s.hYieldTimer);
     }
     pVM->vmm.s.u64LastYield = RTTimeNanoTS();
@@ -1018 +1018 @@
 {
     if (!pVM->vmm.s.cYieldResumeMillies)
-        TMTimerStop(pVM->vmm.s.pYieldTimer);
+        TMTimerStop(pVM, pVM->vmm.s.hYieldTimer);
     pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies;
     pVM->vmm.s.u64LastYield = RTTimeNanoTS();
@@ -1033 +1033 @@
     if (pVM->vmm.s.cYieldResumeMillies)
     {
-        TMTimerSetMillies(pVM->vmm.s.pYieldTimer, pVM->vmm.s.cYieldResumeMillies);
+        TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldResumeMillies);
         pVM->vmm.s.cYieldResumeMillies = 0;
     }
@@ -1040 +1040 @@
 
 /**
- * Internal timer callback function.
- *
- * @param   pVM             The cross context VM structure.
- * @param   pTimer          The timer handle.
- * @param   pvUser          User argument specified upon timer creation.
- */
-static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser)
+ * @callback_method_impl{FNTMTIMERINT, EMT yielder}
+ *
+ * @todo This is a UNI core/thread thing, really...   Should be reconsidered.
+ */
+static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)
 {
     NOREF(pvUser);
@@ -1077 +1075 @@
 #endif
     }
-    TMTimerSetMillies(pTimer, pVM->vmm.s.cYieldEveryMillies);
+    TMTimerSetMillies(pVM, hTimer, pVM->vmm.s.cYieldEveryMillies);
 }