- Timestamp:
- Feb 16, 2021 2:27:43 PM (4 years ago)
- Location:
- trunk
- Files:
-
- 26 edited
-
include/VBox/vmm/tm.h (modified) (3 diffs)
-
src/VBox/Devices/VMMDev/VMMDev.cpp (modified) (1 diff)
-
src/VBox/VMM/VMMAll/CPUMAllRegs.cpp (modified) (2 diffs)
-
src/VBox/VMM/VMMAll/GIMAllHv.cpp (modified) (9 diffs)
-
src/VBox/VMM/VMMAll/PDMAllQueue.cpp (modified) (1 diff)
-
src/VBox/VMM/VMMAll/TMAll.cpp (modified) (32 diffs)
-
src/VBox/VMM/VMMR0/PDMR0DevHlp.cpp (modified) (20 diffs)
-
src/VBox/VMM/VMMR3/CPUM.cpp (modified) (5 diffs)
-
src/VBox/VMM/VMMR3/GIMHv.cpp (modified) (5 diffs)
-
src/VBox/VMM/VMMR3/PDMAsyncCompletionFile.cpp (modified) (4 diffs)
-
src/VBox/VMM/VMMR3/PDMBlkCache.cpp (modified) (6 diffs)
-
src/VBox/VMM/VMMR3/PDMDevHlp.cpp (modified) (25 diffs)
-
src/VBox/VMM/VMMR3/PDMDriver.cpp (modified) (1 diff)
-
src/VBox/VMM/VMMR3/PDMQueue.cpp (modified) (7 diffs)
-
src/VBox/VMM/VMMR3/PDMUsb.cpp (modified) (25 diffs)
-
src/VBox/VMM/VMMR3/TM.cpp (modified) (26 diffs)
-
src/VBox/VMM/VMMR3/VMM.cpp (modified) (7 diffs)
-
src/VBox/VMM/include/CPUMInternal.h (modified) (2 diffs)
-
src/VBox/VMM/include/CPUMInternal.mac (modified) (2 diffs)
-
src/VBox/VMM/include/GIMHvInternal.h (modified) (1 diff)
-
src/VBox/VMM/include/PDMAsyncCompletionFileInternal.h (modified) (1 diff)
-
src/VBox/VMM/include/PDMBlkCacheInternal.h (modified) (1 diff)
-
src/VBox/VMM/include/PDMInternal.h (modified) (1 diff)
-
src/VBox/VMM/include/TMInline.h (modified) (1 diff)
-
src/VBox/VMM/include/TMInternal.h (modified) (2 diffs)
-
src/VBox/VMM/include/VMMInternal.h (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/include/VBox/vmm/tm.h
r87765 r87766 215 215 * 216 216 * @param pVM The cross context VM structure. 217 * @param pTimer The timer handle.217 * @param hTimer The timer handle. 218 218 * @param pvUser User argument specified upon timer creation. 219 219 */ 220 typedef DECLCALLBACKTYPE(void, FNTMTIMERINT,(PVM pVM, PTMTIMER pTimer, void *pvUser));220 typedef DECLCALLBACKTYPE(void, FNTMTIMERINT,(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser)); 221 221 /** Pointer to internal timer callback function. */ 222 222 typedef FNTMTIMERINT *PFNTMTIMERINT; … … 231 231 typedef FNTMTIMEREXT *PFNTMTIMEREXT; 232 232 233 VMMDECL(PTMTIMERR3) TMTimerR3Ptr(PTMTIMER pTimer); 234 VMMDECL(PTMTIMERR0) TMTimerR0Ptr(PTMTIMER pTimer); 235 VMMDECL(PTMTIMERRC) TMTimerRCPtr(PTMTIMER pTimer); 236 VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy); 237 VMMDECL(void) TMTimerUnlock(PTMTIMER pTimer); 238 VMMDECL(bool) TMTimerIsLockOwner(PTMTIMER pTimer); 239 VMMDECL(int) TMTimerSet(PTMTIMER pTimer, uint64_t u64Expire); 240 VMMDECL(int) TMTimerSetRelative(PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now); 241 VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHz); 242 VMMDECL(uint64_t) TMTimerGet(PTMTIMER pTimer); 243 VMMDECL(int) TMTimerStop(PTMTIMER pTimer); 244 VMMDECL(bool) TMTimerIsActive(PTMTIMER pTimer); 245 246 VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext); 247 VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext); 248 VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext); 249 VMMDECL(uint64_t) TMTimerGetNano(PTMTIMER pTimer); 250 VMMDECL(uint64_t) TMTimerGetMicro(PTMTIMER pTimer); 251 VMMDECL(uint64_t) TMTimerGetMilli(PTMTIMER pTimer); 252 VMMDECL(uint64_t) TMTimerGetFreq(PTMTIMER pTimer); 253 VMMDECL(uint64_t) TMTimerGetExpire(PTMTIMER pTimer); 254 VMMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t cTicks); 255 VMMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t cTicks); 256 VMMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t cTicks); 257 VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs); 258 VMMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t cMicroSecs); 259 VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, PTMTIMER pTimer, uint64_t cMilliSecs); 233 VMMDECL(int) TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy); 234 VMMDECL(void) TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer); 235 VMMDECL(bool) TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer); 236 VMMDECL(int) TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire); 237 VMMDECL(int) TMTimerSetRelative(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now); 238 VMMDECL(int) TMTimerSetFrequencyHint(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t uHz); 239 VMMDECL(uint64_t) TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer); 240 VMMDECL(int) TMTimerStop(PVMCC pVM, TMTIMERHANDLE hTimer); 241 VMMDECL(bool) TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer); 242 243 VMMDECL(int) TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext); 244 VMMDECL(int) TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext); 245 VMMDECL(int) TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext); 246 VMMDECL(uint64_t) TMTimerGetNano(PVMCC pVM, TMTIMERHANDLE hTimer); 247 VMMDECL(uint64_t) TMTimerGetMicro(PVMCC pVM, TMTIMERHANDLE hTimer); 248 VMMDECL(uint64_t) TMTimerGetMilli(PVMCC pVM, TMTIMERHANDLE hTimer); 249 VMMDECL(uint64_t) TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer); 250 VMMDECL(uint64_t) TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer); 251 VMMDECL(uint64_t) TMTimerToNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks); 252 VMMDECL(uint64_t) TMTimerToMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks); 253 VMMDECL(uint64_t) TMTimerToMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cTicks); 254 VMMDECL(uint64_t) TMTimerFromNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanoSecs); 255 VMMDECL(uint64_t) TMTimerFromMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicroSecs); 256 VMMDECL(uint64_t) TMTimerFromMilli(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMilliSecs); 260 257 261 258 VMMDECL(bool) TMTimerPollBool(PVMCC pVM, PVMCPUCC pVCpu); … … 275 272 VMM_INT_DECL(void) TMR3Reset(PVM pVM); 276 273 VMM_INT_DECL(int) TMR3GetImportRC(PVM pVM, const char *pszSymbol, PRTRCPTR pRCPtrValue); 277 VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer); 278 VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer); 279 VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, uint32_t fFlags, const char *pszDesc, PPTMTIMERR3 ppTimer); 274 VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, PFNTMTIMERDEV pfnCallback, 275 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer); 276 VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, PFNTMTIMERUSB pfnCallback, 277 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer); 278 VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, 279 void *pvUser, uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer); 280 280 VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, uint32_t fFlags, 281 const char *pszDesc, P PTMTIMERR3 ppTimer);282 VMMR3DECL(int) TMR3TimerDestroy(P TMTIMER pTimer);281 const char *pszDesc, PTMTIMERHANDLE phTimer); 282 VMMR3DECL(int) TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer); 283 283 VMM_INT_DECL(int) TMR3TimerDestroyDevice(PVM pVM, PPDMDEVINS pDevIns); 284 284 VMM_INT_DECL(int) TMR3TimerDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns); 285 285 VMM_INT_DECL(int) TMR3TimerDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns); 286 VMMR3DECL(int) TMR3TimerSave(P TMTIMERR3 pTimer, PSSMHANDLE pSSM);287 VMMR3DECL(int) TMR3TimerLoad(P TMTIMERR3 pTimer, PSSMHANDLE pSSM);286 VMMR3DECL(int) TMR3TimerSave(PVMCC pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM); 287 VMMR3DECL(int) TMR3TimerLoad(PVMCC pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM); 288 288 VMMR3DECL(int) TMR3TimerSkip(PSSMHANDLE pSSM, bool *pfActive); 289 VMMR3DECL(int) TMR3TimerSetCritSect(P TMTIMERR3 pTimer, PPDMCRITSECT pCritSect);289 VMMR3DECL(int) TMR3TimerSetCritSect(PVMCC pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect); 290 290 VMMR3DECL(void) TMR3TimerQueuesDo(PVM pVM); 291 291 VMMR3_INT_DECL(void) TMR3VirtualSyncFF(PVM pVM, PVMCPU pVCpu); -
trunk/src/VBox/Devices/VMMDev/VMMDev.cpp
r87760 r87766 513 513 static DECLCALLBACK(void) vmmDevHeartbeatFlatlinedTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser) 514 514 { 515 RT_NOREF(pDevIns );515 RT_NOREF(pDevIns, pTimer); 516 516 PVMMDEV pThis = (PVMMDEV)pvUser; 517 517 if (pThis->fHeartbeatActive) 518 518 { 519 uint64_t cNsElapsed = TMTimerGetNano(pTimer) - pThis->nsLastHeartbeatTS;519 uint64_t cNsElapsed = PDMDevHlpTimerGetNano(pDevIns, pThis->hFlatlinedTimer) - pThis->nsLastHeartbeatTS; 520 520 if ( !pThis->fFlatlined 521 521 && cNsElapsed >= pThis->cNsHeartbeatInterval) -
trunk/src/VBox/VMM/VMMAll/CPUMAllRegs.cpp
r87361 r87766 2335 2335 VMCPU_ASSERT_EMT(pVCpu); 2336 2336 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); 2338 2338 } 2339 2339 … … 2353 2353 /* 2354 2354 * 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 have2355 * However, we still get called during CPUMR3Init() and hence we need to check if we have 2356 2356 * a valid timer object before trying to stop it. 2357 2357 */ 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; 2369 2373 return rc; 2370 2374 } -
trunk/src/VBox/VMM/VMMAll/GIMAllHv.cpp
r82968 r87766 509 509 VMM_INT_DECL(void) gimHvStartStimer(PVMCPUCC pVCpu, PCGIMHVSTIMER pHvStimer) 510 510 { 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)); 513 514 514 515 uint64_t const uTimerCount = pHvStimer->uStimerCountMsr; … … 520 521 if (MSR_GIM_HV_STIMER_IS_PERIODIC(pHvStimer->uStimerConfigMsr)) 521 522 { 522 TMTimerSetNano(p Timer, uTimerCountNS);523 TMTimerSetNano(pVM, hTimer, uTimerCountNS); 523 524 LogFlow(("GIM%u: HyperV: Started relative periodic STIMER%u with uTimerCountNS=%RU64\n", pVCpu->idCpu, 524 525 pHvStimer->idxStimer, uTimerCountNS)); … … 532 533 { 533 534 uint64_t const uRelativeNS = uTimerCountNS - uCurRefTimeNS; 534 TMTimerSetNano(p Timer, uRelativeNS);535 TMTimerSetNano(pVM, hTimer, uRelativeNS); 535 536 LogFlow(("GIM%u: HyperV: Started one-shot relative STIMER%u with uRelativeNS=%RU64\n", pVCpu->idCpu, 536 537 pHvStimer->idxStimer, uRelativeNS)); … … 554 555 { 555 556 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); 564 564 } 565 565 … … 757 757 { 758 758 NOREF(pRange); 759 PVM pVM = pVCpu->CTX_SUFF(pVM);759 PVMCC pVM = pVCpu->CTX_SUFF(pVM); 760 760 PGIMHV pHv = &pVM->gim.s.u.Hv; 761 761 … … 1153 1153 Assert(idxStimer < RT_ELEMENTS(pHvCpu->aStimers)); 1154 1154 PGIMHVSTIMER pHvStimer = &pHvCpu->aStimers[idxStimer]; 1155 PTMTIMER pTimer = pHvStimer->CTX_SUFF(pTimer);1156 1155 1157 1156 /* Lock to prevent concurrent access from the timer callback. */ 1158 int rc = TMTimerLock(p Timer, VERR_IGNORED);1157 int rc = TMTimerLock(pVM, pHvStimer->hTimer, VERR_IGNORED); 1159 1158 if (rc == VINF_SUCCESS) 1160 1159 { … … 1176 1175 if (!MSR_GIM_HV_STIMER_IS_AUTO_ENABLED(uRawValue)) 1177 1176 { 1178 if (!TMTimerIsActive(p HvStimer->CTX_SUFF(pTimer)))1177 if (!TMTimerIsActive(pVM, pHvStimer->hTimer)) 1179 1178 { 1180 1179 gimHvStartStimer(pVCpu, pHvStimer); … … 1197 1196 } 1198 1197 1199 TMTimerUnlock(p Timer);1198 TMTimerUnlock(pVM, pHvStimer->hTimer); 1200 1199 } 1201 1200 return rc; … … 1239 1238 if (MSR_GIM_HV_STIMER_IS_AUTO_ENABLED(pHvStimer->uStimerConfigMsr)) 1240 1239 { 1241 PTMTIMER pTimer = pHvStimer->CTX_SUFF(pTimer); 1242 int rc = TMTimerLock(pTimer, rcBusy); 1240 int rc = TMTimerLock(pVM, pHvStimer->hTimer, rcBusy); 1243 1241 if (rc == VINF_SUCCESS) 1244 1242 { 1245 1243 pHvStimer->uStimerCountMsr = uRawValue; 1246 1244 gimHvStartStimer(pVCpu, pHvStimer); 1247 TMTimerUnlock(p Timer);1245 TMTimerUnlock(pVM, pHvStimer->hTimer); 1248 1246 Log(("GIM%u: HyperV: Set STIMER_COUNT%u=%RU64 %RU64 msec, auto-started timer\n", pVCpu->idCpu, idxStimer, 1249 1247 uRawValue, (uRawValue * 100) / RT_NS_1MS_64)); -
trunk/src/VBox/VMM/VMMAll/PDMAllQueue.cpp
r82968 r87766 111 111 #endif 112 112 113 if ( !pQueue->pTimer)113 if (pQueue->hTimer == NIL_TMTIMERHANDLE) 114 114 pdmQueueSetFF(pQueue); 115 115 STAM_REL_COUNTER_INC(&pQueue->StatInsert); -
trunk/src/VBox/VMM/VMMAll/TMAll.cpp
r87764 r87766 1102 1102 1103 1103 /** 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_RING01112 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);1113 #endif1114 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_RING01127 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);1128 #endif1129 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_RING01142 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0);1143 #endif1144 return (PTMTIMERRC)MMHyperCCToRC(pTimer->CTX_SUFF(pVM), pTimer);1145 }1146 1147 1148 /**1149 1104 * Locks the timer clock. 1150 1105 * 1151 1106 * @returns VINF_SUCCESS on success, @a rcBusy if busy, and VERR_NOT_SUPPORTED 1152 1107 * if the clock does not have a lock. 1153 * @param p Timer The timer which clock lock we wish to take.1154 * @param rcBusy What to return in ring-0 and raw-mode context1155 * if the lock is busy. Pass VINF_SUCCESS to1156 * acquired the critical section thru a ring-31157 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. 1158 1113 * 1159 1114 * @remarks Currently only supported on timers using the virtual sync clock. 1160 1115 */ 1161 VMMDECL(int) TMTimerLock(PTMTIMER pTimer, int rcBusy) 1162 { 1163 #ifdef IN_RING0 1164 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 1165 #endif 1116 VMMDECL(int) TMTimerLock(PVMCC pVM, TMTIMERHANDLE hTimer, int rcBusy) 1117 { 1118 PTMTIMER pTimer; 1119 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 1166 1120 AssertPtr(pTimer); 1167 1121 AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, VERR_NOT_SUPPORTED); 1168 return PDMCritSectEnter(&p Timer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock, rcBusy);1122 return PDMCritSectEnter(&pVM->tm.s.VirtualSyncLock, rcBusy); 1169 1123 } 1170 1124 … … 1173 1127 * Unlocks a timer clock locked by TMTimerLock. 1174 1128 * 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 */ 1132 VMMDECL(void) TMTimerUnlock(PVMCC pVM, TMTIMERHANDLE hTimer) 1133 { 1134 PTMTIMER pTimer; 1135 TMTIMER_HANDLE_TO_PTR_RETURN_VOID(pVM, hTimer, pTimer); 1183 1136 AssertReturnVoid(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC); 1184 PDMCritSectLeave(&p Timer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock);1137 PDMCritSectLeave(&pVM->tm.s.VirtualSyncLock); 1185 1138 } 1186 1139 … … 1190 1143 * 1191 1144 * @returns @c true if its the owner, @c false if not. 1192 * @param p Timer 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 */ 1148 VMMDECL(bool) TMTimerIsLockOwner(PVMCC pVM, TMTIMERHANDLE hTimer) 1149 { 1150 PTMTIMER pTimer; 1151 TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer); 1199 1152 AssertPtr(pTimer); 1200 1153 AssertReturn(pTimer->enmClock == TMCLOCK_VIRTUAL_SYNC, false); 1201 return PDMCritSectIsOwner(&p Timer->CTX_SUFF(pVM)->tm.s.VirtualSyncLock);1154 return PDMCritSectIsOwner(&pVM->tm.s.VirtualSyncLock); 1202 1155 } 1203 1156 … … 1319 1272 * 1320 1273 * @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 */ 1278 VMMDECL(int) TMTimerSet(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t u64Expire) 1279 { 1280 PTMTIMER pTimer; 1281 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 1330 1282 STAM_COUNTER_INC(&pTimer->StatSetAbsolute); 1331 1283 … … 1627 1579 * 1628 1580 * @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. 1630 1583 * @param cTicksToNext Clock ticks until the next time expiration. 1631 1584 * @param pu64Now Where to return the current time stamp used. 1632 1585 * Optional. 1633 1586 */ 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); 1587 static int tmTimerSetRelative(PVMCC pVM, PTMTIMER pTimer, uint64_t cTicksToNext, uint64_t *pu64Now) 1588 { 1640 1589 STAM_COUNTER_INC(&pTimer->StatSetRelative); 1641 1590 … … 1849 1798 1850 1799 /** 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 */ 1809 VMMDECL(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 /** 1851 1818 * Drops a hint about the frequency of the timer. 1852 1819 * … … 1855 1822 * 1856 1823 * @returns VBox status code. 1857 * @param p Timer Timer handle as returned by one of the create1858 * 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. 1860 1827 * 1861 1828 * @remarks We're using an integer hertz value here since anything above 1 HZ … … 1863 1830 * range where it makes sense is >= 100 HZ. 1864 1831 */ 1865 VMMDECL(int) TMTimerSetFrequencyHint(PTMTIMER pTimer, uint32_t uHzHint) 1866 { 1867 #ifdef IN_RING0 1868 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 1869 #endif 1832 VMMDECL(int) TMTimerSetFrequencyHint(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t uHzHint) 1833 { 1834 PTMTIMER pTimer; 1835 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 1870 1836 TMTIMER_ASSERT_CRITSECT(pTimer); 1871 1837 … … 1873 1839 pTimer->uHzHint = uHzHint; 1874 1840 1875 PVM pVM = pTimer->CTX_SUFF(pVM);1876 1841 uint32_t const uMaxHzHint = pVM->tm.s.uMaxHzHint; 1877 1842 if ( uHzHint > uMaxHzHint … … 1959 1924 * 1960 1925 * @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 */ 1929 VMMDECL(int) TMTimerStop(PVMCC pVM, TMTIMERHANDLE hTimer) 1930 { 1931 PTMTIMER pTimer; 1932 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 1969 1933 STAM_COUNTER_INC(&pTimer->StatStop); 1970 1934 … … 2070 2034 * 2071 2035 * @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 */ 2039 VMMDECL(uint64_t) TMTimerGet(PVMCC pVM, TMTIMERHANDLE hTimer) 2040 { 2041 PTMTIMER pTimer; 2042 TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer); 2080 2043 STAM_COUNTER_INC(&pTimer->StatGet); 2081 2044 … … 2106 2069 * 2107 2070 * @returns Clock frequency (as Hz of course). 2108 * @param p Timer 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 */ 2074 VMMDECL(uint64_t) TMTimerGetFreq(PVMCC pVM, TMTIMERHANDLE hTimer) 2075 { 2076 PTMTIMER pTimer; 2077 TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, 0, pTimer); 2115 2078 switch (pTimer->enmClock) 2116 2079 { … … 2134 2097 * 2135 2098 * @returns Expire time of the timer. 2136 * @param p Timer 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 */ 2102 VMMDECL(uint64_t) TMTimerGetExpire(PVMCC pVM, TMTIMERHANDLE hTimer) 2103 { 2104 PTMTIMER pTimer; 2105 TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, UINT64_MAX, pTimer); 2143 2106 TMTIMER_ASSERT_CRITSECT(pTimer); 2144 2107 int cRetries = 1000; … … 2155 2118 Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n", 2156 2119 pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc))); 2157 return ~(uint64_t)0;2120 return UINT64_MAX; 2158 2121 2159 2122 case TMTIMERSTATE_ACTIVE: … … 2180 2143 Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n", 2181 2144 pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc))); 2182 return ~(uint64_t)0;2145 return UINT64_MAX; 2183 2146 default: 2184 2147 AssertMsgFailed(("Unknown timer state %d (%s)\n", enmState, R3STRING(pTimer->pszDesc))); 2185 return ~(uint64_t)0;2148 return UINT64_MAX; 2186 2149 } 2187 2150 } while (cRetries-- > 0); … … 2190 2153 Log2(("TMTimerGetExpire: returns ~0 (pTimer=%p:{.enmState=%s, .pszDesc='%s'})\n", 2191 2154 pTimer, tmTimerState(pTimer->enmState), R3STRING(pTimer->pszDesc))); 2192 return ~(uint64_t)0;2155 return UINT64_MAX; 2193 2156 } 2194 2157 … … 2199 2162 * @returns True if active. 2200 2163 * @returns False if not active. 2201 * @param p Timer 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 */ 2167 VMMDECL(bool) TMTimerIsActive(PVMCC pVM, TMTIMERHANDLE hTimer) 2168 { 2169 PTMTIMER pTimer; 2170 TMTIMER_HANDLE_TO_PTR_RETURN_EX(pVM, hTimer, false, pTimer); 2208 2171 TMTIMERSTATE enmState = pTimer->enmState; 2209 2172 switch (enmState) … … 2250 2213 * 2251 2214 * @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. 2253 2217 * @param cMilliesToNext Number of milliseconds to the next tick. 2254 2218 */ 2255 VMMDECL(int) TMTimerSetMillies(PTMTIMER pTimer, uint32_t cMilliesToNext) 2256 { 2219 VMMDECL(int) TMTimerSetMillies(PVMCC pVM, TMTIMERHANDLE hTimer, uint32_t cMilliesToNext) 2220 { 2221 PTMTIMER pTimer; 2222 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2257 2223 switch (pTimer->enmClock) 2258 2224 { 2259 2225 case TMCLOCK_VIRTUAL: 2260 2226 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2261 return TMTimerSetRelative(pTimer, cMilliesToNext * UINT64_C(1000000), NULL);2227 return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL); 2262 2228 2263 2229 case TMCLOCK_VIRTUAL_SYNC: 2264 2230 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2265 return TMTimerSetRelative(pTimer, cMilliesToNext * UINT64_C(1000000), NULL);2231 return tmTimerSetRelative(pVM, pTimer, cMilliesToNext * UINT64_C(1000000), NULL); 2266 2232 2267 2233 case TMCLOCK_REAL: 2268 2234 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2269 return TMTimerSetRelative(pTimer, cMilliesToNext, NULL);2235 return tmTimerSetRelative(pVM, pTimer, cMilliesToNext, NULL); 2270 2236 2271 2237 default: … … 2280 2246 * 2281 2247 * @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. 2283 2250 * @param cMicrosToNext Number of microseconds to the next tick. 2284 2251 */ 2285 VMMDECL(int) TMTimerSetMicro(PTMTIMER pTimer, uint64_t cMicrosToNext) 2286 { 2252 VMMDECL(int) TMTimerSetMicro(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext) 2253 { 2254 PTMTIMER pTimer; 2255 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2287 2256 switch (pTimer->enmClock) 2288 2257 { 2289 2258 case TMCLOCK_VIRTUAL: 2290 2259 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2291 return TMTimerSetRelative(pTimer, cMicrosToNext * 1000, NULL);2260 return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL); 2292 2261 2293 2262 case TMCLOCK_VIRTUAL_SYNC: 2294 2263 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2295 return TMTimerSetRelative(pTimer, cMicrosToNext * 1000, NULL);2264 return tmTimerSetRelative(pVM, pTimer, cMicrosToNext * 1000, NULL); 2296 2265 2297 2266 case TMCLOCK_REAL: 2298 2267 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2299 return TMTimerSetRelative(pTimer, cMicrosToNext / 1000, NULL);2268 return tmTimerSetRelative(pVM, pTimer, cMicrosToNext / 1000, NULL); 2300 2269 2301 2270 default: … … 2310 2279 * 2311 2280 * @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. 2313 2283 * @param cNanosToNext Number of nanoseconds to the next tick. 2314 2284 */ 2315 VMMDECL(int) TMTimerSetNano(PTMTIMER pTimer, uint64_t cNanosToNext) 2316 { 2285 VMMDECL(int) TMTimerSetNano(PVMCC pVM, TMTIMERHANDLE hTimer, uint64_t cNanosToNext) 2286 { 2287 PTMTIMER pTimer; 2288 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2317 2289 switch (pTimer->enmClock) 2318 2290 { 2319 2291 case TMCLOCK_VIRTUAL: 2320 2292 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2321 return TMTimerSetRelative(pTimer, cNanosToNext, NULL);2293 return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL); 2322 2294 2323 2295 case TMCLOCK_VIRTUAL_SYNC: 2324 2296 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2325 return TMTimerSetRelative(pTimer, cNanosToNext, NULL);2297 return tmTimerSetRelative(pVM, pTimer, cNanosToNext, NULL); 2326 2298 2327 2299 case TMCLOCK_REAL: 2328 2300 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2329 return TMTimerSetRelative(pTimer, cNanosToNext / 1000000, NULL);2301 return tmTimerSetRelative(pVM, pTimer, cNanosToNext / 1000000, NULL); 2330 2302 2331 2303 default: … … 2340 2312 * 2341 2313 * @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 */ 2317 VMMDECL(uint64_t) TMTimerGetNano(PVMCC pVM, TMTIMERHANDLE hTimer) 2318 { 2319 return TMTimerToNano(pVM, hTimer, TMTimerGet(pVM, hTimer)); 2347 2320 } 2348 2321 … … 2352 2325 * 2353 2326 * @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 */ 2330 VMMDECL(uint64_t) TMTimerGetMicro(PVMCC pVM, TMTIMERHANDLE hTimer) 2331 { 2332 return TMTimerToMicro(pVM, hTimer, TMTimerGet(pVM, hTimer)); 2359 2333 } 2360 2334 … … 2364 2338 * 2365 2339 * @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 */ 2343 VMMDECL(uint64_t) TMTimerGetMilli(PVMCC pVM, TMTIMERHANDLE hTimer) 2344 { 2345 return TMTimerToMilli(pVM, hTimer, TMTimerGet(pVM, hTimer)); 2371 2346 } 2372 2347 … … 2376 2351 * 2377 2352 * @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. 2380 2356 * @remark There could be rounding errors here. We just do a simple integer divide 2381 2357 * without any adjustments. 2382 2358 */ 2383 VMMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks) 2384 { 2385 #ifdef IN_RING0 2386 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 2387 #endif 2359 VMMDECL(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); 2388 2363 switch (pTimer->enmClock) 2389 2364 { … … 2391 2366 case TMCLOCK_VIRTUAL_SYNC: 2392 2367 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2393 return u64Ticks;2368 return cTicks; 2394 2369 2395 2370 case TMCLOCK_REAL: 2396 2371 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2397 return u64Ticks * 1000000;2372 return cTicks * 1000000; 2398 2373 2399 2374 default: … … 2408 2383 * 2409 2384 * @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. 2412 2388 * @remark There could be rounding errors here. We just do a simple integer divide 2413 2389 * without any adjustments. 2414 2390 */ 2415 VMMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks) 2416 { 2417 #ifdef IN_RING0 2418 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 2419 #endif 2391 VMMDECL(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); 2420 2395 switch (pTimer->enmClock) 2421 2396 { … … 2423 2398 case TMCLOCK_VIRTUAL_SYNC: 2424 2399 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2425 return u64Ticks / 1000;2400 return cTicks / 1000; 2426 2401 2427 2402 case TMCLOCK_REAL: 2428 2403 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2429 return u64Ticks * 1000;2404 return cTicks * 1000; 2430 2405 2431 2406 default: … … 2440 2415 * 2441 2416 * @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. 2444 2420 * @remark There could be rounding errors here. We just do a simple integer divide 2445 2421 * without any adjustments. 2446 2422 */ 2447 VMMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks) 2448 { 2449 #ifdef IN_RING0 2450 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 2451 #endif 2423 VMMDECL(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); 2452 2427 switch (pTimer->enmClock) 2453 2428 { … … 2455 2430 case TMCLOCK_VIRTUAL_SYNC: 2456 2431 AssertCompile(TMCLOCK_FREQ_VIRTUAL == 1000000000); 2457 return u64Ticks / 1000000;2432 return cTicks / 1000000; 2458 2433 2459 2434 case TMCLOCK_REAL: 2460 2435 AssertCompile(TMCLOCK_FREQ_REAL == 1000); 2461 return u64Ticks;2436 return cTicks; 2462 2437 2463 2438 default: … … 2472 2447 * 2473 2448 * @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. 2476 2452 * @remark There could be rounding and overflow errors here. 2477 2453 */ 2478 VMMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t cNanoSecs) 2479 { 2480 #ifdef IN_RING0 2481 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 2482 #endif 2454 VMMDECL(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); 2483 2458 switch (pTimer->enmClock) 2484 2459 { … … 2503 2478 * 2504 2479 * @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. 2507 2483 * @remark There could be rounding and overflow errors here. 2508 2484 */ 2509 VMMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t cMicroSecs) 2510 { 2511 #ifdef IN_RING0 2512 Assert(pTimer->fFlags & TMTIMER_FLAGS_RING0); 2513 #endif 2485 VMMDECL(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); 2514 2489 switch (pTimer->enmClock) 2515 2490 { … … 2534 2509 * 2535 2510 * @returns timer clock ticks. 2536 * @param pVM The cross context VM structure.2537 * @param pTimerTimer 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. 2539 2514 * @remark There could be rounding and overflow errors here. 2540 2515 */ 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 2516 VMMDECL(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); 2548 2520 switch (pTimer->enmClock) 2549 2521 { -
trunk/src/VBox/VMM/VMMR0/PDMR0DevHlp.cpp
r87764 r87766 415 415 416 416 417 /** Converts a timer handle to a pointer (used to be exposed, will be418 * rewritten later). */419 DECLINLINE(PTMTIMERR0) pdmR0DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)420 {421 PDMDEV_ASSERT_DEVINS(pDevIns);422 return (PTMTIMERR0)MMHyperR3ToCC(pDevIns->Internal.s.pGVM, hTimer);423 }424 425 417 /** @interface_method_impl{PDMDEVHLPR0,pfnTimerFromMicro} */ 426 418 static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs) 427 419 { 428 return TMTimerFromMicro(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMicroSecs); 420 PDMDEV_ASSERT_DEVINS(pDevIns); 421 return TMTimerFromMicro(pDevIns->Internal.s.pGVM, hTimer, cMicroSecs); 429 422 } 430 423 … … 434 427 { 435 428 PDMDEV_ASSERT_DEVINS(pDevIns); 436 return TMTimerFromMilli(pDevIns->Internal.s.pGVM, pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMilliSecs);429 return TMTimerFromMilli(pDevIns->Internal.s.pGVM, hTimer, cMilliSecs); 437 430 } 438 431 … … 441 434 static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs) 442 435 { 443 return TMTimerFromNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cNanoSecs); 436 PDMDEV_ASSERT_DEVINS(pDevIns); 437 return TMTimerFromNano(pDevIns->Internal.s.pGVM, hTimer, cNanoSecs); 444 438 } 445 439 … … 447 441 static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 448 442 { 449 return TMTimerGet(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 443 PDMDEV_ASSERT_DEVINS(pDevIns); 444 return TMTimerGet(pDevIns->Internal.s.pGVM, hTimer); 450 445 } 451 446 … … 454 449 static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 455 450 { 456 return TMTimerGetFreq(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 451 PDMDEV_ASSERT_DEVINS(pDevIns); 452 return TMTimerGetFreq(pDevIns->Internal.s.pGVM, hTimer); 457 453 } 458 454 … … 461 457 static DECLCALLBACK(uint64_t) pdmR0DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 462 458 { 463 return TMTimerGetNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 459 PDMDEV_ASSERT_DEVINS(pDevIns); 460 return TMTimerGetNano(pDevIns->Internal.s.pGVM, hTimer); 464 461 } 465 462 … … 468 465 static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 469 466 { 470 return TMTimerIsActive(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 467 PDMDEV_ASSERT_DEVINS(pDevIns); 468 return TMTimerIsActive(pDevIns->Internal.s.pGVM, hTimer); 471 469 } 472 470 … … 475 473 static DECLCALLBACK(bool) pdmR0DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 476 474 { 477 return TMTimerIsLockOwner(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 475 PDMDEV_ASSERT_DEVINS(pDevIns); 476 return TMTimerIsLockOwner(pDevIns->Internal.s.pGVM, hTimer); 478 477 } 479 478 … … 482 481 static DECLCALLBACK(VBOXSTRICTRC) pdmR0DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy) 483 482 { 484 return TMTimerLock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy); 483 PDMDEV_ASSERT_DEVINS(pDevIns); 484 return TMTimerLock(pDevIns->Internal.s.pGVM, hTimer, rcBusy); 485 485 } 486 486 … … 490 490 PPDMCRITSECT pCritSect, int rcBusy) 491 491 { 492 VBOXSTRICTRC rc = TMTimerLock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy); 492 PDMDEV_ASSERT_DEVINS(pDevIns); 493 VBOXSTRICTRC rc = TMTimerLock(pDevIns->Internal.s.pGVM, hTimer, rcBusy); 493 494 if (rc == VINF_SUCCESS) 494 495 { … … 497 498 return rc; 498 499 AssertRC(VBOXSTRICTRC_VAL(rc)); 499 TMTimerUnlock(p dmR0DevHlp_TimerToPtr(pDevIns, hTimer));500 TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer); 500 501 } 501 502 else … … 508 509 static DECLCALLBACK(int) pdmR0DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire) 509 510 { 510 return TMTimerSet(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), uExpire); 511 PDMDEV_ASSERT_DEVINS(pDevIns); 512 return TMTimerSet(pDevIns->Internal.s.pGVM, hTimer, uExpire); 511 513 } 512 514 … … 515 517 static DECLCALLBACK(int) pdmR0DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz) 516 518 { 517 return TMTimerSetFrequencyHint(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), uHz); 519 PDMDEV_ASSERT_DEVINS(pDevIns); 520 return TMTimerSetFrequencyHint(pDevIns->Internal.s.pGVM, hTimer, uHz); 518 521 } 519 522 … … 522 525 static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext) 523 526 { 524 return TMTimerSetMicro(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMicrosToNext); 527 PDMDEV_ASSERT_DEVINS(pDevIns); 528 return TMTimerSetMicro(pDevIns->Internal.s.pGVM, hTimer, cMicrosToNext); 525 529 } 526 530 … … 529 533 static DECLCALLBACK(int) pdmR0DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext) 530 534 { 531 return TMTimerSetMillies(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cMilliesToNext); 535 PDMDEV_ASSERT_DEVINS(pDevIns); 536 return TMTimerSetMillies(pDevIns->Internal.s.pGVM, hTimer, cMilliesToNext); 532 537 } 533 538 … … 536 541 static DECLCALLBACK(int) pdmR0DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext) 537 542 { 538 return TMTimerSetNano(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cNanosToNext); 543 PDMDEV_ASSERT_DEVINS(pDevIns); 544 return TMTimerSetNano(pDevIns->Internal.s.pGVM, hTimer, cNanosToNext); 539 545 } 540 546 … … 543 549 static DECLCALLBACK(int) pdmR0DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now) 544 550 { 545 return TMTimerSetRelative(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer), cTicksToNext, pu64Now); 551 PDMDEV_ASSERT_DEVINS(pDevIns); 552 return TMTimerSetRelative(pDevIns->Internal.s.pGVM, hTimer, cTicksToNext, pu64Now); 546 553 } 547 554 … … 550 557 static DECLCALLBACK(int) pdmR0DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 551 558 { 552 return TMTimerStop(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 559 PDMDEV_ASSERT_DEVINS(pDevIns); 560 return TMTimerStop(pDevIns->Internal.s.pGVM, hTimer); 553 561 } 554 562 … … 557 565 static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 558 566 { 559 TMTimerUnlock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 567 PDMDEV_ASSERT_DEVINS(pDevIns); 568 TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer); 560 569 } 561 570 … … 564 573 static DECLCALLBACK(void) pdmR0DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 565 574 { 566 TMTimerUnlock(pdmR0DevHlp_TimerToPtr(pDevIns, hTimer)); 575 PDMDEV_ASSERT_DEVINS(pDevIns); 576 TMTimerUnlock(pDevIns->Internal.s.pGVM, hTimer); 567 577 int rc = PDMCritSectLeave(pCritSect); 568 578 AssertRC(rc); -
trunk/src/VBox/VMM/VMMR3/CPUM.cpp
r87765 r87766 2099 2099 2100 2100 /** 2101 * Callback that fires when the nested VMX-preemption timer expired. 2102 * 2103 * @param pVM The cross context VM structure. 2104 * @param pTimer Pointer to timer. 2105 * @param pvUser Opaque pointer to the virtual-CPU. 2106 */ 2107 static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser) 2108 { 2109 RT_NOREF2(pVM, pTimer); 2110 Assert(pvUser); 2111 2101 * @callback_method_impl{FNTMTIMERINT, 2102 * Callback that fires when the nested VMX-preemption timer expired.} 2103 */ 2104 static DECLCALLBACK(void) cpumR3VmxPreemptTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 2105 { 2106 RT_NOREF(pVM, hTimer); 2112 2107 PVMCPU pVCpu = (PVMCPUR3)pvUser; 2108 AssertPtr(pVCpu); 2113 2109 VMCPU_FF_SET(pVCpu, VMCPU_FF_VMX_PREEMPT_TIMER); 2114 2110 } … … 2224 2220 2225 2221 pVCpu->cpum.s.Host.fXStateMask = fXStateHostMask; 2222 2223 pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE; 2226 2224 } 2227 2225 … … 2334 2332 { 2335 2333 PVMCPU pVCpu = pVM->apCpusR3[idCpu]; 2336 int rc = TMR3TimerDestroy(pVCpu->cpum.s.pNestedVmxPreemptTimerR3); AssertRC(rc); 2337 pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = NIL_RTR0PTR; 2334 if (pVCpu->cpum.s.hNestedVmxPreemptTimer != NIL_TMTIMERHANDLE) 2335 { 2336 int rc = TMR3TimerDestroy(pVM, pVCpu->cpum.s.hNestedVmxPreemptTimer); AssertRC(rc); 2337 pVCpu->cpum.s.hNestedVmxPreemptTimer = NIL_TMTIMERHANDLE; 2338 } 2338 2339 } 2339 2340 … … 4502 4503 cpumR3MsrRegStats(pVM); 4503 4504 4504 /* Create VMX-preemption timer for nested guests if required. */4505 /** @todo r=bird: this should be one in CPUMR3Init, not here.*/4505 /* Create VMX-preemption timer for nested guests if required. Must be 4506 done here as CPUM is initialized before TM. */ 4506 4507 if (pVM->cpum.s.GuestFeatures.fVmx) 4507 4508 { … … 4513 4514 char *pszTimerName = MMR3HeapAPrintf(pVM, MM_TAG_CPUM_CTX, "Nested Guest VMX-preempt. timer %u", idCpu); 4514 4515 int rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, cpumR3VmxPreemptTimerCallback, pVCpu, 4515 TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s. pNestedVmxPreemptTimerR3);4516 TMTIMER_FLAGS_RING0, pszTimerName, &pVCpu->cpum.s.hNestedVmxPreemptTimer); 4516 4517 AssertLogRelRCReturn(rc, rc); 4517 pVCpu->cpum.s.pNestedVmxPreemptTimerR0 = TMTimerR0Ptr(pVCpu->cpum.s.pNestedVmxPreemptTimerR3);4518 4518 } 4519 4519 } -
trunk/src/VBox/VMM/VMMR3/GIMHv.cpp
r87765 r87766 187 187 static int gimR3HvInitDebugSupport(PVM pVM); 188 188 static void gimR3HvTermDebugSupport(PVM pVM); 189 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMERpTimer, void *pvUser);189 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE pTimer, void *pvUser); 190 190 191 191 /** … … 202 202 203 203 PGIMHV pHv = &pVM->gim.s.u.Hv; 204 205 /* 206 * Initialize timer handles and such. 207 */ 208 for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++) 209 { 210 PVMCPU pVCpu = pVM->apCpusR3[idCpu]; 211 PGIMHVCPU pHvCpu = &pVCpu->gim.s.u.HvCpu; 212 for (uint8_t idxStimer = 0; idxStimer < RT_ELEMENTS(pHvCpu->aStimers); idxStimer++) 213 pHvCpu->aStimers[idxStimer].hTimer = NIL_TMTIMERHANDLE; 214 } 204 215 205 216 /* … … 510 521 idxStimer); 511 522 rc = TMR3TimerCreate(pVM, TMCLOCK_VIRTUAL_SYNC, gimR3HvTimerCallback, pHvStimer /* pvUser */, 512 TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer-> pTimerR3);523 TMTIMER_FLAGS_RING0, pHvStimer->szTimerDesc, &pHvStimer->hTimer); 513 524 AssertLogRelRCReturn(rc, rc); 514 pHvStimer->pTimerR0 = TMTimerR0Ptr(pHvStimer->pTimerR3);515 525 } 516 526 } … … 605 615 { 606 616 PGIMHVSTIMER pHvStimer = &pHvCpu->aStimers[idxStimer]; 607 TMR3TimerDestroy(pHvStimer->pTimerR3); 617 TMR3TimerDestroy(pVM, pHvStimer->hTimer); 618 pHvStimer->hTimer = NIL_TMTIMERHANDLE; 608 619 } 609 620 } … … 1082 1093 1083 1094 /** 1084 * Hyper-V synthetic timer callback. 1085 * 1086 * @param pVM The cross context VM structure. 1087 * @param pTimer Pointer to timer. 1088 * @param pvUser Pointer to the synthetic timer. 1089 */ 1090 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser) 1095 * @callback_method_impl{FNTMTIMERINT, Hyper-V synthetic timer callback.} 1096 */ 1097 static DECLCALLBACK(void) gimR3HvTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 1091 1098 { 1092 1099 PGIMHVSTIMER pHvStimer = (PGIMHVSTIMER)pvUser; 1093 1100 Assert(pHvStimer); 1094 Assert(TMTimerIsLockOwner(p Timer)); RT_NOREF(pTimer);1101 Assert(TMTimerIsLockOwner(pVM, hTimer)); 1095 1102 Assert(pHvStimer->idCpu < pVM->cCpus); 1103 Assert(pHvStimer->hTimer == hTimer); 1104 RT_NOREF(hTimer); 1096 1105 1097 1106 PVMCPU pVCpu = pVM->apCpusR3[pHvStimer->idCpu]; -
trunk/src/VBox/VMM/VMMR3/PDMAsyncCompletionFile.cpp
r87765 r87766 363 363 { 364 364 ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, tsDelay); 365 TMTimerSetMillies(p EpClassFile->pTimer, tsDelay);365 TMTimerSetMillies(pVM, pEpClassFile->hTimer, tsDelay); 366 366 } 367 367 … … 733 733 } 734 734 735 static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser) 736 { 735 /** 736 * @callback_method_impl{FNTMTIMERINT, } 737 */ 738 static DECLCALLBACK(void) pdmacR3TimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 739 { 740 Assert(hTimer == pEpClassFile->hTimer); 737 741 uint64_t tsCur = RTTimeProgramMilliTS(); 738 742 uint64_t cMilliesNext = UINT64_MAX; … … 784 788 { 785 789 ASMAtomicWriteU64(&pEpClassFile->cMilliesNext, cMilliesNext); 786 TMTimerSetMillies(p EpClassFile->pTimer, cMilliesNext);790 TMTimerSetMillies(pVM, hTimer, cMilliesNext); 787 791 } 788 792 } … … 868 872 # ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY 869 873 rc = TMR3TimerCreate(pEpClassFile->Core.pVM, TMCLOCK_REAL, pdmacR3TimerCallback, pEpClassFile, 870 TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile-> pTimer);874 TMTIMER_FLAGS_NO_RING0, "AC Delay", &pEpClassFile->hTimer); 871 875 AssertRC(rc); 872 876 pEpClassFile->cMilliesNext = UINT64_MAX; -
trunk/src/VBox/VMM/VMMR3/PDMBlkCache.cpp
r87765 r87766 736 736 if ( !(cbDirtyOld - cbCommitted) 737 737 && pBlkCache->pCache->u32CommitTimeoutMs != 0) 738 TMTimerStop(pBlkCache->pCache->p TimerCommit);738 TMTimerStop(pBlkCache->pCache->pVM, pBlkCache->pCache->hTimerCommit); 739 739 } 740 740 … … 808 808 { 809 809 /* Arm the commit timer. */ 810 TMTimerSetMillies(pCache->p TimerCommit, pCache->u32CommitTimeoutMs);810 TMTimerSetMillies(pCache->pVM, pCache->hTimerCommit, pCache->u32CommitTimeoutMs); 811 811 } 812 812 } … … 833 833 834 834 /** 835 * Commit timer callback.836 */ 837 static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, PTMTIMER pTimer, void *pvUser)835 * @callback_method_impl{FNTMTIMERINT, Commit timer callback.} 836 */ 837 static DECLCALLBACK(void) pdmBlkCacheCommitTimerCallback(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 838 838 { 839 839 PPDMBLKCACHEGLOBAL pCache = (PPDMBLKCACHEGLOBAL)pvUser; 840 NOREF(pVM); NOREF(pTimer);840 RT_NOREF(pVM, hTimer); 841 841 842 842 LogFlowFunc(("Commit interval expired, commiting dirty entries\n")); … … 1158 1158 if (pBlkCacheGlobal->u32CommitTimeoutMs > 0) 1159 1159 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmBlkCacheCommitTimerCallback, pBlkCacheGlobal, 1160 TMTIMER_FLAGS_NO_RING0, "BlkCache-Commit", &pBlkCacheGlobal-> pTimerCommit);1160 TMTIMER_FLAGS_NO_RING0, "BlkCache-Commit", &pBlkCacheGlobal->hTimerCommit); 1161 1161 1162 1162 if (RT_SUCCESS(rc)) … … 2778 2778 VMMR3DECL(int) PDMR3BlkCacheClear(PPDMBLKCACHE pBlkCache) 2779 2779 { 2780 int rc = VINF_SUCCESS;2781 2780 PPDMBLKCACHEGLOBAL pCache = pBlkCache->pCache; 2782 2781 … … 2796 2795 2797 2796 pdmBlkCacheLockLeave(pCache); 2798 return rc;2799 } 2800 2797 return VINF_SUCCESS; 2798 } 2799 -
trunk/src/VBox/VMM/VMMR3/PDMDevHlp.cpp
r87764 r87766 439 439 Assert(fFlags & TMTIMER_FLAGS_NO_RING0 /* just to make sure all devices has been considered */); 440 440 441 PTMTIMER pTimer = NULL; 442 int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer); 443 *phTimer = (uintptr_t)pTimer; 441 int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer); 444 442 445 443 LogFlow(("pdmR3DevHlp_TimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc)); 446 444 return rc; 447 }448 449 450 /** Converts timer handle to pointer (used to exposed, will be replace soon.) */451 DECLINLINE(PTMTIMERR3) pdmR3DevHlp_TimerToPtr(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer)452 {453 PDMDEV_ASSERT_DEVINS(pDevIns);454 RT_NOREF(pDevIns);455 return (PTMTIMERR3)hTimer;456 445 } 457 446 … … 460 449 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs) 461 450 { 462 return TMTimerFromMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicroSecs); 451 PDMDEV_ASSERT_DEVINS(pDevIns); 452 return TMTimerFromMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicroSecs); 463 453 } 464 454 … … 468 458 { 469 459 PDMDEV_ASSERT_DEVINS(pDevIns); 470 return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliSecs);460 return TMTimerFromMilli(pDevIns->Internal.s.pVMR3, hTimer, cMilliSecs); 471 461 } 472 462 … … 475 465 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerFromNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs) 476 466 { 477 return TMTimerFromNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanoSecs); 467 PDMDEV_ASSERT_DEVINS(pDevIns); 468 return TMTimerFromNano(pDevIns->Internal.s.pVMR3, hTimer, cNanoSecs); 478 469 } 479 470 … … 481 472 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 482 473 { 483 return TMTimerGet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 474 PDMDEV_ASSERT_DEVINS(pDevIns); 475 return TMTimerGet(pDevIns->Internal.s.pVMR3, hTimer); 484 476 } 485 477 … … 488 480 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetFreq(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 489 481 { 490 return TMTimerGetFreq(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 482 PDMDEV_ASSERT_DEVINS(pDevIns); 483 return TMTimerGetFreq(pDevIns->Internal.s.pVMR3, hTimer); 491 484 } 492 485 … … 495 488 static DECLCALLBACK(uint64_t) pdmR3DevHlp_TimerGetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 496 489 { 497 return TMTimerGetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 490 PDMDEV_ASSERT_DEVINS(pDevIns); 491 return TMTimerGetNano(pDevIns->Internal.s.pVMR3, hTimer); 498 492 } 499 493 … … 502 496 static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsActive(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 503 497 { 504 return TMTimerIsActive(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 498 PDMDEV_ASSERT_DEVINS(pDevIns); 499 return TMTimerIsActive(pDevIns->Internal.s.pVMR3, hTimer); 505 500 } 506 501 … … 509 504 static DECLCALLBACK(bool) pdmR3DevHlp_TimerIsLockOwner(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 510 505 { 511 return TMTimerIsLockOwner(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 506 PDMDEV_ASSERT_DEVINS(pDevIns); 507 return TMTimerIsLockOwner(pDevIns->Internal.s.pVMR3, hTimer); 512 508 } 513 509 … … 516 512 static DECLCALLBACK(VBOXSTRICTRC) pdmR3DevHlp_TimerLockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, int rcBusy) 517 513 { 518 return TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy); 514 PDMDEV_ASSERT_DEVINS(pDevIns); 515 return TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy); 519 516 } 520 517 … … 524 521 PPDMCRITSECT pCritSect, int rcBusy) 525 522 { 526 VBOXSTRICTRC rc = TMTimerLock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), rcBusy); 523 PDMDEV_ASSERT_DEVINS(pDevIns); 524 VBOXSTRICTRC rc = TMTimerLock(pDevIns->Internal.s.pVMR3, hTimer, rcBusy); 527 525 if (rc == VINF_SUCCESS) 528 526 { … … 531 529 return rc; 532 530 AssertRC(VBOXSTRICTRC_VAL(rc)); 533 TMTimerUnlock(p dmR3DevHlp_TimerToPtr(pDevIns, hTimer));531 TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer); 534 532 } 535 533 else … … 542 540 static DECLCALLBACK(int) pdmR3DevHlp_TimerSet(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t uExpire) 543 541 { 544 return TMTimerSet(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uExpire); 542 PDMDEV_ASSERT_DEVINS(pDevIns); 543 return TMTimerSet(pDevIns->Internal.s.pVMR3, hTimer, uExpire); 545 544 } 546 545 … … 549 548 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetFrequencyHint(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint32_t uHz) 550 549 { 551 return TMTimerSetFrequencyHint(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), uHz); 550 PDMDEV_ASSERT_DEVINS(pDevIns); 551 return TMTimerSetFrequencyHint(pDevIns->Internal.s.pVMR3, hTimer, uHz); 552 552 } 553 553 … … 556 556 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMicro(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext) 557 557 { 558 return TMTimerSetMicro(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMicrosToNext); 558 PDMDEV_ASSERT_DEVINS(pDevIns); 559 return TMTimerSetMicro(pDevIns->Internal.s.pVMR3, hTimer, cMicrosToNext); 559 560 } 560 561 … … 563 564 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetMillies(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext) 564 565 { 565 return TMTimerSetMillies(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cMilliesToNext); 566 PDMDEV_ASSERT_DEVINS(pDevIns); 567 return TMTimerSetMillies(pDevIns->Internal.s.pVMR3, hTimer, cMilliesToNext); 566 568 } 567 569 … … 570 572 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetNano(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext) 571 573 { 572 return TMTimerSetNano(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cNanosToNext); 574 PDMDEV_ASSERT_DEVINS(pDevIns); 575 return TMTimerSetNano(pDevIns->Internal.s.pVMR3, hTimer, cNanosToNext); 573 576 } 574 577 … … 577 580 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetRelative(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now) 578 581 { 579 return TMTimerSetRelative(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), cTicksToNext, pu64Now); 582 PDMDEV_ASSERT_DEVINS(pDevIns); 583 return TMTimerSetRelative(pDevIns->Internal.s.pVMR3, hTimer, cTicksToNext, pu64Now); 580 584 } 581 585 … … 584 588 static DECLCALLBACK(int) pdmR3DevHlp_TimerStop(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 585 589 { 586 return TMTimerStop(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 590 PDMDEV_ASSERT_DEVINS(pDevIns); 591 return TMTimerStop(pDevIns->Internal.s.pVMR3, hTimer); 587 592 } 588 593 … … 591 596 static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 592 597 { 593 TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 598 PDMDEV_ASSERT_DEVINS(pDevIns); 599 TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer); 594 600 } 595 601 … … 598 604 static DECLCALLBACK(void) pdmR3DevHlp_TimerUnlockClock2(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 599 605 { 600 TMTimerUnlock(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 606 PDMDEV_ASSERT_DEVINS(pDevIns); 607 TMTimerUnlock(pDevIns->Internal.s.pVMR3, hTimer); 601 608 int rc = PDMCritSectLeave(pCritSect); 602 609 AssertRC(rc); … … 607 614 static DECLCALLBACK(int) pdmR3DevHlp_TimerSetCritSect(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 608 615 { 609 return TMR3TimerSetCritSect(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pCritSect); 616 PDMDEV_ASSERT_DEVINS(pDevIns); 617 return TMR3TimerSetCritSect(pDevIns->Internal.s.pVMR3, hTimer, pCritSect); 610 618 } 611 619 … … 614 622 static DECLCALLBACK(int) pdmR3DevHlp_TimerSave(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 615 623 { 616 return TMR3TimerSave(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM); 624 PDMDEV_ASSERT_DEVINS(pDevIns); 625 return TMR3TimerSave(pDevIns->Internal.s.pVMR3, hTimer, pSSM); 617 626 } 618 627 … … 621 630 static DECLCALLBACK(int) pdmR3DevHlp_TimerLoad(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 622 631 { 623 return TMR3TimerLoad(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer), pSSM); 632 PDMDEV_ASSERT_DEVINS(pDevIns); 633 return TMR3TimerLoad(pDevIns->Internal.s.pVMR3, hTimer, pSSM); 624 634 } 625 635 … … 628 638 static DECLCALLBACK(int) pdmR3DevHlp_TimerDestroy(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer) 629 639 { 630 return TMR3TimerDestroy(pdmR3DevHlp_TimerToPtr(pDevIns, hTimer)); 640 PDMDEV_ASSERT_DEVINS(pDevIns); 641 return TMR3TimerDestroy(pDevIns->Internal.s.pVMR3, hTimer); 631 642 } 632 643 -
trunk/src/VBox/VMM/VMMR3/PDMDriver.cpp
r87761 r87766 1337 1337 fFlags |= TMTIMER_FLAGS_NO_RING0; 1338 1338 1339 PTMTIMERR3 pTimer = NULL; 1340 int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer); 1341 if (RT_SUCCESS(rc)) 1342 *phTimer = (TMTIMERHANDLE)pTimer; 1339 int rc = TMR3TimerCreateDriver(pDrvIns->Internal.s.pVMR3, pDrvIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer); 1343 1340 1344 1341 LogFlow(("pdmR3DrvHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc *phTimer=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, *phTimer)); -
trunk/src/VBox/VMM/VMMR3/PDMQueue.cpp
r87765 r87766 39 39 DECLINLINE(void) pdmR3QueueFreeItem(PPDMQUEUE pQueue, PPDMQUEUEITEMCORE pItem); 40 40 static bool pdmR3QueueFlush(PPDMQUEUE pQueue); 41 static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);41 static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser); 42 42 43 43 … … 89 89 pQueue->pszName = pszName; 90 90 pQueue->cMilliesInterval = cMilliesInterval; 91 //pQueue->pTimer = NULL;91 pQueue->hTimer = NIL_TMTIMERHANDLE; 92 92 pQueue->cbItem = (uint32_t)cbItem; 93 93 pQueue->cItems = cItems; … … 113 113 if (cMilliesInterval) 114 114 { 115 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue-> pTimer);115 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, pdmR3QueueTimer, pQueue, TMTIMER_FLAGS_NO_RING0, "Queue timer", &pQueue->hTimer); 116 116 if (RT_SUCCESS(rc)) 117 117 { 118 rc = TMTimerSetMillies(p Queue->pTimer, cMilliesInterval);118 rc = TMTimerSetMillies(pVM, pQueue->hTimer, cMilliesInterval); 119 119 if (RT_FAILURE(rc)) 120 120 { 121 121 AssertMsgFailed(("TMTimerSetMillies failed rc=%Rrc\n", rc)); 122 int rc2 = TMR3TimerDestroy(p Queue->pTimer); AssertRC(rc2);122 int rc2 = TMR3TimerDestroy(pVM, pQueue->hTimer); AssertRC(rc2); 123 123 } 124 124 } … … 398 398 * Unlink it. 399 399 */ 400 if (pQueue-> pTimer)400 if (pQueue->hTimer != NIL_TMTIMERHANDLE) 401 401 { 402 402 if (pUVM->pdm.s.pQueuesTimer != pQueue) … … 448 448 * Destroy the timer and free it. 449 449 */ 450 if (pQueue-> pTimer)451 { 452 TMR3TimerDestroy(p Queue->pTimer);453 pQueue-> pTimer = NULL;450 if (pQueue->hTimer != NIL_TMTIMERHANDLE) 451 { 452 TMR3TimerDestroy(pVM, pQueue->hTimer); 453 pQueue->hTimer = NIL_TMTIMERHANDLE; 454 454 } 455 455 if (pQueue->pVMRC) … … 856 856 857 857 /** 858 * Timer handler for PDM queues. 859 * This is called by for a single queue. 860 * 861 * @param pVM The cross context VM structure. 862 * @param pTimer Pointer to timer. 863 * @param pvUser Pointer to the queue. 864 */ 865 static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, PTMTIMER pTimer, void *pvUser) 858 * @callback_method_impl{FNTMTIMERINT, Timer handler for one PDM queue.} 859 */ 860 static DECLCALLBACK(void) pdmR3QueueTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 866 861 { 867 862 PPDMQUEUE pQueue = (PPDMQUEUE)pvUser; 868 Assert( pTimer == pQueue->pTimer); NOREF(pTimer); NOREF(pVM);863 Assert(hTimer == pQueue->hTimer); 869 864 870 865 if ( pQueue->pPendingR3 … … 872 867 || pQueue->pPendingRC) 873 868 pdmR3QueueFlush(pQueue); 874 int rc = TMTimerSetMillies(p Queue->pTimer, pQueue->cMilliesInterval);869 int rc = TMTimerSetMillies(pVM, hTimer, pQueue->cMilliesInterval); 875 870 AssertRC(rc); 876 871 } -
trunk/src/VBox/VMM/VMMR3/PDMUsb.cpp
r87764 r87766 1833 1833 pszDesc = pszDesc2; 1834 1834 1835 PTMTIMERR3 pTimer = NULL; 1836 int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, &pTimer); 1837 if (RT_SUCCESS(rc)) 1838 *phTimer = (TMTIMERHANDLE)pTimer; 1835 int rc = TMR3TimerCreateUsb(pVM, pUsbIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, phTimer); 1839 1836 1840 1837 LogFlow(("pdmR3UsbHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc *phTimer=%p\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc, *phTimer)); … … 1843 1840 1844 1841 1845 /** Converts timer handle to pointer (will be replace soon.) */1846 DECLINLINE(PTMTIMERR3) pdmR3UsbHlp_TimerToPtr(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer)1847 {1848 PDMUSB_ASSERT_USBINS(pUsbIns);1849 RT_NOREF(pUsbIns);1850 return (PTMTIMERR3)hTimer;1851 }1852 1853 1854 1842 /** @interface_method_impl{PDMUSBHLP,pfnTimerFromMicro} */ 1855 1843 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicroSecs) 1856 1844 { 1857 return TMTimerFromMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicroSecs); 1845 PDMUSB_ASSERT_USBINS(pUsbIns); 1846 return TMTimerFromMicro(pUsbIns->Internal.s.pVM, hTimer, cMicroSecs); 1858 1847 } 1859 1848 … … 1863 1852 { 1864 1853 PDMUSB_ASSERT_USBINS(pUsbIns); 1865 return TMTimerFromMilli(pUsbIns->Internal.s.pVM, pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliSecs);1854 return TMTimerFromMilli(pUsbIns->Internal.s.pVM, hTimer, cMilliSecs); 1866 1855 } 1867 1856 … … 1870 1859 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerFromNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanoSecs) 1871 1860 { 1872 return TMTimerFromNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanoSecs); 1861 PDMUSB_ASSERT_USBINS(pUsbIns); 1862 return TMTimerFromNano(pUsbIns->Internal.s.pVM, hTimer, cNanoSecs); 1873 1863 } 1874 1864 … … 1876 1866 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1877 1867 { 1878 return TMTimerGet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1868 PDMUSB_ASSERT_USBINS(pUsbIns); 1869 return TMTimerGet(pUsbIns->Internal.s.pVM, hTimer); 1879 1870 } 1880 1871 … … 1883 1874 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetFreq(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1884 1875 { 1885 return TMTimerGetFreq(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1876 PDMUSB_ASSERT_USBINS(pUsbIns); 1877 return TMTimerGetFreq(pUsbIns->Internal.s.pVM, hTimer); 1886 1878 } 1887 1879 … … 1890 1882 static DECLCALLBACK(uint64_t) pdmR3UsbHlp_TimerGetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1891 1883 { 1892 return TMTimerGetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1884 PDMUSB_ASSERT_USBINS(pUsbIns); 1885 return TMTimerGetNano(pUsbIns->Internal.s.pVM, hTimer); 1893 1886 } 1894 1887 … … 1897 1890 static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsActive(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1898 1891 { 1899 return TMTimerIsActive(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1892 PDMUSB_ASSERT_USBINS(pUsbIns); 1893 return TMTimerIsActive(pUsbIns->Internal.s.pVM, hTimer); 1900 1894 } 1901 1895 … … 1904 1898 static DECLCALLBACK(bool) pdmR3UsbHlp_TimerIsLockOwner(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1905 1899 { 1906 return TMTimerIsLockOwner(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1900 PDMUSB_ASSERT_USBINS(pUsbIns); 1901 return TMTimerIsLockOwner(pUsbIns->Internal.s.pVM, hTimer); 1907 1902 } 1908 1903 … … 1911 1906 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1912 1907 { 1913 return TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED); 1908 PDMUSB_ASSERT_USBINS(pUsbIns); 1909 return TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED); 1914 1910 } 1915 1911 … … 1918 1914 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 1919 1915 { 1920 int rc = TMTimerLock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), VERR_IGNORED); 1916 PDMUSB_ASSERT_USBINS(pUsbIns); 1917 int rc = TMTimerLock(pUsbIns->Internal.s.pVM, hTimer, VERR_IGNORED); 1921 1918 if (rc == VINF_SUCCESS) 1922 1919 { … … 1925 1922 return rc; 1926 1923 AssertRC(rc); 1927 TMTimerUnlock(p dmR3UsbHlp_TimerToPtr(pUsbIns, hTimer));1924 TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer); 1928 1925 } 1929 1926 else … … 1936 1933 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSet(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t uExpire) 1937 1934 { 1938 return TMTimerSet(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uExpire); 1935 PDMUSB_ASSERT_USBINS(pUsbIns); 1936 return TMTimerSet(pUsbIns->Internal.s.pVM, hTimer, uExpire); 1939 1937 } 1940 1938 … … 1943 1941 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetFrequencyHint(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint32_t uHz) 1944 1942 { 1945 return TMTimerSetFrequencyHint(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), uHz); 1943 PDMUSB_ASSERT_USBINS(pUsbIns); 1944 return TMTimerSetFrequencyHint(pUsbIns->Internal.s.pVM, hTimer, uHz); 1946 1945 } 1947 1946 … … 1950 1949 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMicro(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMicrosToNext) 1951 1950 { 1952 return TMTimerSetMicro(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMicrosToNext); 1951 PDMUSB_ASSERT_USBINS(pUsbIns); 1952 return TMTimerSetMicro(pUsbIns->Internal.s.pVM, hTimer, cMicrosToNext); 1953 1953 } 1954 1954 … … 1957 1957 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetMillies(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cMilliesToNext) 1958 1958 { 1959 return TMTimerSetMillies(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cMilliesToNext); 1959 PDMUSB_ASSERT_USBINS(pUsbIns); 1960 return TMTimerSetMillies(pUsbIns->Internal.s.pVM, hTimer, cMilliesToNext); 1960 1961 } 1961 1962 … … 1964 1965 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetNano(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cNanosToNext) 1965 1966 { 1966 return TMTimerSetNano(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cNanosToNext); 1967 PDMUSB_ASSERT_USBINS(pUsbIns); 1968 return TMTimerSetNano(pUsbIns->Internal.s.pVM, hTimer, cNanosToNext); 1967 1969 } 1968 1970 … … 1971 1973 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetRelative(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, uint64_t cTicksToNext, uint64_t *pu64Now) 1972 1974 { 1973 return TMTimerSetRelative(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), cTicksToNext, pu64Now); 1975 PDMUSB_ASSERT_USBINS(pUsbIns); 1976 return TMTimerSetRelative(pUsbIns->Internal.s.pVM, hTimer, cTicksToNext, pu64Now); 1974 1977 } 1975 1978 … … 1978 1981 static DECLCALLBACK(int) pdmR3UsbHlp_TimerStop(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1979 1982 { 1980 return TMTimerStop(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1983 PDMUSB_ASSERT_USBINS(pUsbIns); 1984 return TMTimerStop(pUsbIns->Internal.s.pVM, hTimer); 1981 1985 } 1982 1986 … … 1985 1989 static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 1986 1990 { 1987 TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1991 PDMUSB_ASSERT_USBINS(pUsbIns); 1992 TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer); 1988 1993 } 1989 1994 … … 1992 1997 static DECLCALLBACK(void) pdmR3UsbHlp_TimerUnlockClock2(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 1993 1998 { 1994 TMTimerUnlock(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 1999 PDMUSB_ASSERT_USBINS(pUsbIns); 2000 TMTimerUnlock(pUsbIns->Internal.s.pVM, hTimer); 1995 2001 int rc = PDMCritSectLeave(pCritSect); 1996 2002 AssertRC(rc); … … 2001 2007 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSetCritSect(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 2002 2008 { 2003 return TMR3TimerSetCritSect(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pCritSect); 2009 PDMUSB_ASSERT_USBINS(pUsbIns); 2010 return TMR3TimerSetCritSect(pUsbIns->Internal.s.pVM, hTimer, pCritSect); 2004 2011 } 2005 2012 … … 2008 2015 static DECLCALLBACK(int) pdmR3UsbHlp_TimerSave(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 2009 2016 { 2010 return TMR3TimerSave(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM); 2017 PDMUSB_ASSERT_USBINS(pUsbIns); 2018 return TMR3TimerSave(pUsbIns->Internal.s.pVM, hTimer, pSSM); 2011 2019 } 2012 2020 … … 2015 2023 static DECLCALLBACK(int) pdmR3UsbHlp_TimerLoad(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 2016 2024 { 2017 return TMR3TimerLoad(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer), pSSM); 2025 PDMUSB_ASSERT_USBINS(pUsbIns); 2026 return TMR3TimerLoad(pUsbIns->Internal.s.pVM, hTimer, pSSM); 2018 2027 } 2019 2028 … … 2022 2031 static DECLCALLBACK(int) pdmR3UsbHlp_TimerDestroy(PPDMUSBINS pUsbIns, TMTIMERHANDLE hTimer) 2023 2032 { 2024 return TMR3TimerDestroy(pdmR3UsbHlp_TimerToPtr(pUsbIns, hTimer)); 2033 PDMUSB_ASSERT_USBINS(pUsbIns); 2034 return TMR3TimerDestroy(pUsbIns->Internal.s.pVM, hTimer); 2025 2035 } 2026 2036 -
trunk/src/VBox/VMM/VMMR3/TM.cpp
r87765 r87766 180 180 static DECLCALLBACK(int) tmR3SetWarpDrive(PUVM pUVM, uint32_t u32Percent); 181 181 #ifndef VBOX_WITHOUT_NS_ACCOUNTING 182 static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser);182 static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser); 183 183 #endif 184 184 static DECLCALLBACK(void) tmR3TimerInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs); … … 1100 1100 * Create a timer for refreshing the CPU load stats. 1101 1101 */ 1102 PTMTIMER pTimer;1103 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", & pTimer);1102 TMTIMERHANDLE hTimer; 1103 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, tmR3CpuLoadTimer, NULL, TMTIMER_FLAGS_NO_RING0, "CPU Load Timer", &hTimer); 1104 1104 if (RT_SUCCESS(rc)) 1105 rc = TMTimerSetMillies(p Timer, 1000);1105 rc = TMTimerSetMillies(pVM, hTimer, 1000); 1106 1106 #endif 1107 1107 … … 1542 1542 pTimer->u64Expire = 0; 1543 1543 pTimer->enmClock = enmClock; 1544 pTimer->hSelf = (TMTIMERHANDLE)pTimer; 1544 1545 pTimer->pVMR3 = pVM; 1545 1546 pTimer->pVMR0 = pVM->pVMR0ForCall; /** @todo fix properly */ … … 1602 1603 * @param pszDesc Pointer to description string which must stay around 1603 1604 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()). 1604 * @param p pTimer Where to store the timeron success.1605 * @param phTimer Where to store the timer handle on success. 1605 1606 */ 1606 1607 VMM_INT_DECL(int) TMR3TimerCreateDevice(PVM pVM, PPDMDEVINS pDevIns, TMCLOCK enmClock, 1607 1608 PFNTMTIMERDEV pfnCallback, void *pvUser, 1608 uint32_t fFlags, const char *pszDesc, P PTMTIMERR3 ppTimer)1609 uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer) 1609 1610 { 1610 1611 AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)), … … 1614 1615 * Allocate and init stuff. 1615 1616 */ 1616 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer); 1617 PTMTIMER pTimer; 1618 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer); 1617 1619 if (RT_SUCCESS(rc)) 1618 1620 { 1619 (*ppTimer)->enmType = TMTIMERTYPE_DEV;1620 (*ppTimer)->u.Dev.pfnTimer = pfnCallback;1621 (*ppTimer)->u.Dev.pDevIns = pDevIns;1622 (*ppTimer)->pvUser = pvUser;1621 pTimer->enmType = TMTIMERTYPE_DEV; 1622 pTimer->u.Dev.pfnTimer = pfnCallback; 1623 pTimer->u.Dev.pDevIns = pDevIns; 1624 pTimer->pvUser = pvUser; 1623 1625 if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT)) 1624 (*ppTimer)->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns); 1625 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc)); 1626 pTimer->pCritSect = PDMR3DevGetCritSect(pVM, pDevIns); 1627 *phTimer = pTimer->hSelf; 1628 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", phTimer, enmClock, pfnCallback, pszDesc)); 1626 1629 } 1627 1630 … … 1644 1647 * @param pszDesc Pointer to description string which must stay around 1645 1648 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()). 1646 * @param p pTimer Where to store the timeron success.1649 * @param phTimer Where to store the timer handle on success. 1647 1650 */ 1648 1651 VMM_INT_DECL(int) TMR3TimerCreateUsb(PVM pVM, PPDMUSBINS pUsbIns, TMCLOCK enmClock, 1649 1652 PFNTMTIMERUSB pfnCallback, void *pvUser, 1650 uint32_t fFlags, const char *pszDesc, P PTMTIMERR3 ppTimer)1653 uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer) 1651 1654 { 1652 1655 AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0)), VERR_INVALID_PARAMETER); … … 1655 1658 * Allocate and init stuff. 1656 1659 */ 1657 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer); 1660 PTMTIMER pTimer; 1661 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer); 1658 1662 if (RT_SUCCESS(rc)) 1659 1663 { 1660 (*ppTimer)->enmType = TMTIMERTYPE_USB;1661 (*ppTimer)->u.Usb.pfnTimer = pfnCallback;1662 (*ppTimer)->u.Usb.pUsbIns = pUsbIns;1663 (*ppTimer)->pvUser = pvUser;1664 pTimer->enmType = TMTIMERTYPE_USB; 1665 pTimer->u.Usb.pfnTimer = pfnCallback; 1666 pTimer->u.Usb.pUsbIns = pUsbIns; 1667 pTimer->pvUser = pvUser; 1664 1668 //if (!(fFlags & TMTIMER_FLAGS_NO_CRIT_SECT)) 1665 1669 //{ 1666 1670 // if (pDevIns->pCritSectR3) 1667 // (*ppTimer)->pCritSect = pUsbIns->pCritSectR3;1671 // pTimer->pCritSect = pUsbIns->pCritSectR3; 1668 1672 // else 1669 // (*ppTimer)->pCritSect = IOMR3GetCritSect(pVM);1673 // pTimer->pCritSect = IOMR3GetCritSect(pVM); 1670 1674 //} 1671 Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc)); 1675 *phTimer = pTimer->hSelf; 1676 Log(("TM: Created USB device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc)); 1672 1677 } 1673 1678 … … 1688 1693 * @param pszDesc Pointer to description string which must stay around 1689 1694 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()). 1690 * @param p pTimer Where to store the timeron success.1695 * @param phTimer Where to store the timer handle on success. 1691 1696 */ 1692 1697 VMM_INT_DECL(int) TMR3TimerCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, TMCLOCK enmClock, PFNTMTIMERDRV pfnCallback, void *pvUser, 1693 uint32_t fFlags, const char *pszDesc, P PTMTIMERR3 ppTimer)1698 uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer) 1694 1699 { 1695 1700 AssertReturn(!(fFlags & ~(TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0)), … … 1699 1704 * Allocate and init stuff. 1700 1705 */ 1701 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, ppTimer); 1706 PTMTIMER pTimer; 1707 int rc = tmr3TimerCreate(pVM, enmClock, fFlags, pszDesc, &pTimer); 1702 1708 if (RT_SUCCESS(rc)) 1703 1709 { 1704 (*ppTimer)->enmType = TMTIMERTYPE_DRV; 1705 (*ppTimer)->u.Drv.pfnTimer = pfnCallback; 1706 (*ppTimer)->u.Drv.pDrvIns = pDrvIns; 1707 (*ppTimer)->pvUser = pvUser; 1708 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", (*ppTimer), enmClock, pfnCallback, pszDesc)); 1710 pTimer->enmType = TMTIMERTYPE_DRV; 1711 pTimer->u.Drv.pfnTimer = pfnCallback; 1712 pTimer->u.Drv.pDrvIns = pDrvIns; 1713 pTimer->pvUser = pvUser; 1714 *phTimer = pTimer->hSelf; 1715 Log(("TM: Created device timer %p clock %d callback %p '%s'\n", *phTimer, enmClock, pfnCallback, pszDesc)); 1709 1716 } 1710 1717 … … 1724 1731 * @param pszDesc Pointer to description string which must stay around 1725 1732 * until the timer is fully destroyed (i.e. a bit after TMTimerDestroy()). 1726 * @param p pTimer Where to store the timeron success.1733 * @param phTimer Where to store the timer handle on success. 1727 1734 */ 1728 1735 VMMR3DECL(int) TMR3TimerCreate(PVM pVM, TMCLOCK enmClock, PFNTMTIMERINT pfnCallback, void *pvUser, 1729 uint32_t fFlags, const char *pszDesc, P PTMTIMERR3 ppTimer)1736 uint32_t fFlags, const char *pszDesc, PTMTIMERHANDLE phTimer) 1730 1737 { 1731 1738 AssertReturn(fFlags & (TMTIMER_FLAGS_RING0 | TMTIMER_FLAGS_NO_RING0), VERR_INVALID_FLAGS); … … 1743 1750 pTimer->u.Internal.pfnTimer = pfnCallback; 1744 1751 pTimer->pvUser = pvUser; 1745 *p pTimer = pTimer;1752 *phTimer = pTimer->hSelf; 1746 1753 Log(("TM: Created internal timer %p clock %d callback %p '%s'\n", pTimer, enmClock, pfnCallback, pszDesc)); 1747 1754 } … … 1757 1764 * @param pTimer Timer handle as returned by one of the create functions. 1758 1765 */ 1759 VMMR3DECL(int) TMR3TimerDestroy(PTMTIMER pTimer) 1760 { 1761 /* 1762 * Be extra careful here. 1763 */ 1764 if (!pTimer) 1765 return VINF_SUCCESS; 1766 AssertPtr(pTimer); 1766 static int tmR3TimerDestroy(PVMCC pVM, PTMTIMER pTimer) 1767 { 1767 1768 Assert((unsigned)pTimer->enmClock < (unsigned)TMCLOCK_MAX); 1768 1769 1769 PVM pVM = pTimer->CTX_SUFF(pVM);1770 1770 PTMTIMERQUEUE pQueue = &pVM->tm.s.CTX_SUFF(paTimerQueues)[pTimer->enmClock]; 1771 1771 bool fActive = false; … … 1925 1925 1926 1926 /** 1927 * Destroy a timer 1928 * 1929 * @returns VBox status code. 1930 * @param pVM The cross context VM structure. 1931 * @param hTimer Timer handle as returned by one of the create functions. 1932 */ 1933 VMMR3DECL(int) TMR3TimerDestroy(PVM pVM, TMTIMERHANDLE hTimer) 1934 { 1935 /* We ignore NILs here. */ 1936 if (hTimer == NIL_TMTIMERHANDLE) 1937 return VINF_SUCCESS; 1938 PTMTIMER pTimer; 1939 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 1940 return tmR3TimerDestroy(pVM, pTimer); 1941 } 1942 1943 1944 /** 1927 1945 * Destroy all timers owned by a device. 1928 1946 * … … 1946 1964 && pDestroy->u.Dev.pDevIns == pDevIns) 1947 1965 { 1948 int rc = TMR3TimerDestroy(pDestroy);1966 int rc = tmR3TimerDestroy(pVM, pDestroy); 1949 1967 AssertRC(rc); 1950 1968 } … … 1979 1997 && pDestroy->u.Usb.pUsbIns == pUsbIns) 1980 1998 { 1981 int rc = TMR3TimerDestroy(pDestroy);1999 int rc = tmR3TimerDestroy(pVM, pDestroy); 1982 2000 AssertRC(rc); 1983 2001 } … … 2012 2030 && pDestroy->u.Drv.pDrvIns == pDrvIns) 2013 2031 { 2014 int rc = TMR3TimerDestroy(pDestroy);2032 int rc = tmR3TimerDestroy(pVM, pDestroy); 2015 2033 AssertRC(rc); 2016 2034 } … … 2288 2306 case TMTIMERTYPE_USB: pTimer->u.Usb.pfnTimer(pTimer->u.Usb.pUsbIns, pTimer, pTimer->pvUser); break; 2289 2307 case TMTIMERTYPE_DRV: pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break; 2290 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer , pTimer->pvUser); break;2308 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break; 2291 2309 default: 2292 2310 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; 2473 2491 case TMTIMERTYPE_DRV: pTimer->u.Drv.pfnTimer(pTimer->u.Drv.pDrvIns, pTimer, pTimer->pvUser); break; 2474 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer , pTimer->pvUser); break;2492 case TMTIMERTYPE_INTERNAL: pTimer->u.Internal.pfnTimer(pVM, pTimer->hSelf, pTimer->pvUser); break; 2475 2493 default: 2476 2494 AssertMsgFailed(("Invalid timer type %d (%s)\n", pTimer->enmType, pTimer->pszDesc)); … … 2696 2714 * 2697 2715 * @returns VBox status code. 2698 * @param pTimer Timer to save. 2716 * @param pVM The cross context VM structure. 2717 * @param hTimer Timer to save. 2699 2718 * @param pSSM Save State Manager handle. 2700 2719 */ 2701 VMMR3DECL(int) TMR3TimerSave(PTMTIMERR3 pTimer, PSSMHANDLE pSSM) 2702 { 2720 VMMR3DECL(int) TMR3TimerSave(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 2721 { 2722 VM_ASSERT_EMT(pVM); 2723 PTMTIMER pTimer; 2724 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2703 2725 LogFlow(("TMR3TimerSave: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM)); 2726 2704 2727 switch (pTimer->enmState) 2705 2728 { … … 2738 2761 * 2739 2762 * @returns VBox status code. 2740 * @param pTimer Timer to restore. 2763 * @param pVM The cross context VM structure. 2764 * @param hTimer Handle of Timer to restore. 2741 2765 * @param pSSM Save State Manager handle. 2742 2766 */ 2743 VMMR3DECL(int) TMR3TimerLoad(PTMTIMERR3 pTimer, PSSMHANDLE pSSM) 2744 { 2745 Assert(pTimer); Assert(pSSM); VM_ASSERT_EMT(pTimer->pVMR3); 2767 VMMR3DECL(int) TMR3TimerLoad(PVM pVM, TMTIMERHANDLE hTimer, PSSMHANDLE pSSM) 2768 { 2769 VM_ASSERT_EMT(pVM); 2770 PTMTIMER pTimer; 2771 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2772 Assert(pSSM); 2746 2773 LogFlow(("TMR3TimerLoad: %p:{enmState=%s, .pszDesc={%s}} pSSM=%p\n", pTimer, tmTimerState(pTimer->enmState), pTimer->pszDesc, pSSM)); 2747 2774 … … 2787 2814 */ 2788 2815 Log(("u8State=%d u64Expire=%llu\n", u8State, u64Expire)); 2789 rc = TMTimerSet(p Timer, u64Expire);2816 rc = TMTimerSet(pVM, hTimer, u64Expire); 2790 2817 } 2791 2818 else … … 2795 2822 */ 2796 2823 Log(("u8State=%d\n", u8State)); 2797 rc = TMTimerStop(p Timer);2824 rc = TMTimerStop(pVM, hTimer); 2798 2825 } 2799 2826 … … 2887 2914 * active. 2888 2915 */ 2889 VMMR3DECL(int) TMR3TimerSetCritSect(PTMTIMERR3 pTimer, PPDMCRITSECT pCritSect) 2890 { 2891 AssertPtrReturn(pTimer, VERR_INVALID_HANDLE); 2916 VMMR3DECL(int) TMR3TimerSetCritSect(PVM pVM, TMTIMERHANDLE hTimer, PPDMCRITSECT pCritSect) 2917 { 2918 PTMTIMER pTimer; 2919 TMTIMER_HANDLE_TO_PTR_RETURN(pVM, hTimer, pTimer); 2892 2920 AssertPtrReturn(pCritSect, VERR_INVALID_PARAMETER); 2893 2921 const char *pszName = PDMR3CritSectName(pCritSect); /* exploited for validation */ … … 3414 3442 3415 3443 /** 3416 * Timer callback that calculates the CPU load since the last time it was 3417 * called. 3418 * 3419 * @param pVM The cross context VM structure. 3420 * @param pTimer The timer. 3421 * @param pvUser NULL, unused. 3422 */ 3423 static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, PTMTIMER pTimer, void *pvUser) 3444 * @callback_method_impl{FNTMTIMERINT, 3445 * Timer callback that calculates the CPU load since the last 3446 * time it was called.} 3447 */ 3448 static DECLCALLBACK(void) tmR3CpuLoadTimer(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 3424 3449 { 3425 3450 /* 3426 3451 * Re-arm the timer first. 3427 3452 */ 3428 int rc = TMTimerSetMillies(p Timer, 1000);3453 int rc = TMTimerSetMillies(pVM, hTimer, 1000); 3429 3454 AssertLogRelRC(rc); 3430 3455 NOREF(pvUser); … … 3680 3705 pTimer->offScheduleNext, 3681 3706 tmR3Get5CharClockName(pTimer->enmClock), 3682 TMTimerGet(p Timer),3707 TMTimerGet(pVM, pTimer->hSelf), 3683 3708 pTimer->u64Expire, 3684 3709 pTimer->uHzHint, … … 3726 3751 pTimer->offScheduleNext, 3727 3752 tmR3Get5CharClockName(pTimer->enmClock), 3728 TMTimerGet(p Timer),3753 TMTimerGet(pVM, pTimer->hSelf), 3729 3754 pTimer->u64Expire, 3730 3755 pTimer->uHzHint, -
trunk/src/VBox/VMM/VMMR3/VMM.cpp
r87765 r87766 169 169 static DECLCALLBACK(int) vmmR3Save(PVM pVM, PSSMHANDLE pSSM); 170 170 static DECLCALLBACK(int) vmmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass); 171 static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser);171 static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser); 172 172 static VBOXSTRICTRC vmmR3EmtRendezvousCommon(PVM pVM, PVMCPU pVCpu, bool fIsCaller, 173 173 uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser); … … 661 661 */ 662 662 rc = TMR3TimerCreate(pVM, TMCLOCK_REAL, vmmR3YieldEMT, NULL, TMTIMER_FLAGS_NO_RING0, 663 "EMT Yielder", &pVM->vmm.s. pYieldTimer);663 "EMT Yielder", &pVM->vmm.s.hYieldTimer); 664 664 AssertRCReturn(rc, rc); 665 665 666 rc = TMTimerSetMillies(pVM ->vmm.s.pYieldTimer, pVM->vmm.s.cYieldEveryMillies);666 rc = TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldEveryMillies); 667 667 AssertRCReturn(rc, rc); 668 668 break; … … 998 998 if (!pVM->vmm.s.cYieldResumeMillies) 999 999 { 1000 uint64_t u64Now = TMTimerGet(pVM ->vmm.s.pYieldTimer);1001 uint64_t u64Expire = TMTimerGetExpire(pVM ->vmm.s.pYieldTimer);1000 uint64_t u64Now = TMTimerGet(pVM, pVM->vmm.s.hYieldTimer); 1001 uint64_t u64Expire = TMTimerGetExpire(pVM, pVM->vmm.s.hYieldTimer); 1002 1002 if (u64Now >= u64Expire || u64Expire == ~(uint64_t)0) 1003 1003 pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies; 1004 1004 else 1005 pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM ->vmm.s.pYieldTimer, u64Expire - u64Now);1006 TMTimerStop(pVM ->vmm.s.pYieldTimer);1005 pVM->vmm.s.cYieldResumeMillies = TMTimerToMilli(pVM, pVM->vmm.s.hYieldTimer, u64Expire - u64Now); 1006 TMTimerStop(pVM, pVM->vmm.s.hYieldTimer); 1007 1007 } 1008 1008 pVM->vmm.s.u64LastYield = RTTimeNanoTS(); … … 1018 1018 { 1019 1019 if (!pVM->vmm.s.cYieldResumeMillies) 1020 TMTimerStop(pVM ->vmm.s.pYieldTimer);1020 TMTimerStop(pVM, pVM->vmm.s.hYieldTimer); 1021 1021 pVM->vmm.s.cYieldResumeMillies = pVM->vmm.s.cYieldEveryMillies; 1022 1022 pVM->vmm.s.u64LastYield = RTTimeNanoTS(); … … 1033 1033 if (pVM->vmm.s.cYieldResumeMillies) 1034 1034 { 1035 TMTimerSetMillies(pVM ->vmm.s.pYieldTimer, pVM->vmm.s.cYieldResumeMillies);1035 TMTimerSetMillies(pVM, pVM->vmm.s.hYieldTimer, pVM->vmm.s.cYieldResumeMillies); 1036 1036 pVM->vmm.s.cYieldResumeMillies = 0; 1037 1037 } … … 1040 1040 1041 1041 /** 1042 * Internal timer callback function. 1043 * 1044 * @param pVM The cross context VM structure. 1045 * @param pTimer The timer handle. 1046 * @param pvUser User argument specified upon timer creation. 1047 */ 1048 static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, PTMTIMER pTimer, void *pvUser) 1042 * @callback_method_impl{FNTMTIMERINT, EMT yielder} 1043 * 1044 * @todo This is a UNI core/thread thing, really... Should be reconsidered. 1045 */ 1046 static DECLCALLBACK(void) vmmR3YieldEMT(PVM pVM, TMTIMERHANDLE hTimer, void *pvUser) 1049 1047 { 1050 1048 NOREF(pvUser); … … 1077 1075 #endif 1078 1076 } 1079 TMTimerSetMillies(p Timer, pVM->vmm.s.cYieldEveryMillies);1077 TMTimerSetMillies(pVM, hTimer, pVM->vmm.s.cYieldEveryMillies); 1080 1078 } 1081 1079 -
trunk/src/VBox/VMM/include/CPUMInternal.h
r87361 r87766 417 417 CPUMCTXMSRS GuestMsrs; 418 418 419 /** Nested VMX: VMX-preemption timer - R0 ptr. */ 420 PTMTIMERR0 pNestedVmxPreemptTimerR0; 421 /** Nested VMX: VMX-preemption timer - R3 ptr. */ 422 PTMTIMERR3 pNestedVmxPreemptTimerR3; 419 /** Nested VMX: VMX-preemption timer. */ 420 TMTIMERHANDLE hNestedVmxPreemptTimer; 423 421 424 422 /** Use flags. … … 459 457 460 458 /** Align the next member on a 64-byte boundary. */ 461 uint8_t abPadding2[64 - ( 16+ 12 + 4 + 8 + 1 + 1)];459 uint8_t abPadding2[64 - (8 + 12 + 4 + 8 + 1 + 1)]; 462 460 463 461 /** Saved host context. Only valid while inside RC or HM contexts. -
trunk/src/VBox/VMM/include/CPUMInternal.mac
r87522 r87766 259 259 ; Other stuff. 260 260 ; 261 .pNestedVmxPreemptTimerR0 RTR0PTR_RES 1 262 .pNestedVmxPreemptTimerR3 RTR3PTR_RES 1 261 .hNestedVmxPreemptTimer resq 1 263 262 264 263 .fUseFlags resd 1 … … 275 274 276 275 .fCpuIdApicFeatureVisible resb 1 277 278 .abPadding2 resb (64 - (RTR0PTR_CB + RTR3PTR_CB + 12 + 4 + RTR0PTR_CB + 1 + 1))279 276 280 277 ; -
trunk/src/VBox/VMM/include/GIMHvInternal.h
r82968 r87766 1263 1263 typedef struct GIMHVSTIMER 1264 1264 { 1265 /** Synthetic timer object - R0 ptr. */ 1266 PTMTIMERR0 pTimerR0; 1267 /** Synthetic timer object - R3 ptr. */ 1268 PTMTIMERR3 pTimerR3; 1265 /** Synthetic timer handle. */ 1266 TMTIMERHANDLE hTimer; 1269 1267 /** Virtual CPU ID this timer belongs to (for reverse mapping). */ 1270 1268 VMCPUID idCpu; -
trunk/src/VBox/VMM/include/PDMAsyncCompletionFileInternal.h
r85121 r87766 277 277 #ifdef PDM_ASYNC_COMPLETION_FILE_WITH_DELAY 278 278 /** Timer for delayed request completion. */ 279 PTMTIMERR3 pTimer;279 TMTIMERHANDLE hTimer; 280 280 /** Milliseconds until the next delay expires. */ 281 281 volatile uint64_t cMilliesNext; -
trunk/src/VBox/VMM/include/PDMBlkCacheInternal.h
r82968 r87766 134 134 volatile bool fCommitInProgress; 135 135 /** Commit interval timer */ 136 PTMTIMERR3 pTimerCommit;136 TMTIMERHANDLE hTimerCommit; 137 137 /** Number of endpoints using the cache. */ 138 138 uint32_t cRefs; -
trunk/src/VBox/VMM/include/PDMInternal.h
r87494 r87766 1044 1044 uint32_t cMilliesInterval; 1045 1045 /** Interval timer. Only used if cMilliesInterval is non-zero. */ 1046 PTMTIMERR3 pTimer;1046 TMTIMERHANDLE hTimer; 1047 1047 /** Pointer to the VM - R3. */ 1048 1048 PVMR3 pVMR3; -
trunk/src/VBox/VMM/include/TMInline.h
r82968 r87766 56 56 } 57 57 58 59 /** @def TMTIMER_HANDLE_TO_PTR_RETURN_EX 60 * Converts a timer handle to a timer pointer, returning @a a_rcRet if the 61 * handle is invalid. 62 * 63 * @param a_pVM The cross context VM structure. 64 * @param a_hTimer The timer handle to translate. 65 * @param a_rcRet What to return on failure. 66 * @param a_pTimerVar The timer variable to assign the resulting pointer to. 67 */ 68 #ifdef IN_RING3 69 # define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \ 70 RT_NOREF(a_pVM); \ 71 (a_pTimerVar) = (PTMTIMER)hTimer; \ 72 AssertPtrReturn((a_pTimerVar), a_rcRet); \ 73 AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \ 74 } while (0) 75 #else 76 # define TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, a_rcRet, a_pTimerVar) do { \ 77 (a_pTimerVar) = (PTMTIMER)MMHyperR3ToCC(pVM, (RTR3PTR)hTimer); \ 78 AssertPtrReturn((a_pTimerVar), a_rcRet); \ 79 AssertReturn((a_pTimerVar)->hSelf == a_hTimer, a_rcRet); \ 80 Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \ 81 } while (0) 82 #endif 83 84 /** @def TMTIMER_HANDLE_TO_PTR_RETURN 85 * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if 86 * invalid. 87 * 88 * @param a_pVM The cross context VM structure. 89 * @param a_hTimer The timer handle to translate. 90 * @param a_pTimerVar The timer variable to assign the resulting pointer to. 91 */ 92 #define TMTIMER_HANDLE_TO_PTR_RETURN(a_pVM, a_hTimer, a_pTimerVar) \ 93 TMTIMER_HANDLE_TO_PTR_RETURN_EX(a_pVM, a_hTimer, VERR_INVALID_HANDLE, a_pTimerVar) 94 95 /** @def TMTIMER_HANDLE_TO_PTR_RETURN_VOID 96 * Converts a timer handle to a timer pointer, returning VERR_INVALID_HANDLE if 97 * invalid. 98 * 99 * @param a_pVM The cross context VM structure. 100 * @param a_hTimer The timer handle to translate. 101 * @param a_pTimerVar The timer variable to assign the resulting pointer to. 102 */ 103 #ifdef IN_RING3 104 # define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \ 105 RT_NOREF(a_pVM); \ 106 (a_pTimerVar) = (PTMTIMER)hTimer; \ 107 AssertPtrReturnVoid((a_pTimerVar)); \ 108 AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \ 109 } while (0) 110 #else 111 # define TMTIMER_HANDLE_TO_PTR_RETURN_VOID(a_pVM, a_hTimer, a_pTimerVar) do { \ 112 (a_pTimerVar) = (PTMTIMER)MMHyperR3ToCC(pVM, (RTR3PTR)hTimer); \ 113 AssertPtrReturnVoid((a_pTimerVar)); \ 114 AssertReturnVoid((a_pTimerVar)->hSelf == a_hTimer); \ 115 Assert((a_pTimerVar)->fFlags & TMTIMER_FLAGS_RING0); \ 116 } while (0) 117 #endif 118 119 58 120 #endif /* !VMM_INCLUDED_SRC_include_TMInline_h */ 59 121 -
trunk/src/VBox/VMM/include/TMInternal.h
r87763 r87766 174 174 int32_t offPrev; 175 175 176 /** It's own handle value. */ 177 TMTIMERHANDLE hSelf; 176 178 /** Pointer to the VM the timer belongs to - R3 Ptr. */ 177 179 PVMR3 pVMR3; … … 200 202 /** TMTIMER_FLAGS_XXX. */ 201 203 uint32_t fFlags; 202 uint32_t u32Pad ing;204 uint32_t u32Padding; 203 205 204 206 #ifdef VBOX_WITH_STATISTICS -
trunk/src/VBox/VMM/include/VMMInternal.h
r85121 r87766 193 193 194 194 /** The EMT yield timer. */ 195 PTMTIMERR3 pYieldTimer;195 TMTIMERHANDLE hYieldTimer; 196 196 /** The period to the next timeout when suspended or stopped. 197 197 * This is 0 when running. */
Note:
See TracChangeset
for help on using the changeset viewer.

