Index: /trunk/include/VBox/vmm/pgm.h =================================================================== --- /trunk/include/VBox/vmm/pgm.h (revision 55895) +++ /trunk/include/VBox/vmm/pgm.h (revision 55896) @@ -102,7 +102,8 @@ * @param pvUser User argument. */ -typedef DECLCALLBACK(int) FNPGMRCPHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); +typedef DECLCALLBACK(int) FNPGMRCPHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser); /** Pointer to PGM access callback. */ -typedef FNPGMRCPHYSHANDLER *PFNPGMRCPHYSHANDLER; +typedef FNPGMRCPHYSPFHANDLER *PFNPGMRCPHYSPFHANDLER; /** @@ -118,7 +119,8 @@ * @param pvUser User argument. */ -typedef DECLCALLBACK(int) FNPGMR0PHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); +typedef DECLCALLBACK(int) FNPGMR0PHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser); /** Pointer to PGM access callback. */ -typedef FNPGMR0PHYSHANDLER *PFNPGMR0PHYSHANDLER; +typedef FNPGMR0PHYSPFHANDLER *PFNPGMR0PHYSPFHANDLER; /** @@ -151,5 +153,6 @@ * @todo Add pVCpu, possibly replacing pVM. */ -typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser); +typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, + PGMACCESSTYPE enmAccessType, void *pvUser); /** Pointer to PGM access callback. */ typedef FNPGMR3PHYSHANDLER *PFNPGMR3PHYSHANDLER; @@ -539,11 +542,11 @@ VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind, PFNPGMR3PHYSHANDLER pfnHandlerR3, - R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, - RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, + R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0, + RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC, const char *pszDesc, PPGMPHYSHANDLERTYPE phType); VMMR3DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, - const char *pszModR0, const char *pszHandlerR0, - const char *pszModRC, const char *pszHandlerRC, const char *pszDesc, + const char *pszModR0, const char *pszPfHandlerR0, + const char *pszModRC, const char *pszPfHandlerRC, const char *pszDesc, PPGMPHYSHANDLERTYPE phType); VMMR3_INT_DECL(int) PGMR3HandlerVirtualTypeRegisterEx(PVM pVM, PGMVIRTHANDLERKIND enmKind, bool fRelocUserRC, Index: /trunk/src/VBox/Devices/Graphics/DevVGA.cpp =================================================================== --- /trunk/src/VBox/Devices/Graphics/DevVGA.cpp (revision 55895) +++ /trunk/src/VBox/Devices/Graphics/DevVGA.cpp (revision 55896) @@ -3524,28 +3524,17 @@ -#ifdef IN_RC +#ifndef IN_RING3 +RT_C_DECLS_BEGIN +DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) vgaLbfAccessPfHandler; +RT_C_DECLS_END + /** * @callback_method_impl{FNPGMRCPHYSHANDLER, \#PF Handler for VBE LFB access.} */ -PDMBOTHCBDECL(int) vgaRCLFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) +PDMBOTHCBDECL(int) vgaLbfAccessPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser) { PVGASTATE pThis = (PVGASTATE)pvUser; AssertPtr(pThis); - Assert(GCPhysFault >= pThis->GCPhysVRAM); - AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode)); - NOREF(pRegFrame); - - return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault); -} - -#elif IN_RING0 - -/** - * @callback_method_impl{FNPGMR0PHYSHANDLER, \#PF Handler for VBE LFB access.} - */ -PDMBOTHCBDECL(int) vgaR0LFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) -{ - PVGASTATE pThis = (PVGASTATE)pvUser; - Assert(pThis); Assert(GCPhysFault >= pThis->GCPhysVRAM); AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode)); @@ -6220,6 +6209,6 @@ rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, vgaR3LFBAccessHandler, - g_DeviceVga.szR0Mod, "vgaR0LFBAccessHandler", - g_DeviceVga.szRCMod, "vgaRCLFBAccessHandler", + g_DeviceVga.szR0Mod, "vgaLbfAccessPfHandler", + g_DeviceVga.szRCMod, "vgaLbfAccessPfHandler", "VGA LFB", &pThis->hLfbAccessHandlerType); AssertRCReturn(rc, rc); Index: /trunk/src/VBox/Devices/Network/DevPCNet.cpp =================================================================== --- /trunk/src/VBox/Devices/Network/DevPCNet.cpp (revision 55895) +++ /trunk/src/VBox/Devices/Network/DevPCNet.cpp (revision 55896) @@ -1075,10 +1075,4 @@ } -RT_C_DECLS_BEGIN -#ifndef IN_RING3 -DECLEXPORT(int) pcnetHandleRingWrite(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, - RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); -#endif -RT_C_DECLS_END #undef htonl @@ -1096,4 +1090,7 @@ #ifdef PCNET_NO_POLLING # ifndef IN_RING3 +RT_C_DECLS_BEGIN +DECLEXPORT(CTX_SUFF(FNPGM,PHYSPFHANDLER)) pcnetHandleRingWritePf; +RT_C_DECLS_END /** @@ -1108,10 +1105,10 @@ * @param pvUser User argument. */ -DECLEXPORT(int) pcnetHandleRingWrite(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, - RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) +DECLEXPORT(int) pcnetHandleRingWritePf(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, + RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) { PPCNETSTATE pThis = (PPCNETSTATE)pvUser; - Log(("#%d pcnetHandleRingWriteGC: write to %#010x\n", PCNET_INST_NR, GCPhysFault)); + Log(("#%d pcnetHandleRingWritePf: write to %#010x\n", PCNET_INST_NR, GCPhysFault)); uint32_t cb; @@ -1168,11 +1165,11 @@ * @param pvUser User argument. */ -static DECLCALLBACK(int) pcnetHandleRingWrite(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, - size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser) +static DECLCALLBACK(int) pcnetR3HandleRingWrite(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, + size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser) { PPDMDEVINS pDevIns = (PPDMDEVINS)pvUser; PPCNETSTATE pThis = PDMINS_2_DATA(pDevIns, PPCNETSTATE); - Log(("#%d pcnetHandleRingWrite: write to %#010x\n", PCNET_INST_NR, GCPhys)); + Log(("#%d pcnetR3HandleRingWrite: write to %#010x\n", PCNET_INST_NR, GCPhys)); #ifdef VBOX_WITH_STATISTICS STAM_COUNTER_INC(&CTXSUFF(pThis->StatRingWrite)); @@ -4976,7 +4973,7 @@ rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pDevIns), PGMPHYSHANDLERKIND_WRITE, - pcnetHandleRingWrite, - g_DevicePCNet.szR0Mod, "pcnetHandleRingWrite", - g_DevicePCNet.szRCMod, "pcnetHandleRingWrite", + pcnetR3HandleRingWrite, + g_DevicePCNet.szR0Mod, "pcnetHandleRingWritePf", + g_DevicePCNet.szRCMod, "pcnetHandleRingWritePf", "PCNet ring write access handler", &pThis->hNoPollingHandlerType); Index: /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMAll/IOMAllMMIO.cpp (revision 55896) @@ -1741,7 +1741,8 @@ * @param pvUser Pointer to the MMIO ring-3 range entry. */ -VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) -{ - LogFlow(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n", +DECLEXPORT(int) iomMmioPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser) +{ + LogFlow(("iomMmioPfHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n", GCPhysFault, (uint32_t)uErrorCode, pvFault, (RTGCPTR)pCtxCore->rip)); VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, VMMGetCpu(pVM), (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser); @@ -1799,5 +1800,5 @@ * @param pvUser Pointer to the MMIO range entry. */ -DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf, +DECLCALLBACK(int) iomR3MmioHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser) { Index: /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h =================================================================== --- /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h (revision 55895) +++ /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h (revision 55896) @@ -248,13 +248,8 @@ } - if (pCurType->CTX_SUFF(pfnHandler)) + if (pCurType->CTX_SUFF(pfnPfHandler)) { - PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool); - void *pvUser = pCur->CTX_SUFF(pvUser); -# ifdef IN_RING0 - PFNPGMR0PHYSHANDLER pfnHandler = pCurType->CTX_SUFF(pfnHandler); -# else - PFNPGMRCPHYSHANDLER pfnHandler = pCurType->CTX_SUFF(pfnHandler); -# endif + PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool); + void *pvUser = pCur->CTX_SUFF(pvUser); STAM_PROFILE_START(&pCur->Stat, h); @@ -265,5 +260,5 @@ } - rc = pfnHandler(pVM, uErr, pRegFrame, pvFault, GCPhysFault, pvUser); + rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPhysFault, pvUser); # ifdef VBOX_WITH_STATISTICS Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp (revision 55896) @@ -64,5 +64,6 @@ * @param pvUser User argument. */ -VMMDECL(int) pgmPhysHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) +VMMDECL(int) pgmPhysPfHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser) { NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser); @@ -83,5 +84,6 @@ * @param pvUser User argument. Pointer to the ROM range structure. */ -VMMDECL(int) pgmPhysRomWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser) +DECLEXPORT(int) pgmPhysRomWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser) { int rc; @@ -2355,5 +2357,4 @@ { Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast); - Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler)); size_t cbRange = pCur->Core.KeyLast - GCPhys + 1; @@ -2368,4 +2369,5 @@ #else /* IN_RING3 */ + Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler)); Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) )); Index: /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp (revision 55896) @@ -52,5 +52,5 @@ static void pgmPoolMonitorModifiedRemove(PPGMPOOL pPool, PPGMPOOLPAGE pPage); #ifndef IN_RING3 -DECLEXPORT(int) pgmPoolAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); +DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPoolAccessPfHandler; #endif #if defined(LOG_ENABLED) || defined(VBOX_STRICT) @@ -823,6 +823,6 @@ * @todo VBOXSTRICTRC */ -static int pgmPoolAccessHandlerFlush(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, - PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault) +static int pgmPoolAccessPfHandlerFlush(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, + PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault) { NOREF(pVM); NOREF(GCPhysFault); @@ -855,5 +855,5 @@ if (PATMIsPatchGCAddr(pVM, pRegFrame->eip)) { - LogFlow(("pgmPoolAccessHandlerPTWorker: Interpretation failed for patch code %04x:%RGv, ignoring.\n", + LogFlow(("pgmPoolAccessPfHandlerPTWorker: Interpretation failed for patch code %04x:%RGv, ignoring.\n", pRegFrame->cs.Sel, (RTGCPTR)pRegFrame->eip)); rc = VINF_SUCCESS; @@ -872,5 +872,5 @@ AssertMsgFailed(("%Rrc\n", VBOXSTRICTRC_VAL(rc2))); /* ASSUMES no complicated stuff here. */ - LogFlow(("pgmPoolAccessHandlerPT: returns %Rrc (flushed)\n", rc)); + LogFlow(("pgmPoolAccessPfHandlerPT: returns %Rrc (flushed)\n", rc)); return rc; } @@ -889,6 +889,6 @@ * @param pvFault The fault address. */ -DECLINLINE(int) pgmPoolAccessHandlerSTOSD(PVM pVM, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, - PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault) +DECLINLINE(int) pgmPoolAccessPfHandlerSTOSD(PVM pVM, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, + PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault) { unsigned uIncrement = pDis->Param1.cb; @@ -905,5 +905,5 @@ #endif - Log3(("pgmPoolAccessHandlerSTOSD\n")); + Log3(("pgmPoolAccessPfHandlerSTOSD\n")); /* @@ -943,5 +943,5 @@ pRegFrame->rip += pDis->cbInstr; - LogFlow(("pgmPoolAccessHandlerSTOSD: returns\n")); + LogFlow(("pgmPoolAccessPfHandlerSTOSD: returns\n")); return VINF_SUCCESS; } @@ -962,8 +962,8 @@ * @param pfReused Reused state (in/out) */ -DECLINLINE(int) pgmPoolAccessHandlerSimple(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, - PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault, bool *pfReused) -{ - Log3(("pgmPoolAccessHandlerSimple\n")); +DECLINLINE(int) pgmPoolAccessPfHandlerSimple(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis, + PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault, bool *pfReused) +{ + Log3(("pgmPoolAccessPfHandlerSimple\n")); NOREF(pVM); NOREF(pfReused); /* initialized by caller */ @@ -1005,5 +1005,5 @@ else if (rc == VERR_EM_INTERPRETER) { - LogFlow(("pgmPoolAccessHandlerPTWorker: Interpretation failed for %04x:%RGv - opcode=%d\n", + LogFlow(("pgmPoolAccessPfHandlerPTWorker: Interpretation failed for %04x:%RGv - opcode=%d\n", pRegFrame->cs.Sel, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->uOpcode)); rc = VINF_EM_RAW_EMULATE_INSTR; @@ -1041,5 +1041,5 @@ #endif - LogFlow(("pgmPoolAccessHandlerSimple: returns %Rrc\n", VBOXSTRICTRC_VAL(rc))); + LogFlow(("pgmPoolAccessPfHandlerSimple: returns %Rrc\n", VBOXSTRICTRC_VAL(rc))); return VBOXSTRICTRC_VAL(rc); } @@ -1058,6 +1058,6 @@ * @param pvUser User argument. */ -DECLEXPORT(int) pgmPoolAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, - RTGCPHYS GCPhysFault, void *pvUser) +DECLEXPORT(int) pgmPoolAccessPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, + RTGCPHYS GCPhysFault, void *pvUser) { STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), a); @@ -1069,5 +1069,5 @@ NOREF(uErrorCode); - LogFlow(("pgmPoolAccessHandler: pvFault=%RGv pPage=%p:{.idx=%d} GCPhysFault=%RGp\n", pvFault, pPage, pPage->idx, GCPhysFault)); + LogFlow(("pgmPoolAccessPfHandler: pvFault=%RGv pPage=%p:{.idx=%d} GCPhysFault=%RGp\n", pvFault, pPage, pPage->idx, GCPhysFault)); pgmLock(pVM); @@ -1075,5 +1075,5 @@ { /* Pool page changed while we were waiting for the lock; ignore. */ - Log(("CPU%d: pgmPoolAccessHandler pgm pool page for %RGp changed (to %RGp) while waiting!\n", pVCpu->idCpu, PHYS_PAGE_ADDRESS(GCPhysFault), PHYS_PAGE_ADDRESS(pPage->GCPhys))); + Log(("CPU%d: pgmPoolAccessPfHandler pgm pool page for %RGp changed (to %RGp) while waiting!\n", pVCpu->idCpu, PHYS_PAGE_ADDRESS(GCPhysFault), PHYS_PAGE_ADDRESS(pPage->GCPhys))); STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), &pPool->CTX_MID_Z(StatMonitor,Handled), a); pgmUnlock(pVM); @@ -1173,5 +1173,5 @@ if (!(pDis->fPrefix & (DISPREFIX_REP | DISPREFIX_REPNE))) { - rc = pgmPoolAccessHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused); + rc = pgmPoolAccessPfHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused); if (fReused) goto flushPage; @@ -1244,5 +1244,5 @@ if (fValidStosd) { - rc = pgmPoolAccessHandlerSTOSD(pVM, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault); + rc = pgmPoolAccessPfHandlerSTOSD(pVM, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault); STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), &pPool->CTX_MID_Z(StatMonitor,RepStosd), a); pgmUnlock(pVM); @@ -1253,5 +1253,5 @@ /* REP prefix, don't bother. */ STAM_COUNTER_INC(&pPool->CTX_MID_Z(StatMonitor,RepPrefix)); - Log4(("pgmPoolAccessHandler: eax=%#x ecx=%#x edi=%#x esi=%#x rip=%RGv opcode=%d prefix=%#x\n", + Log4(("pgmPoolAccessPfHandler: eax=%#x ecx=%#x edi=%#x esi=%#x rip=%RGv opcode=%d prefix=%#x\n", pRegFrame->eax, pRegFrame->ecx, pRegFrame->edi, pRegFrame->esi, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->uOpcode, pDis->fPrefix)); fNotReusedNotForking = true; @@ -1341,5 +1341,5 @@ * the reuse detection must be fixed. */ - rc = pgmPoolAccessHandlerFlush(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault); + rc = pgmPoolAccessPfHandlerFlush(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault); if ( rc == VINF_EM_RAW_EMULATE_INSTR && fReused) Index: /trunk/src/VBox/VMM/VMMR0/PGMR0.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR0/PGMR0.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMR0/PGMR0.cpp (revision 55896) @@ -580,13 +580,13 @@ else { - if (pHandlerType->CTX_SUFF(pfnHandler)) + if (pHandlerType->CTX_SUFF(pfnPfHandler)) { - CTX_MID(PFNPGM,PHYSHANDLER) pfnHandler = pHandlerType->CTX_SUFF(pfnHandler); - void *pvUser = pHandler->CTX_SUFF(pvUser); + void *pvUser = pHandler->CTX_SUFF(pvUser); STAM_PROFILE_START(&pHandler->Stat, h); pgmUnlock(pVM); - Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pfnHandler, uErr, GCPhysFault, pvUser)); - rc = pfnHandler(pVM, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame, GCPhysFault, GCPhysFault, pvUser); + Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->CTX_SUFF(pfnPfHandler), uErr, GCPhysFault, pvUser)); + rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pVM, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame, + GCPhysFault, GCPhysFault, pvUser); #ifdef VBOX_WITH_STATISTICS Index: /trunk/src/VBox/VMM/VMMR3/IOM.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/IOM.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMR3/IOM.cpp (revision 55896) @@ -42,8 +42,8 @@ * with the PGM access handler sub-system. The access handler catches all * access and will be called in the context of a \#PF handler. In RC and R0 this - * handler is IOMMMIOHandler while in ring-3 it's IOMR3MMIOHandler (although in - * ring-3 there can be alternative ways). IOMMMIOHandler will attempt to emulate - * the instruction that is doing the access and pass the corresponding reads / - * writes to the device. + * handler is iomMmioPfHandler while in ring-3 it's iomR3MmioHandler (although + * in ring-3 there can be alternative ways). iomMmioPfHandler will attempt to + * emulate the instruction that is doing the access and pass the corresponding + * reads / writes to the device. * * Emulating I/O port access is less complex and should be slightly faster than @@ -69,5 +69,5 @@ * word and dword access) we call IOMMMIORead and IOMMMIOWrite directly. The * alternative ways that the physical memory access which goes via PGM will take - * care of it by calling IOMR3MMIOHandler via the PGM access handler machinery + * care of it by calling iomR3MmioHandler via the PGM access handler machinery * - this shouldn't happen but it is an alternative... * @@ -187,7 +187,7 @@ */ rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_MMIO, - IOMR3MMIOHandler, - NULL, "IOMMMIOHandler", - NULL, "IOMMMIOHandler", + iomR3MmioHandler, + NULL, "iomMmioPfHandler", + NULL, "iomMmioPfHandler", "MMIO", &pVM->iom.s.hMmioHandlerType); @@ -205,10 +205,10 @@ * Statistics. */ - STAM_REG(pVM, &pVM->iom.s.StatRZMMIOHandler, STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler", STAMUNIT_TICKS_PER_CALL, "Profiling of the IOMMMIOHandler() body, only success calls."); + STAM_REG(pVM, &pVM->iom.s.StatRZMMIOHandler, STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler", STAMUNIT_TICKS_PER_CALL, "Profiling of the iomMmioPfHandler() body, only success calls."); STAM_REG(pVM, &pVM->iom.s.StatRZMMIO1Byte, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access1", STAMUNIT_OCCURENCES, "MMIO access by 1 byte counter."); STAM_REG(pVM, &pVM->iom.s.StatRZMMIO2Bytes, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access2", STAMUNIT_OCCURENCES, "MMIO access by 2 bytes counter."); STAM_REG(pVM, &pVM->iom.s.StatRZMMIO4Bytes, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access4", STAMUNIT_OCCURENCES, "MMIO access by 4 bytes counter."); STAM_REG(pVM, &pVM->iom.s.StatRZMMIO8Bytes, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access8", STAMUNIT_OCCURENCES, "MMIO access by 8 bytes counter."); - STAM_REG(pVM, &pVM->iom.s.StatRZMMIOFailures, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/MMIOFailures", STAMUNIT_OCCURENCES, "Number of times IOMMMIOHandler() didn't service the request."); + STAM_REG(pVM, &pVM->iom.s.StatRZMMIOFailures, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/MMIOFailures", STAMUNIT_OCCURENCES, "Number of times iomMmioPfHandler() didn't service the request."); STAM_REG(pVM, &pVM->iom.s.StatRZInstMov, STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOV", STAMUNIT_TICKS_PER_CALL, "Profiling of the MOV instruction emulation."); STAM_REG(pVM, &pVM->iom.s.StatRZInstCmp, STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/CMP", STAMUNIT_TICKS_PER_CALL, "Profiling of the CMP instruction emulation."); @@ -228,5 +228,5 @@ #endif STAM_REG(pVM, &pVM->iom.s.StatRZInstOther, STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Inst/Other", STAMUNIT_OCCURENCES, "Other instructions counter."); - STAM_REG(pVM, &pVM->iom.s.StatR3MMIOHandler, STAMTYPE_COUNTER, "/IOM/R3-MMIOHandler", STAMUNIT_OCCURENCES, "Number of calls to IOMR3MMIOHandler."); + STAM_REG(pVM, &pVM->iom.s.StatR3MMIOHandler, STAMTYPE_COUNTER, "/IOM/R3-MMIOHandler", STAMUNIT_OCCURENCES, "Number of calls to iomR3MmioHandler."); STAM_REG(pVM, &pVM->iom.s.StatInstIn, STAMTYPE_COUNTER, "/IOM/IOWork/In", STAMUNIT_OCCURENCES, "Counter of any IN instructions."); STAM_REG(pVM, &pVM->iom.s.StatInstOut, STAMTYPE_COUNTER, "/IOM/IOWork/Out", STAMUNIT_OCCURENCES, "Counter of any OUT instructions."); Index: /trunk/src/VBox/VMM/VMMR3/PGM.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PGM.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMR3/PGM.cpp (revision 55896) @@ -1457,6 +1457,6 @@ rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, pgmR3PhysRomWriteHandler, - NULL, "pgmPhysRomWriteHandler", - NULL, "pgmPhysRomWriteHandler", + NULL, "pgmPhysRomWritePfHandler", + NULL, "pgmPhysRomWritePfHandler", "ROM write protection", &pVM->pgm.s.hRomPhysHandlerType); @@ -2430,6 +2430,6 @@ RTListOff32ForEach(&pVM->pgm.s.pTreesR3->HeadPhysHandlerTypes, pCurPhysType, PGMPHYSHANDLERTYPEINT, ListNode) { - if (pCurPhysType->pfnHandlerRC != NIL_RTRCPTR) - pCurPhysType->pfnHandlerRC += offDelta; + if (pCurPhysType->pfnPfHandlerRC != NIL_RTRCPTR) + pCurPhysType->pfnPfHandlerRC += offDelta; } Index: /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp (revision 55896) @@ -73,6 +73,7 @@ * @param enmKind The kind of access handler. * @param pfnHandlerR3 Pointer to the ring-3 handler callback. - * @param pfnHandlerR0 Pointer to the ring-0 handler callback. - * @param pfnHandlerRC Pointer to the raw-mode context handler callback. + * @param pfnPfHandlerR0 Pointer to the ring-0 \#PF handler callback. + * @param pfnPfHandlerRC Pointer to the raw-mode context \#PF handler + * callback. * @param pszDesc The type description. * @param phType Where to return the type handle (cross context @@ -81,11 +82,11 @@ VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind, PFNPGMR3PHYSHANDLER pfnHandlerR3, - R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0, - RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC, + R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0, + RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC, const char *pszDesc, PPGMPHYSHANDLERTYPE phType) { AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER); - AssertReturn(pfnHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER); - AssertReturn(pfnHandlerRC != NIL_RTRCPTR || HMIsEnabled(pVM), VERR_INVALID_POINTER); + AssertReturn(pfnPfHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER); + AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR || HMIsEnabled(pVM), VERR_INVALID_POINTER); AssertPtrReturn(pszDesc, VERR_INVALID_POINTER); AssertReturn( enmKind == PGMPHYSHANDLERKIND_WRITE @@ -98,12 +99,13 @@ if (RT_SUCCESS(rc)) { - pType->u32Magic = PGMPHYSHANDLERTYPEINT_MAGIC; - pType->cRefs = 1; - pType->enmKind = enmKind; - pType->uState = enmKind == PGMPHYSHANDLERKIND_WRITE ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL; - pType->pfnHandlerR3 = pfnHandlerR3; - pType->pfnHandlerR0 = pfnHandlerR0; - pType->pfnHandlerRC = pfnHandlerRC; - pType->pszDesc = pszDesc; + pType->u32Magic = PGMPHYSHANDLERTYPEINT_MAGIC; + pType->cRefs = 1; + pType->enmKind = enmKind; + pType->uState = enmKind == PGMPHYSHANDLERKIND_WRITE + ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL; + pType->pfnHandlerR3 = pfnHandlerR3; + pType->pfnPfHandlerR0 = pfnPfHandlerR0; + pType->pfnPfHandlerRC = pfnPfHandlerRC; + pType->pszDesc = pszDesc; pgmLock(pVM); @@ -113,5 +115,5 @@ *phType = MMHyperHeapPtrToOffset(pVM, pType); LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pfnHandlerRC=%RRv pszDesc=%s\n", - pType, *phType, enmKind, pfnHandlerR3, pfnHandlerR0, pfnHandlerRC, pszDesc)); + pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc)); return VINF_SUCCESS; } @@ -130,10 +132,10 @@ * @param pszModR0 The name of the ring-0 module, NULL is an alias for * the main ring-0 module. - * @param pszHandlerR0 The name of the ring-0 handler, NULL if the ring-3 - * handler should be called. + * @param pszPfHandlerR0 The name of the ring-0 \#PF handler, NULL if the + * ring-3 handler should be called. * @param pszModRC The name of the raw-mode context module, NULL is an * alias for the main RC module. - * @param pszHandlerRC The name of the raw-mode context handler, NULL if - * the ring-3 handler should be called. + * @param pszPfHandlerRC The name of the raw-mode context \#PF handler, NULL + * if the ring-3 handler should be called. * @param pszDesc The type description. * @param phType Where to return the type handle (cross context @@ -142,10 +144,10 @@ VMMR3DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3, - const char *pszModR0, const char *pszHandlerR0, - const char *pszModRC, const char *pszHandlerRC, const char *pszDesc, + const char *pszModR0, const char *pszPfHandlerR0, + const char *pszModRC, const char *pszPfHandlerRC, const char *pszDesc, PPGMPHYSHANDLERTYPE phType) { - LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszHandlerR0=%s pszModRC=%s pszHandlerRC=%s pszDesc=%s\n", - enmKind, pfnHandlerR3, pszModR0, pszHandlerR0, pszHandlerRC, pszModRC, pszDesc)); + LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszPfHandlerR0=%s pszModRC=%s pszPfHandlerRC=%s pszDesc=%s\n", + enmKind, pfnHandlerR3, pszModR0, pszPfHandlerR0, pszModRC, pszPfHandlerRC, pszDesc)); /* @@ -156,17 +158,17 @@ if (!pszModR0) pszModR0 = VMMR0_MAIN_MODULE_NAME; - if (!pszHandlerR0) - pszHandlerR0 = "pgmPhysHandlerRedirectToHC"; - if (!pszHandlerRC) - pszHandlerRC = "pgmPhysHandlerRedirectToHC"; + if (!pszPfHandlerR0) + pszPfHandlerR0 = "pgmPhysPfHandlerRedirectToHC"; + if (!pszPfHandlerRC) + pszPfHandlerRC = "pgmPhysPfHandlerRedirectToHC"; AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER); - AssertPtrReturn(pszHandlerR0, VERR_INVALID_POINTER); - AssertPtrReturn(pszHandlerRC, VERR_INVALID_POINTER); + AssertPtrReturn(pszPfHandlerR0, VERR_INVALID_POINTER); + AssertPtrReturn(pszPfHandlerRC, VERR_INVALID_POINTER); /* * Resolve the R0 handler. */ - R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0 = NIL_RTR0PTR; - int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszModR0, NULL /*pszSearchPath*/, pszHandlerR0, &pfnHandlerR0); + R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0 = NIL_RTR0PTR; + int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszModR0, NULL /*pszSearchPath*/, pszPfHandlerR0, &pfnPfHandlerR0); if (RT_SUCCESS(rc)) { @@ -174,14 +176,14 @@ * Resolve the GC handler. */ - RTRCPTR pfnHandlerRC = NIL_RTRCPTR; + RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR; if (!HMIsEnabled(pVM)) - rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszHandlerRC, &pfnHandlerRC); + rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszPfHandlerRC, &pfnPfHandlerRC); if (RT_SUCCESS(rc)) - return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3, pfnHandlerR0, pfnHandlerRC, pszDesc, phType); - - AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszHandlerRC, rc)); + return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc, phType); + + AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszPfHandlerRC, rc)); } else - AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModR0, pszHandlerR0, rc)); + AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModR0, pszPfHandlerR0, rc)); return rc; @@ -282,5 +284,5 @@ * @param pfnInvalidateR3 Pointer to the ring-3 invalidation handler callback. * @param pfnHandlerR3 Pointer to the ring-3 handler callback. - * @param pfnHandlerRC Pointer to the raw-mode context handler callback. + * @param pfnPfHandlerRC Pointer to the raw-mode context handler callback. * @param pszDesc The type description. * @param phType Where to return the type handle (cross context @@ -720,5 +722,5 @@ pHlp->pfnPrintf(pHlp, "%RGp - %RGp %RHv %RHv %RRv %RRv %s %s\n", - pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnHandlerRC, pCur->pvUserRC, + pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnPfHandlerRC, pCur->pvUserRC, pszType, pCur->pszDesc); #ifdef VBOX_WITH_STATISTICS Index: /trunk/src/VBox/VMM/VMMR3/PGMPool.cpp =================================================================== --- /trunk/src/VBox/VMM/VMMR3/PGMPool.cpp (revision 55895) +++ /trunk/src/VBox/VMM/VMMR3/PGMPool.cpp (revision 55896) @@ -114,5 +114,5 @@ * Internal Functions * *******************************************************************************/ -static DECLCALLBACK(int) pgmR3PoolAccessHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser); +static FNPGMR3PHYSHANDLER pgmR3PoolAccessHandler; #ifdef VBOX_WITH_DEBUGGER static FNDBGCCMD pgmR3PoolCmdCheck; @@ -284,6 +284,6 @@ rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, pgmR3PoolAccessHandler, - NULL, "pgmPoolAccessHandler", - NULL, "pgmPoolAccessHandler", + NULL, "pgmPoolAccessPfHandler", + NULL, "pgmPoolAccessPfHandler", "Guest Paging Access Handler", &pPool->hAccessHandlerType); Index: /trunk/src/VBox/VMM/include/IOMInternal.h =================================================================== --- /trunk/src/VBox/VMM/include/IOMInternal.h (revision 55895) +++ /trunk/src/VBox/VMM/include/IOMInternal.h (revision 55896) @@ -422,9 +422,9 @@ #endif /* IN_RING3 */ -VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, - RTGCPHYS GCPhysFault, void *pvUser); +#ifndef IN_RING3 +DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) iomMmioPfHandler; +#endif #ifdef IN_RING3 -DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, - PGMACCESSTYPE enmAccessType, void *pvUser); +FNPGMR3PHYSHANDLER iomR3MmioHandler; #endif Index: /trunk/src/VBox/VMM/include/PGMInternal.h =================================================================== --- /trunk/src/VBox/VMM/include/PGMInternal.h (revision 55895) +++ /trunk/src/VBox/VMM/include/PGMInternal.h (revision 55896) @@ -590,12 +590,12 @@ /** The PGM_PAGE_HNDL_PHYS_STATE_XXX value corresponding to enmKind. */ uint32_t uState; - /** Pointer to RC callback function. */ - RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC; + /** Pointer to RC callback function for \#PFs. */ + RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC; /** Explicit alignment padding. */ RTRCPTR RCPtrPadding; /** Pointer to R3 callback function. */ R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3; - /** Pointer to R0 callback function. */ - R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0; + /** Pointer to R0 callback function for \#PFs. */ + R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0; /** Description / Name. For easing debugging. */ R3PTRTYPE(const char *) pszDesc; @@ -710,5 +710,5 @@ bool fRelocUserRC; bool afPadding[3]; - /** Pointer to RC callback function. */ + /** Pointer to RC callback function for \#PFs. */ RCPTRTYPE(PFNPGMRCVIRTPFHANDLER) pfnPfHandlerRC; /** Pointer to the R3 callback function for invalidation. */ @@ -4146,6 +4146,8 @@ int pgmPhysGCPhys2CCPtrInternalReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, const void **ppv, PPGMPAGEMAPLOCK pLock); void pgmPhysReleaseInternalPageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock); -VMMDECL(int) pgmPhysHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); -VMMDECL(int) pgmPhysRomWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser); +#ifndef IN_RING3 +DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysPfHandlerRedirectToHC; +DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysRomWritePfHandler; +#endif int pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys); void pgmPhysInvalidRamRangeTlbs(PVM pVM); @@ -4159,6 +4161,5 @@ #ifdef IN_RING3 -DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, - PGMACCESSTYPE enmAccessType, void *pvUser); +FNPGMR3PHYSHANDLER pgmR3PhysRomWriteHandler; void pgmR3PhysRelinkRamRanges(PVM pVM); int pgmR3PhysRamPreAllocate(PVM pVM); Index: /trunk/src/VBox/VMM/testcase/tstVMStruct.h =================================================================== --- /trunk/src/VBox/VMM/testcase/tstVMStruct.h (revision 55895) +++ /trunk/src/VBox/VMM/testcase/tstVMStruct.h (revision 55896) @@ -791,6 +791,6 @@ GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, uState); GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR3); - GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR0); - GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerRC); + GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerR0); + GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerRC); GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pszDesc); GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);