VirtualBox

Changeset 55896 in vbox


Ignore:
Timestamp:
May 17, 2015 8:20:30 PM (10 years ago)
Author:
vboxsync
Message:

PGM: Renamed the ring-0 and raw-mode context physical page access handler callbacks to 'PfHandler' to indicate that these are for page-fault callbacks. Will add non-PF handlers similar to the ring-3 one later.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pgm.h

    r55895 r55896  
    102102 * @param   pvUser      User argument.
    103103 */
    104 typedef DECLCALLBACK(int) FNPGMRCPHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
     104typedef DECLCALLBACK(int) FNPGMRCPHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     105                                               RTGCPHYS GCPhysFault, void *pvUser);
    105106/** Pointer to PGM access callback. */
    106 typedef FNPGMRCPHYSHANDLER *PFNPGMRCPHYSHANDLER;
     107typedef FNPGMRCPHYSPFHANDLER *PFNPGMRCPHYSPFHANDLER;
    107108
    108109/**
    … …  
    118119 * @param   pvUser      User argument.
    119120 */
    120 typedef DECLCALLBACK(int) FNPGMR0PHYSHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
     121typedef DECLCALLBACK(int) FNPGMR0PHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     122                                               RTGCPHYS GCPhysFault, void *pvUser);
    121123/** Pointer to PGM access callback. */
    122 typedef FNPGMR0PHYSHANDLER *PFNPGMR0PHYSHANDLER;
     124typedef FNPGMR0PHYSPFHANDLER *PFNPGMR0PHYSPFHANDLER;
    123125
    124126/**
    … …  
    151153 * @todo    Add pVCpu, possibly replacing pVM.
    152154 */
    153 typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
     155typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     156                                             PGMACCESSTYPE enmAccessType, void *pvUser);
    154157/** Pointer to PGM access callback. */
    155158typedef FNPGMR3PHYSHANDLER *PFNPGMR3PHYSHANDLER;
    … …  
    539542VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    540543                                                       PFNPGMR3PHYSHANDLER pfnHandlerR3,
    541                                                        R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0,
    542                                                        RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC,
     544                                                       R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0,
     545                                                       RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC,
    543546                                                       const char *pszDesc, PPGMPHYSHANDLERTYPE phType);
    544547VMMR3DECL(int)      PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    545548                                                     R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3,
    546                                                      const char *pszModR0, const char *pszHandlerR0,
    547                                                      const char *pszModRC, const char *pszHandlerRC, const char *pszDesc,
     549                                                     const char *pszModR0, const char *pszPfHandlerR0,
     550                                                     const char *pszModRC, const char *pszPfHandlerRC, const char *pszDesc,
    548551                                                     PPGMPHYSHANDLERTYPE phType);
    549552VMMR3_INT_DECL(int) PGMR3HandlerVirtualTypeRegisterEx(PVM pVM, PGMVIRTHANDLERKIND enmKind, bool fRelocUserRC,

  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r55838 r55896  
    35243524
    35253525
    3526 #ifdef IN_RC
     3526#ifndef IN_RING3
     3527RT_C_DECLS_BEGIN
     3528DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) vgaLbfAccessPfHandler;
     3529RT_C_DECLS_END
     3530
    35273531/**
    35283532 * @callback_method_impl{FNPGMRCPHYSHANDLER, \#PF Handler for VBE LFB access.}
    35293533 */
    3530 PDMBOTHCBDECL(int) vgaRCLFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
     3534PDMBOTHCBDECL(int) vgaLbfAccessPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     3535                                         RTGCPHYS GCPhysFault, void *pvUser)
    35313536{
    35323537    PVGASTATE   pThis = (PVGASTATE)pvUser;
    35333538    AssertPtr(pThis);
    3534     Assert(GCPhysFault >= pThis->GCPhysVRAM);
    3535     AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
    3536     NOREF(pRegFrame);
    3537 
    3538     return vgaLFBAccess(pVM, pThis, GCPhysFault, pvFault);
    3539 }
    3540 
    3541 #elif IN_RING0
    3542 
    3543 /**
    3544  * @callback_method_impl{FNPGMR0PHYSHANDLER, \#PF Handler for VBE LFB access.}
    3545  */
    3546 PDMBOTHCBDECL(int) vgaR0LFBAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    3547 {
    3548     PVGASTATE   pThis = (PVGASTATE)pvUser;
    3549     Assert(pThis);
    35503539    Assert(GCPhysFault >= pThis->GCPhysVRAM);
    35513540    AssertMsg(uErrorCode & X86_TRAP_PF_RW, ("uErrorCode=%#x\n", uErrorCode));
    … …  
    62206209    rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
    62216210                                          vgaR3LFBAccessHandler,
    6222                                           g_DeviceVga.szR0Mod, "vgaR0LFBAccessHandler",
    6223                                           g_DeviceVga.szRCMod, "vgaRCLFBAccessHandler",
     6211                                          g_DeviceVga.szR0Mod, "vgaLbfAccessPfHandler",
     6212                                          g_DeviceVga.szRCMod, "vgaLbfAccessPfHandler",
    62246213                                          "VGA LFB", &pThis->hLfbAccessHandlerType);
    62256214    AssertRCReturn(rc, rc);

  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r55493 r55896  
    10751075}
    10761076
    1077 RT_C_DECLS_BEGIN
    1078 #ifndef IN_RING3
    1079 DECLEXPORT(int) pcnetHandleRingWrite(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
    1080                                      RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
    1081 #endif
    1082 RT_C_DECLS_END
    10831077
    10841078#undef htonl
    … …  
    10961090#ifdef PCNET_NO_POLLING
    10971091# ifndef IN_RING3
     1092RT_C_DECLS_BEGIN
     1093DECLEXPORT(CTX_SUFF(FNPGM,PHYSPFHANDLER)) pcnetHandleRingWritePf;
     1094RT_C_DECLS_END
    10981095
    10991096/**
    … …  
    11081105 * @param   pvUser      User argument.
    11091106 */
    1110 DECLEXPORT(int) pcnetHandleRingWrite(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
    1111                                      RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
     1107DECLEXPORT(int) pcnetHandleRingWritePf(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
     1108                                       RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    11121109{
    11131110    PPCNETSTATE pThis   = (PPCNETSTATE)pvUser;
    11141111
    1115     Log(("#%d pcnetHandleRingWriteGC: write to %#010x\n", PCNET_INST_NR, GCPhysFault));
     1112    Log(("#%d pcnetHandleRingWritePf: write to %#010x\n", PCNET_INST_NR, GCPhysFault));
    11161113
    11171114    uint32_t cb;
    … …  
    11681165 * @param   pvUser          User argument.
    11691166 */
    1170 static DECLCALLBACK(int) pcnetHandleRingWrite(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf,
    1171                                               size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
     1167static DECLCALLBACK(int) pcnetR3HandleRingWrite(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf,
     1168                                                size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
    11721169{
    11731170    PPDMDEVINS  pDevIns = (PPDMDEVINS)pvUser;
    11741171    PPCNETSTATE pThis   = PDMINS_2_DATA(pDevIns, PPCNETSTATE);
    11751172
    1176     Log(("#%d pcnetHandleRingWrite: write to %#010x\n", PCNET_INST_NR, GCPhys));
     1173    Log(("#%d pcnetR3HandleRingWrite: write to %#010x\n", PCNET_INST_NR, GCPhys));
    11771174#ifdef VBOX_WITH_STATISTICS
    11781175    STAM_COUNTER_INC(&CTXSUFF(pThis->StatRingWrite));
    … …  
    49764973
    49774974    rc = PGMR3HandlerPhysicalTypeRegister(PDMDevHlpGetVM(pDevIns), PGMPHYSHANDLERKIND_WRITE,
    4978                                           pcnetHandleRingWrite,
    4979                                           g_DevicePCNet.szR0Mod, "pcnetHandleRingWrite",
    4980                                           g_DevicePCNet.szRCMod, "pcnetHandleRingWrite",
     4975                                          pcnetR3HandleRingWrite,
     4976                                          g_DevicePCNet.szR0Mod, "pcnetHandleRingWritePf",
     4977                                          g_DevicePCNet.szRCMod, "pcnetHandleRingWritePf",
    49814978                                          "PCNet ring write access handler",
    49824979                                          &pThis->hNoPollingHandlerType);

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

    r55841 r55896  
    17411741 * @param   pvUser      Pointer to the MMIO ring-3 range entry.
    17421742 */
    1743 VMMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
    1744 {
    1745     LogFlow(("IOMMMIOHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
     1743DECLEXPORT(int) iomMmioPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault,
     1744                                 RTGCPHYS GCPhysFault, void *pvUser)
     1745{
     1746    LogFlow(("iomMmioPfHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
    17461747             GCPhysFault, (uint32_t)uErrorCode, pvFault, (RTGCPTR)pCtxCore->rip));
    17471748    VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, VMMGetCpu(pVM), (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
    … …  
    17991800 * @param   pvUser          Pointer to the MMIO range entry.
    18001801 */
    1801 DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf,
     1802DECLCALLBACK(int) iomR3MmioHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf,
    18021803                                   PGMACCESSTYPE enmAccessType, void *pvUser)
    18031804{

  • trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

    r55895 r55896  
    248248            }
    249249
    250             if (pCurType->CTX_SUFF(pfnHandler))
     250            if (pCurType->CTX_SUFF(pfnPfHandler))
    251251            {
    252                 PPGMPOOL            pPool      = pVM->pgm.s.CTX_SUFF(pPool);
    253                 void               *pvUser     = pCur->CTX_SUFF(pvUser);
    254 #  ifdef IN_RING0
    255                 PFNPGMR0PHYSHANDLER pfnHandler = pCurType->CTX_SUFF(pfnHandler);
    256 #  else
    257                 PFNPGMRCPHYSHANDLER pfnHandler = pCurType->CTX_SUFF(pfnHandler);
    258 #  endif
     252                PPGMPOOL    pPool  = pVM->pgm.s.CTX_SUFF(pPool);
     253                void       *pvUser = pCur->CTX_SUFF(pvUser);
    259254
    260255                STAM_PROFILE_START(&pCur->Stat, h);
    … …  
    265260                }
    266261
    267                 rc = pfnHandler(pVM, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
     262                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
    268263
    269264#  ifdef VBOX_WITH_STATISTICS

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

    r55889 r55896  
    6464 * @param   pvUser      User argument.
    6565 */
    66 VMMDECL(int) pgmPhysHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
     66VMMDECL(int) pgmPhysPfHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     67                                          RTGCPHYS GCPhysFault, void *pvUser)
    6768{
    6869    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser);
    … …  
    8384 * @param   pvUser      User argument. Pointer to the ROM range structure.
    8485 */
    85 VMMDECL(int) pgmPhysRomWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser)
     86DECLEXPORT(int) pgmPhysRomWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     87                                         RTGCPHYS GCPhysFault, void *pvUser)
    8688{
    8789    int             rc;
    … …  
    23552357        {
    23562358            Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
    2357             Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler));
    23582359
    23592360            size_t cbRange = pCur->Core.KeyLast - GCPhys + 1;
    … …  
    23682369
    23692370#else  /* IN_RING3 */
     2371            Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler));
    23702372            Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n",
    23712373                  GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));

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

    r55493 r55896  
    5252static void pgmPoolMonitorModifiedRemove(PPGMPOOL pPool, PPGMPOOLPAGE pPage);
    5353#ifndef IN_RING3
    54 DECLEXPORT(int) pgmPoolAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
     54DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPoolAccessPfHandler;
    5555#endif
    5656#if defined(LOG_ENABLED) || defined(VBOX_STRICT)
    … …  
    823823 * @todo VBOXSTRICTRC
    824824 */
    825 static int pgmPoolAccessHandlerFlush(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
    826                                      PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
     825static int pgmPoolAccessPfHandlerFlush(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
     826                                       PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
    827827{
    828828    NOREF(pVM); NOREF(GCPhysFault);
    … …  
    855855        if (PATMIsPatchGCAddr(pVM, pRegFrame->eip))
    856856        {
    857             LogFlow(("pgmPoolAccessHandlerPTWorker: Interpretation failed for patch code %04x:%RGv, ignoring.\n",
     857            LogFlow(("pgmPoolAccessPfHandlerPTWorker: Interpretation failed for patch code %04x:%RGv, ignoring.\n",
    858858                     pRegFrame->cs.Sel, (RTGCPTR)pRegFrame->eip));
    859859            rc = VINF_SUCCESS;
    … …  
    872872        AssertMsgFailed(("%Rrc\n", VBOXSTRICTRC_VAL(rc2))); /* ASSUMES no complicated stuff here. */
    873873
    874     LogFlow(("pgmPoolAccessHandlerPT: returns %Rrc (flushed)\n", rc));
     874    LogFlow(("pgmPoolAccessPfHandlerPT: returns %Rrc (flushed)\n", rc));
    875875    return rc;
    876876}
    … …  
    889889 * @param   pvFault     The fault address.
    890890 */
    891 DECLINLINE(int) pgmPoolAccessHandlerSTOSD(PVM pVM, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
    892                                           PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
     891DECLINLINE(int) pgmPoolAccessPfHandlerSTOSD(PVM pVM, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
     892                                            PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault)
    893893{
    894894    unsigned uIncrement = pDis->Param1.cb;
    … …  
    905905#endif
    906906
    907     Log3(("pgmPoolAccessHandlerSTOSD\n"));
     907    Log3(("pgmPoolAccessPfHandlerSTOSD\n"));
    908908
    909909    /*
    … …  
    943943    pRegFrame->rip += pDis->cbInstr;
    944944
    945     LogFlow(("pgmPoolAccessHandlerSTOSD: returns\n"));
     945    LogFlow(("pgmPoolAccessPfHandlerSTOSD: returns\n"));
    946946    return VINF_SUCCESS;
    947947}
    … …  
    962962 * @param   pfReused    Reused state (in/out)
    963963 */
    964 DECLINLINE(int) pgmPoolAccessHandlerSimple(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
    965                                            PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault, bool *pfReused)
    966 {
    967     Log3(("pgmPoolAccessHandlerSimple\n"));
     964DECLINLINE(int) pgmPoolAccessPfHandlerSimple(PVM pVM, PVMCPU pVCpu, PPGMPOOL pPool, PPGMPOOLPAGE pPage, PDISCPUSTATE pDis,
     965                                             PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, RTGCPTR pvFault, bool *pfReused)
     966{
     967    Log3(("pgmPoolAccessPfHandlerSimple\n"));
    968968    NOREF(pVM);
    969969    NOREF(pfReused); /* initialized by caller */
    … …  
    10051005    else if (rc == VERR_EM_INTERPRETER)
    10061006    {
    1007         LogFlow(("pgmPoolAccessHandlerPTWorker: Interpretation failed for %04x:%RGv - opcode=%d\n",
     1007        LogFlow(("pgmPoolAccessPfHandlerPTWorker: Interpretation failed for %04x:%RGv - opcode=%d\n",
    10081008                  pRegFrame->cs.Sel, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->uOpcode));
    10091009        rc = VINF_EM_RAW_EMULATE_INSTR;
    … …  
    10411041#endif
    10421042
    1043     LogFlow(("pgmPoolAccessHandlerSimple: returns %Rrc\n", VBOXSTRICTRC_VAL(rc)));
     1043    LogFlow(("pgmPoolAccessPfHandlerSimple: returns %Rrc\n", VBOXSTRICTRC_VAL(rc)));
    10441044    return VBOXSTRICTRC_VAL(rc);
    10451045}
    … …  
    10581058 * @param   pvUser      User argument.
    10591059 */
    1060 DECLEXPORT(int) pgmPoolAccessHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    1061                                      RTGCPHYS GCPhysFault, void *pvUser)
     1060DECLEXPORT(int) pgmPoolAccessPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     1061                                       RTGCPHYS GCPhysFault, void *pvUser)
    10621062{
    10631063    STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), a);
    … …  
    10691069    NOREF(uErrorCode);
    10701070
    1071     LogFlow(("pgmPoolAccessHandler: pvFault=%RGv pPage=%p:{.idx=%d} GCPhysFault=%RGp\n", pvFault, pPage, pPage->idx, GCPhysFault));
     1071    LogFlow(("pgmPoolAccessPfHandler: pvFault=%RGv pPage=%p:{.idx=%d} GCPhysFault=%RGp\n", pvFault, pPage, pPage->idx, GCPhysFault));
    10721072
    10731073    pgmLock(pVM);
    … …  
    10751075    {
    10761076        /* Pool page changed while we were waiting for the lock; ignore. */
    1077         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)));
     1077        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)));
    10781078        STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), &pPool->CTX_MID_Z(StatMonitor,Handled), a);
    10791079        pgmUnlock(pVM);
    … …  
    11731173        if (!(pDis->fPrefix & (DISPREFIX_REP | DISPREFIX_REPNE)))
    11741174        {
    1175             rc = pgmPoolAccessHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused);
     1175            rc = pgmPoolAccessPfHandlerSimple(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault, &fReused);
    11761176            if (fReused)
    11771177                goto flushPage;
    … …  
    12441244            if (fValidStosd)
    12451245            {
    1246                 rc = pgmPoolAccessHandlerSTOSD(pVM, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
     1246                rc = pgmPoolAccessPfHandlerSTOSD(pVM, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
    12471247                STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->CTX_SUFF_Z(StatMonitor), &pPool->CTX_MID_Z(StatMonitor,RepStosd), a);
    12481248                pgmUnlock(pVM);
    … …  
    12531253        /* REP prefix, don't bother. */
    12541254        STAM_COUNTER_INC(&pPool->CTX_MID_Z(StatMonitor,RepPrefix));
    1255         Log4(("pgmPoolAccessHandler: eax=%#x ecx=%#x edi=%#x esi=%#x rip=%RGv opcode=%d prefix=%#x\n",
     1255        Log4(("pgmPoolAccessPfHandler: eax=%#x ecx=%#x edi=%#x esi=%#x rip=%RGv opcode=%d prefix=%#x\n",
    12561256              pRegFrame->eax, pRegFrame->ecx, pRegFrame->edi, pRegFrame->esi, (RTGCPTR)pRegFrame->rip, pDis->pCurInstr->uOpcode, pDis->fPrefix));
    12571257        fNotReusedNotForking = true;
    … …  
    13411341     * the reuse detection must be fixed.
    13421342     */
    1343     rc = pgmPoolAccessHandlerFlush(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
     1343    rc = pgmPoolAccessPfHandlerFlush(pVM, pVCpu, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
    13441344    if (    rc == VINF_EM_RAW_EMULATE_INSTR
    13451345        &&  fReused)

  • trunk/src/VBox/VMM/VMMR0/PGMR0.cpp

    r55493 r55896  
    580580        else
    581581        {
    582             if (pHandlerType->CTX_SUFF(pfnHandler))
     582            if (pHandlerType->CTX_SUFF(pfnPfHandler))
    583583            {
    584                 CTX_MID(PFNPGM,PHYSHANDLER) pfnHandler = pHandlerType->CTX_SUFF(pfnHandler);
    585                 void                       *pvUser     = pHandler->CTX_SUFF(pvUser);
     584                void *pvUser = pHandler->CTX_SUFF(pvUser);
    586585                STAM_PROFILE_START(&pHandler->Stat, h);
    587586                pgmUnlock(pVM);
    588587
    589                 Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pfnHandler, uErr, GCPhysFault, pvUser));
    590                 rc = pfnHandler(pVM, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame, GCPhysFault, GCPhysFault, pvUser);
     588                Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->CTX_SUFF(pfnPfHandler), uErr, GCPhysFault, pvUser));
     589                rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pVM, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
     590                                                          GCPhysFault, GCPhysFault, pvUser);
    591591
    592592#ifdef VBOX_WITH_STATISTICS

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

    r55493 r55896  
    4242 * with the PGM access handler sub-system. The access handler catches all
    4343 * access and will be called in the context of a \#PF handler. In RC and R0 this
    44  * handler is IOMMMIOHandler while in ring-3 it's IOMR3MMIOHandler (although in
    45  * ring-3 there can be alternative ways). IOMMMIOHandler will attempt to emulate
    46  * the instruction that is doing the access and pass the corresponding reads /
    47  * writes to the device.
     44 * handler is iomMmioPfHandler while in ring-3 it's iomR3MmioHandler (although
     45 * in ring-3 there can be alternative ways). iomMmioPfHandler will attempt to
     46 * emulate the instruction that is doing the access and pass the corresponding
     47 * reads / writes to the device.
    4848 *
    4949 * Emulating I/O port access is less complex and should be slightly faster than
    … …  
    6969 * word and dword access) we call IOMMMIORead and IOMMMIOWrite directly. The
    7070 * alternative ways that the physical memory access which goes via PGM will take
    71  * care of it by calling IOMR3MMIOHandler via the PGM access handler machinery
     71 * care of it by calling iomR3MmioHandler via the PGM access handler machinery
    7272 * - this shouldn't happen but it is an alternative...
    7373 *
    … …  
    187187         */
    188188        rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_MMIO,
    189                                               IOMR3MMIOHandler,
    190                                               NULL, "IOMMMIOHandler",
    191                                               NULL, "IOMMMIOHandler",
     189                                              iomR3MmioHandler,
     190                                              NULL, "iomMmioPfHandler",
     191                                              NULL, "iomMmioPfHandler",
    192192                                              "MMIO",
    193193                                              &pVM->iom.s.hMmioHandlerType);
    … …  
    205205             * Statistics.
    206206             */
    207             STAM_REG(pVM, &pVM->iom.s.StatRZMMIOHandler,      STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler",                      STAMUNIT_TICKS_PER_CALL, "Profiling of the IOMMMIOHandler() body, only success calls.");
     207            STAM_REG(pVM, &pVM->iom.s.StatRZMMIOHandler,      STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler",                      STAMUNIT_TICKS_PER_CALL, "Profiling of the iomMmioPfHandler() body, only success calls.");
    208208            STAM_REG(pVM, &pVM->iom.s.StatRZMMIO1Byte,        STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access1",              STAMUNIT_OCCURENCES,     "MMIO access by 1 byte counter.");
    209209            STAM_REG(pVM, &pVM->iom.s.StatRZMMIO2Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access2",              STAMUNIT_OCCURENCES,     "MMIO access by 2 bytes counter.");
    210210            STAM_REG(pVM, &pVM->iom.s.StatRZMMIO4Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access4",              STAMUNIT_OCCURENCES,     "MMIO access by 4 bytes counter.");
    211211            STAM_REG(pVM, &pVM->iom.s.StatRZMMIO8Bytes,       STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Access8",              STAMUNIT_OCCURENCES,     "MMIO access by 8 bytes counter.");
    212             STAM_REG(pVM, &pVM->iom.s.StatRZMMIOFailures,     STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/MMIOFailures",         STAMUNIT_OCCURENCES,     "Number of times IOMMMIOHandler() didn't service the request.");
     212            STAM_REG(pVM, &pVM->iom.s.StatRZMMIOFailures,     STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/MMIOFailures",         STAMUNIT_OCCURENCES,     "Number of times iomMmioPfHandler() didn't service the request.");
    213213            STAM_REG(pVM, &pVM->iom.s.StatRZInstMov,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/MOV",             STAMUNIT_TICKS_PER_CALL, "Profiling of the MOV instruction emulation.");
    214214            STAM_REG(pVM, &pVM->iom.s.StatRZInstCmp,          STAMTYPE_PROFILE, "/IOM/RZ-MMIOHandler/Inst/CMP",             STAMUNIT_TICKS_PER_CALL, "Profiling of the CMP instruction emulation.");
    … …  
    228228#endif
    229229            STAM_REG(pVM, &pVM->iom.s.StatRZInstOther,        STAMTYPE_COUNTER, "/IOM/RZ-MMIOHandler/Inst/Other",           STAMUNIT_OCCURENCES,     "Other instructions counter.");
    230             STAM_REG(pVM, &pVM->iom.s.StatR3MMIOHandler,      STAMTYPE_COUNTER, "/IOM/R3-MMIOHandler",                      STAMUNIT_OCCURENCES,     "Number of calls to IOMR3MMIOHandler.");
     230            STAM_REG(pVM, &pVM->iom.s.StatR3MMIOHandler,      STAMTYPE_COUNTER, "/IOM/R3-MMIOHandler",                      STAMUNIT_OCCURENCES,     "Number of calls to iomR3MmioHandler.");
    231231            STAM_REG(pVM, &pVM->iom.s.StatInstIn,             STAMTYPE_COUNTER, "/IOM/IOWork/In",                           STAMUNIT_OCCURENCES,     "Counter of any IN instructions.");
    232232            STAM_REG(pVM, &pVM->iom.s.StatInstOut,            STAMTYPE_COUNTER, "/IOM/IOWork/Out",                          STAMUNIT_OCCURENCES,     "Counter of any OUT instructions.");

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

    r55895 r55896  
    14571457        rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
    14581458                                              pgmR3PhysRomWriteHandler,
    1459                                               NULL, "pgmPhysRomWriteHandler",
    1460                                               NULL, "pgmPhysRomWriteHandler",
     1459                                              NULL, "pgmPhysRomWritePfHandler",
     1460                                              NULL, "pgmPhysRomWritePfHandler",
    14611461                                              "ROM write protection",
    14621462                                              &pVM->pgm.s.hRomPhysHandlerType);
    … …  
    24302430    RTListOff32ForEach(&pVM->pgm.s.pTreesR3->HeadPhysHandlerTypes, pCurPhysType, PGMPHYSHANDLERTYPEINT, ListNode)
    24312431    {
    2432         if (pCurPhysType->pfnHandlerRC != NIL_RTRCPTR)
    2433             pCurPhysType->pfnHandlerRC += offDelta;
     2432        if (pCurPhysType->pfnPfHandlerRC != NIL_RTRCPTR)
     2433            pCurPhysType->pfnPfHandlerRC += offDelta;
    24342434    }
    24352435

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

    r55895 r55896  
    7373 * @param   enmKind         The kind of access handler.
    7474 * @param   pfnHandlerR3    Pointer to the ring-3 handler callback.
    75  * @param   pfnHandlerR0    Pointer to the ring-0 handler callback.
    76  * @param   pfnHandlerRC    Pointer to the raw-mode context handler callback.
     75 * @param   pfnPfHandlerR0  Pointer to the ring-0 \#PF handler callback.
     76 * @param   pfnPfHandlerRC  Pointer to the raw-mode context \#PF handler
     77 *                          callback.
    7778 * @param   pszDesc         The type description.
    7879 * @param   phType          Where to return the type handle (cross context
    … …  
    8182VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    8283                                                       PFNPGMR3PHYSHANDLER pfnHandlerR3,
    83                                                        R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0,
    84                                                        RCPTRTYPE(PFNPGMRCPHYSHANDLER) pfnHandlerRC,
     84                                                       R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0,
     85                                                       RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC,
    8586                                                       const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
    8687{
    8788    AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
    88     AssertReturn(pfnHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER);
    89     AssertReturn(pfnHandlerRC != NIL_RTRCPTR || HMIsEnabled(pVM), VERR_INVALID_POINTER);
     89    AssertReturn(pfnPfHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER);
     90    AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR || HMIsEnabled(pVM), VERR_INVALID_POINTER);
    9091    AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
    9192    AssertReturn(   enmKind == PGMPHYSHANDLERKIND_WRITE
    … …  
    9899    if (RT_SUCCESS(rc))
    99100    {
    100         pType->u32Magic     = PGMPHYSHANDLERTYPEINT_MAGIC;
    101         pType->cRefs        = 1;
    102         pType->enmKind      = enmKind;
    103         pType->uState       = enmKind == PGMPHYSHANDLERKIND_WRITE ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
    104         pType->pfnHandlerR3 = pfnHandlerR3;
    105         pType->pfnHandlerR0 = pfnHandlerR0;
    106         pType->pfnHandlerRC = pfnHandlerRC;
    107         pType->pszDesc      = pszDesc;
     101        pType->u32Magic         = PGMPHYSHANDLERTYPEINT_MAGIC;
     102        pType->cRefs            = 1;
     103        pType->enmKind          = enmKind;
     104        pType->uState           = enmKind == PGMPHYSHANDLERKIND_WRITE
     105                                ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
     106        pType->pfnHandlerR3     = pfnHandlerR3;
     107        pType->pfnPfHandlerR0   = pfnPfHandlerR0;
     108        pType->pfnPfHandlerRC   = pfnPfHandlerRC;
     109        pType->pszDesc          = pszDesc;
    108110
    109111        pgmLock(pVM);
    … …  
    113115        *phType = MMHyperHeapPtrToOffset(pVM, pType);
    114116        LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pfnHandlerRC=%RRv pszDesc=%s\n",
    115                  pType, *phType, enmKind, pfnHandlerR3, pfnHandlerR0, pfnHandlerRC, pszDesc));
     117                 pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc));
    116118        return VINF_SUCCESS;
    117119    }
    … …  
    130132 * @param   pszModR0        The name of the ring-0 module, NULL is an alias for
    131133 *                          the main ring-0 module.
    132  * @param   pszHandlerR0    The name of the ring-0 handler, NULL if the ring-3
    133  *                          handler should be called.
     134 * @param   pszPfHandlerR0  The name of the ring-0 \#PF handler, NULL if the
     135 *                          ring-3 handler should be called.
    134136 * @param   pszModRC        The name of the raw-mode context module, NULL is an
    135137 *                          alias for the main RC module.
    136  * @param   pszHandlerRC    The name of the raw-mode context handler, NULL if
    137  *                          the ring-3 handler should be called.
     138 * @param   pszPfHandlerRC  The name of the raw-mode context \#PF handler, NULL
     139 *                          if the ring-3 handler should be called.
    138140 * @param   pszDesc         The type description.
    139141 * @param   phType          Where to return the type handle (cross context
    … …  
    142144VMMR3DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    143145                                                R3PTRTYPE(PFNPGMR3PHYSHANDLER) pfnHandlerR3,
    144                                                 const char *pszModR0, const char *pszHandlerR0,
    145                                                 const char *pszModRC, const char *pszHandlerRC, const char *pszDesc,
     146                                                const char *pszModR0, const char *pszPfHandlerR0,
     147                                                const char *pszModRC, const char *pszPfHandlerRC, const char *pszDesc,
    146148                                                PPGMPHYSHANDLERTYPE phType)
    147149{
    148     LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszHandlerR0=%s pszModRC=%s pszHandlerRC=%s pszDesc=%s\n",
    149              enmKind, pfnHandlerR3, pszModR0, pszHandlerR0, pszHandlerRC, pszModRC, pszDesc));
     150    LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszPfHandlerR0=%s pszModRC=%s pszPfHandlerRC=%s pszDesc=%s\n",
     151             enmKind, pfnHandlerR3, pszModR0, pszPfHandlerR0, pszModRC, pszPfHandlerRC, pszDesc));
    150152
    151153    /*
    … …  
    156158    if (!pszModR0)
    157159        pszModR0 = VMMR0_MAIN_MODULE_NAME;
    158     if (!pszHandlerR0)
    159         pszHandlerR0 = "pgmPhysHandlerRedirectToHC";
    160     if (!pszHandlerRC)
    161         pszHandlerRC = "pgmPhysHandlerRedirectToHC";
     160    if (!pszPfHandlerR0)
     161        pszPfHandlerR0 = "pgmPhysPfHandlerRedirectToHC";
     162    if (!pszPfHandlerRC)
     163        pszPfHandlerRC = "pgmPhysPfHandlerRedirectToHC";
    162164    AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
    163     AssertPtrReturn(pszHandlerR0, VERR_INVALID_POINTER);
    164     AssertPtrReturn(pszHandlerRC, VERR_INVALID_POINTER);
     165    AssertPtrReturn(pszPfHandlerR0, VERR_INVALID_POINTER);
     166    AssertPtrReturn(pszPfHandlerRC, VERR_INVALID_POINTER);
    165167
    166168    /*
    167169     * Resolve the R0 handler.
    168170     */
    169     R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnHandlerR0 = NIL_RTR0PTR;
    170     int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszModR0, NULL /*pszSearchPath*/, pszHandlerR0, &pfnHandlerR0);
     171    R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0 = NIL_RTR0PTR;
     172    int rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszModR0, NULL /*pszSearchPath*/, pszPfHandlerR0, &pfnPfHandlerR0);
    171173    if (RT_SUCCESS(rc))
    172174    {
    … …  
    174176         * Resolve the GC handler.
    175177         */
    176         RTRCPTR pfnHandlerRC = NIL_RTRCPTR;
     178        RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR;
    177179        if (!HMIsEnabled(pVM))
    178             rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszHandlerRC, &pfnHandlerRC);
     180            rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszPfHandlerRC, &pfnPfHandlerRC);
    179181        if (RT_SUCCESS(rc))
    180             return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3, pfnHandlerR0, pfnHandlerRC, pszDesc, phType);
    181 
    182         AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszHandlerRC, rc));
     182            return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc, phType);
     183
     184        AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszPfHandlerRC, rc));
    183185    }
    184186    else
    185         AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModR0, pszHandlerR0, rc));
     187        AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModR0, pszPfHandlerR0, rc));
    186188
    187189    return rc;
    … …  
    282284 * @param   pfnInvalidateR3 Pointer to the ring-3 invalidation handler callback.
    283285 * @param   pfnHandlerR3    Pointer to the ring-3 handler callback.
    284  * @param   pfnHandlerRC    Pointer to the raw-mode context handler callback.
     286 * @param   pfnPfHandlerRC  Pointer to the raw-mode context handler callback.
    285287 * @param   pszDesc         The type description.
    286288 * @param   phType          Where to return the type handle (cross context
    … …  
    720722    pHlp->pfnPrintf(pHlp,
    721723        "%RGp - %RGp  %RHv  %RHv  %RRv  %RRv  %s  %s\n",
    722         pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnHandlerRC, pCur->pvUserRC,
     724        pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnPfHandlerRC, pCur->pvUserRC,
    723725                    pszType, pCur->pszDesc);
    724726#ifdef VBOX_WITH_STATISTICS

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

    r55493 r55896  
    114114*   Internal Functions                                                         *
    115115*******************************************************************************/
    116 static DECLCALLBACK(int) pgmR3PoolAccessHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
     116static FNPGMR3PHYSHANDLER pgmR3PoolAccessHandler;
    117117#ifdef VBOX_WITH_DEBUGGER
    118118static FNDBGCCMD pgmR3PoolCmdCheck;
    … …  
    284284    rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE,
    285285                                          pgmR3PoolAccessHandler,
    286                                           NULL, "pgmPoolAccessHandler",
    287                                           NULL, "pgmPoolAccessHandler",
     286                                          NULL, "pgmPoolAccessPfHandler",
     287                                          NULL, "pgmPoolAccessPfHandler",
    288288                                          "Guest Paging Access Handler",
    289289                                          &pPool->hAccessHandlerType);

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

    r55493 r55896  
    422422#endif /* IN_RING3 */
    423423
    424 VMMDECL(int)        IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    425                                    RTGCPHYS GCPhysFault, void *pvUser);
     424#ifndef IN_RING3
     425DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER))    iomMmioPfHandler;
     426#endif
    426427#ifdef IN_RING3
    427 DECLCALLBACK(int)   IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    428                                      PGMACCESSTYPE enmAccessType, void *pvUser);
     428FNPGMR3PHYSHANDLER                          iomR3MmioHandler;
    429429#endif
    430430

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

    r55895 r55896  
    590590    /** The PGM_PAGE_HNDL_PHYS_STATE_XXX value corresponding to enmKind. */
    591591    uint32_t                            uState;
    592     /** Pointer to RC callback function. */
    593     RCPTRTYPE(PFNPGMRCPHYSHANDLER)      pfnHandlerRC;
     592    /** Pointer to RC callback function for \#PFs. */
     593    RCPTRTYPE(PFNPGMRCPHYSPFHANDLER)    pfnPfHandlerRC;
    594594    /** Explicit alignment padding. */
    595595    RTRCPTR                             RCPtrPadding;
    596596    /** Pointer to R3 callback function. */
    597597    R3PTRTYPE(PFNPGMR3PHYSHANDLER)      pfnHandlerR3;
    598     /** Pointer to R0 callback function. */
    599     R0PTRTYPE(PFNPGMR0PHYSHANDLER)      pfnHandlerR0;
     598    /** Pointer to R0 callback function for \#PFs. */
     599    R0PTRTYPE(PFNPGMR0PHYSPFHANDLER)    pfnPfHandlerR0;
    600600    /** Description / Name. For easing debugging. */
    601601    R3PTRTYPE(const char *)             pszDesc;
    … …  
    710710    bool                                fRelocUserRC;
    711711    bool                                afPadding[3];
    712     /** Pointer to RC callback function. */
     712    /** Pointer to RC callback function for \#PFs. */
    713713    RCPTRTYPE(PFNPGMRCVIRTPFHANDLER)    pfnPfHandlerRC;
    714714    /** Pointer to the R3 callback function for invalidation. */
    … …  
    41464146int             pgmPhysGCPhys2CCPtrInternalReadOnly(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, const void **ppv, PPGMPAGEMAPLOCK pLock);
    41474147void            pgmPhysReleaseInternalPageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock);
    4148 VMMDECL(int)    pgmPhysHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
    4149 VMMDECL(int)    pgmPhysRomWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
     4148#ifndef IN_RING3
     4149DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysPfHandlerRedirectToHC;
     4150DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysRomWritePfHandler;
     4151#endif
    41504152int             pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys);
    41514153void            pgmPhysInvalidRamRangeTlbs(PVM pVM);
    … …  
    41594161
    41604162#ifdef IN_RING3
    4161 DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    4162                                            PGMACCESSTYPE enmAccessType, void *pvUser);
     4163FNPGMR3PHYSHANDLER pgmR3PhysRomWriteHandler;
    41634164void            pgmR3PhysRelinkRamRanges(PVM pVM);
    41644165int             pgmR3PhysRamPreAllocate(PVM pVM);

  • trunk/src/VBox/VMM/testcase/tstVMStruct.h

    r55895 r55896  
    791791    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, uState);
    792792    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR3);
    793     GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerR0);
    794     GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnHandlerRC);
     793    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerR0);
     794    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pfnPfHandlerRC);
    795795    GEN_CHECK_OFF(PGMPHYSHANDLERTYPEINT, pszDesc);
    796796    GEN_CHECK_SIZE(PGMPHYS2VIRTHANDLER);
Note: See TracChangeset for help on using the changeset viewer.

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