VirtualBox

Changeset 55903 in vbox for trunk


Ignore:
Timestamp:
May 18, 2015 12:02:58 PM (10 years ago)
Author:
vboxsync
Message:

PGM: Added a pVCpu parameter to all physical handler callouts and also a PGMACCESSORIGIN parameter to the ring-3 one. Fixed virtual handler callout mix up from previous commit.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r55900 r55903  
    121121
    122122/**
    123  * \#PF Handler callback for physical access handler ranges in RC.
    124  *
    125  * @returns VBox status code (appropriate for RC return).
    126  * @param   pVM         VM Handle.
    127  * @param   uErrorCode  CPU Error code.
    128  * @param   pRegFrame   Trap register frame.
    129  *                      NULL on DMA and other non CPU access.
    130  * @param   pvFault     The fault address (cr2).
    131  * @param   GCPhysFault The GC physical address corresponding to pvFault.
    132  * @param   pvUser      User argument.
    133  */
    134 typedef DECLCALLBACK(int) FNPGMRCPHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    135                                                RTGCPHYS GCPhysFault, void *pvUser);
    136 /** Pointer to PGM access callback. */
    137 typedef FNPGMRCPHYSPFHANDLER *PFNPGMRCPHYSPFHANDLER;
    138 
    139 /**
    140  * \#PF Handler callback for physical access handler ranges in R0.
    141  *
    142  * @returns VBox status code (appropriate for R0 return).
    143  * @param   pVM         VM Handle.
    144  * @param   uErrorCode  CPU Error code.
    145  * @param   pRegFrame   Trap register frame.
    146  *                      NULL on DMA and other non CPU access.
    147  * @param   pvFault     The fault address (cr2).
    148  * @param   GCPhysFault The GC physical address corresponding to pvFault.
    149  * @param   pvUser      User argument.
    150  */
    151 typedef DECLCALLBACK(int) FNPGMR0PHYSPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    152                                                RTGCPHYS GCPhysFault, void *pvUser);
    153 /** Pointer to PGM access callback. */
    154 typedef FNPGMR0PHYSPFHANDLER *PFNPGMR0PHYSPFHANDLER;
    155 
    156 /**
    157123 * Guest Access type
    158124 */
    … …  
    165131} PGMACCESSTYPE;
    166132
     133
     134/**
     135 * \#PF Handler callback for physical access handler ranges in RC and R0.
     136 *
     137 * @returns VBox status code (appropriate for RC return).
     138 * @param   pVM         VM Handle.
     139 * @param   pVCpu           Pointer to the cross context CPU context for the
     140 *                          calling EMT.
     141 * @param   uErrorCode  CPU Error code.
     142 * @param   pRegFrame   Trap register frame.
     143 *                      NULL on DMA and other non CPU access.
     144 * @param   pvFault     The fault address (cr2).
     145 * @param   GCPhysFault The GC physical address corresponding to pvFault.
     146 * @param   pvUser      User argument.
     147 */
     148typedef DECLCALLBACK(int) FNPGMRZPHYSPFHANDLER(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     149                                               RTGCPHYS GCPhysFault, void *pvUser);
     150/** Pointer to PGM access callback. */
     151typedef FNPGMRZPHYSPFHANDLER *PFNPGMRZPHYSPFHANDLER;
     152
     153
    167154/**
    168155 * \#PF Handler callback for physical access handler ranges (MMIO among others) in HC.
    … …  
    174161 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
    175162 * @param   pVM             VM Handle.
     163 * @param   pVCpu           Pointer to the cross context CPU context for the
     164 *                          calling EMT.
    176165 * @param   GCPhys          The physical address the guest is writing to.
    177166 * @param   pvPhys          The HC mapping of that address.
    … …  
    179168 * @param   cbBuf           How much it's reading/writing.
    180169 * @param   enmAccessType   The access type.
     170 * @param   enmOrigin       The origin of this call.
    181171 * @param   pvUser          User argument.
    182172 *
    183173 * @todo    Add pVCpu, possibly replacing pVM.
    184174 */
    185 typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    186                                              PGMACCESSTYPE enmAccessType, void *pvUser);
     175typedef DECLCALLBACK(int) FNPGMR3PHYSHANDLER(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     176                                             PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser);
    187177/** Pointer to PGM access callback. */
    188178typedef FNPGMR3PHYSHANDLER *PFNPGMR3PHYSHANDLER;
    … …  
    222212 * @param   pvUser          User argument.
    223213 */
    224 typedef DECLCALLBACK(int) FNPGMRCVIRTPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     214typedef DECLCALLBACK(int) FNPGMRCVIRTPFHANDLER(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    225215                                               RTGCPTR pvRange, uintptr_t offRange, void *pvUser);
    226216/** Pointer to PGM access callback. */
    … …  
    578568VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    579569                                                       PFNPGMR3PHYSHANDLER pfnHandlerR3,
    580                                                        R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0,
    581                                                        RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC,
     570                                                       R0PTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerR0,
     571                                                       RCPTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerRC,
    582572                                                       const char *pszDesc, PPGMPHYSHANDLERTYPE phType);
    583573VMMR3DECL(int)      PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind,

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

    r55899 r55903  
    17351735 * @returns VBox status code (appropriate for GC return).
    17361736 * @param   pVM         Pointer to the VM.
     1737 * @param   pVCpu       Pointer to the cross context CPU context for the
     1738 *                      calling EMT.
    17371739 * @param   uErrorCode  CPU Error code.
    17381740 * @param   pCtxCore    Trap register frame.
    … …  
    17411743 * @param   pvUser      Pointer to the MMIO ring-3 range entry.
    17421744 */
    1743 DECLEXPORT(int) iomMmioPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault,
     1745DECLEXPORT(int) iomMmioPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore, RTGCPTR pvFault,
    17441746                                 RTGCPHYS GCPhysFault, void *pvUser)
    17451747{
    17461748    LogFlow(("iomMmioPfHandler: GCPhys=%RGp uErr=%#x pvFault=%RGv rip=%RGv\n",
    17471749             GCPhysFault, (uint32_t)uErrorCode, pvFault, (RTGCPTR)pCtxCore->rip));
    1748     VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, VMMGetCpu(pVM), (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
     1750    VBOXSTRICTRC rcStrict = iomMMIOHandler(pVM, pVCpu, (uint32_t)uErrorCode, pCtxCore, GCPhysFault, pvUser);
    17491751    return VBOXSTRICTRC_VAL(rcStrict);
    17501752}
    … …  
    17931795 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
    17941796 * @param   pVM             Pointer to the VM.
     1797 * @param   pVCpu           The cross context CPU structure for the calling EMT.
    17951798 * @param   GCPhys          The physical address the guest is writing to.
    17961799 * @param   pvPhys          The HC mapping of that address.
    … …  
    17981801 * @param   cbBuf           How much it's reading/writing.
    17991802 * @param   enmAccessType   The access type.
     1803 * @param   enmOrigin       Who is making the access.
    18001804 * @param   pvUser          Pointer to the MMIO range entry.
    18011805 */
    1802 DECLCALLBACK(int) iomR3MmioHandler(PVM pVM, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf,
    1803                                    PGMACCESSTYPE enmAccessType, void *pvUser)
    1804 {
    1805     PVMCPU        pVCpu = VMMGetCpu(pVM);
     1806DECLCALLBACK(int) iomR3MmioHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf, size_t cbBuf,
     1807                                   PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
     1808{
    18061809    PIOMMMIORANGE pRange = (PIOMMMIORANGE)pvUser;
    18071810    STAM_COUNTER_INC(&pVM->iom.s.StatR3MMIOHandler);
    … …  
    18091812    AssertMsg(cbBuf >= 1 && cbBuf <= 16, ("%zu\n", cbBuf));
    18101813    AssertPtr(pRange);
    1811     NOREF(pvPhys);
     1814    NOREF(pvPhys); NOREF(enmOrigin);
    18121815
    18131816    /*

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

    r55896 r55903  
    260260                }
    261261
    262                 rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
     262                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault, pvUser);
    263263
    264264#  ifdef VBOX_WITH_STATISTICS
    … …  
    330330                STAM_PROFILE_START(&pCur->Stat, h);
    331331                RTGCPTR GCPtrStart = pCur->Core.Key;
     332                void *pvUser = pCur->CTX_SUFF(pvUser);
    332333                pgmUnlock(pVM);
    333334                *pfLockTaken = false;
    334335
    335                 rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPtrStart, pvFault - GCPtrStart,
    336                                                       pCur->pvUserRC);
     336                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart,
     337                                                      pvFault - GCPtrStart, pvUser);
    337338
    338339#    ifdef VBOX_WITH_STATISTICS
    … …  
    370371                    STAM_PROFILE_START(&pCur->Stat, h);
    371372                    RTGCPTR GCPtrStart = pCur->Core.Key;
     373                    void *pvUser = pCur->CTX_SUFF(pvUser);
    372374                    pgmUnlock(pVM);
    373375                    *pfLockTaken = false;
    … …  
    377379                                - (GCPtrStart & PAGE_OFFSET_MASK);
    378380                    Assert(off < pCur->cb);
    379                     rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPtrStart, off, pCur->pvUserRC);
     381                    rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPtrStart, off, pvUser);
    380382
    381383#    ifdef VBOX_WITH_STATISTICS
    … …  
    721723                    STAM_PROFILE_START(&pCur->Stat, h);
    722724                    PPGMVIRTHANDLERTYPEINT pCurType = PGMVIRTANDLER_GET_TYPE(pVM, pCur);
     725                    void *pvUser = pCur->CTX_SUFF(pvUser);
    723726                    pgmUnlock(pVM);
    724                     rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key,
    725                                                           pCur->pvUserRC);
     727                    rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, pCur->Core.Key,
     728                                                          pvFault - pCur->Core.Key, pvUser);
    726729                    pgmLock(pVM);
    727730                    STAM_PROFILE_STOP(&pCur->Stat, h);
    … …  
    816819#   ifdef IN_RC
    817820                STAM_PROFILE_START(&pCur->Stat, h);
     821                void *pvUser = pCur->CTX_SUFF(pvUser);
    818822                pgmUnlock(pVM);
    819                 rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key,
    820                                                       pCur->pvUserRC);
     823                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, pCur->Core.Key,
     824                                                      pvFault - pCur->Core.Key, pvUser);
    821825                pgmLock(pVM);
    822826                STAM_PROFILE_STOP(&pCur->Stat, h);

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

    r55900 r55903  
    5858 * @returns VBox status code (appropriate for trap handling and GC return).
    5959 * @param   pVM         Pointer to the VM.
     60 * @param   pVCpu       Pointer to the cross context CPU context for the
     61 *                      calling EMT.
    6062 * @param   uErrorCode  CPU Error code.
    6163 * @param   pRegFrame   Trap register frame.
    … …  
    6466 * @param   pvUser      User argument.
    6567 */
    66 VMMDECL(int) pgmPhysPfHandlerRedirectToHC(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     68VMMDECL(int) pgmPhysPfHandlerRedirectToHC(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    6769                                          RTGCPHYS GCPhysFault, void *pvUser)
    6870{
    69     NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser);
     71    NOREF(pVM); NOREF(pVCpu); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(GCPhysFault); NOREF(pvUser);
    7072    return (uErrorCode & X86_TRAP_PF_RW) ? VINF_IOM_R3_MMIO_WRITE : VINF_IOM_R3_MMIO_READ;
    7173}
    … …  
    7880 * @returns VBox status code (appropriate for trap handling and GC return).
    7981 * @param   pVM         Pointer to the VM.
     82 * @param   pVCpu       Pointer to the cross context CPU context for the
     83 *                      calling EMT.
    8084 * @param   uErrorCode  CPU Error code.
    8185 * @param   pRegFrame   Trap register frame.
    … …  
    8488 * @param   pvUser      User argument. Pointer to the ROM range structure.
    8589 */
    86 DECLEXPORT(int) pgmPhysRomWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     90DECLEXPORT(int) pgmPhysRomWritePfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    8791                                         RTGCPHYS GCPhysFault, void *pvUser)
    8892{
    … …  
    9094    PPGMROMRANGE    pRom = (PPGMROMRANGE)pvUser;
    9195    uint32_t        iPage = (GCPhysFault - pRom->GCPhys) >> PAGE_SHIFT;
    92     PVMCPU          pVCpu = VMMGetCpu(pVM);
    9396    NOREF(uErrorCode); NOREF(pvFault);
    9497
    … …  
    21312134        /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    21322135        pgmUnlock(pVM);
    2133         rc = pfnHandler(pVM, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, pvUser);
     2136        rc = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, pvUser);
    21342137        pgmLock(pVM);
    21352138# ifdef VBOX_WITH_STATISTICS
    … …  
    23912394                /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    23922395                pgmUnlock(pVM);
    2393                 rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
     2396                rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    23942397                pgmLock(pVM);
    23952398# ifdef VBOX_WITH_STATISTICS
    … …  
    26172620            /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    26182621            pgmUnlock(pVM);
    2619             rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
     2622            rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    26202623            pgmLock(pVM);
    26212624# ifdef VBOX_WITH_STATISTICS
    … …  
    26922695            /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
    26932696            pgmUnlock(pVM);
    2694             rc = pfnHandler(pVM, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, pvUser);
     2697            rc = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
    26952698            pgmLock(pVM);
    26962699# ifdef VBOX_WITH_STATISTICS

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

    r55896 r55903  
    5252static void pgmPoolMonitorModifiedRemove(PPGMPOOL pPool, PPGMPOOLPAGE pPage);
    5353#ifndef IN_RING3
    54 DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPoolAccessPfHandler;
     54DECLEXPORT(FNPGMRZPHYSPFHANDLER) pgmPoolAccessPfHandler;
    5555#endif
    5656#if defined(LOG_ENABLED) || defined(VBOX_STRICT)
    … …  
    10511051 * @returns VBox status code (appropriate for GC return).
    10521052 * @param   pVM         Pointer to the VM.
     1053 * @param   pVCpu       Pointer to the cross context CPU context for the
     1054 *                      calling EMT.
    10531055 * @param   uErrorCode  CPU Error code.
    10541056 * @param   pRegFrame   Trap register frame.
    … …  
    10581060 * @param   pvUser      User argument.
    10591061 */
    1060 DECLEXPORT(int) pgmPoolAccessPfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
     1062DECLEXPORT(int) pgmPoolAccessPfHandler(PVM pVM, PVMCPU pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
    10611063                                       RTGCPHYS GCPhysFault, void *pvUser)
    10621064{
    … …  
    10641066    PPGMPOOL        pPool = pVM->pgm.s.CTX_SUFF(pPool);
    10651067    PPGMPOOLPAGE    pPage = (PPGMPOOLPAGE)pvUser;
    1066     PVMCPU          pVCpu = VMMGetCpu(pVM);
    10671068    unsigned        cMaxModifications;
    10681069    bool            fForcedFlush = false;

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

    r55896 r55903  
    587587
    588588                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,
     589                rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
    590590                                                          GCPhysFault, GCPhysFault, pvUser);
    591591

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

    r55493 r55903  
    7070static DECLCALLBACK(int) gimR3Save(PVM pVM, PSSMHANDLE pSSM);
    7171static DECLCALLBACK(int) gimR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uSSMVersion, uint32_t uPass);
     72static FNPGMR3PHYSHANDLER gimR3Mmio2WriteHandler;
    7273
    7374
    … …  
    486487 *
    487488 * @returns VBox status code.
    488  * @param pVM               Pointer to the VM.
    489  * @param GCPhys            The guest-physical address of the region.
    490  * @param pvPhys            Pointer to the region in the guest address space.
    491  * @param pvBuf             Pointer to the data being read/written.
    492  * @param cbBuf             The size of the buffer in @a pvBuf.
    493  * @param enmAccessType     The type of access.
    494  * @param pvUser            User argument (NULL, not used).
    495  */
    496 static DECLCALLBACK(int) gimR3Mmio2WriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    497                                                 PGMACCESSTYPE enmAccessType, void *pvUser)
     489 * @param   pVM             Pointer to the VM.
     490 * @param   pVCpu           The cross context CPU structure for the calling EMT.
     491 * @param   GCPhys          The guest-physical address of the region.
     492 * @param   pvPhys          Pointer to the region in the guest address space.
     493 * @param   pvBuf           Pointer to the data being read/written.
     494 * @param   cbBuf           The size of the buffer in @a pvBuf.
     495 * @param   enmAccessType   The type of access.
     496 * @param   enmOrigin       Who is making the access.
     497 * @param   pvUser          User argument (NULL, not used).
     498 */
     499static DECLCALLBACK(int) gimR3Mmio2WriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     500                                                PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    498501{
    499502    /*

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

    r55897 r55903  
    8282VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind,
    8383                                                       PFNPGMR3PHYSHANDLER pfnHandlerR3,
    84                                                        R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0,
    85                                                        RCPTRTYPE(PFNPGMRCPHYSPFHANDLER) pfnPfHandlerRC,
     84                                                       R0PTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerR0,
     85                                                       RCPTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerRC,
    8686                                                       const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
    8787{

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

    r55899 r55903  
    35023502 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
    35033503 * @param   pVM             Pointer to the VM.
     3504 * @param   pVCpu           The cross context CPU structure for the calling EMT.
    35043505 * @param   GCPhys          The physical address the guest is writing to.
    35053506 * @param   pvPhys          The HC mapping of that address.
    … …  
    35073508 * @param   cbBuf           How much it's reading/writing.
    35083509 * @param   enmAccessType   The access type.
     3510 * @param   enmOrigin       Who is making the access.
    35093511 * @param   pvUser          User argument.
    35103512 */
    3511 DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    3512                                            PGMACCESSTYPE enmAccessType, void *pvUser)
     3513DECLCALLBACK(int) pgmR3PhysRomWriteHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     3514                                           PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    35133515{
    35143516    PPGMROMRANGE    pRom     = (PPGMROMRANGE)pvUser;
    … …  
    35173519    PPGMROMPAGE     pRomPage = &pRom->aPages[iPage];
    35183520    Log5(("pgmR3PhysRomWriteHandler: %d %c %#08RGp %#04zx\n", pRomPage->enmProt, enmAccessType == PGMACCESSTYPE_READ ? 'R' : 'W', GCPhys, cbBuf));
    3519     NOREF(pvPhys);
     3521    NOREF(pVCpu); NOREF(pvPhys); NOREF(enmOrigin);
    35203522
    35213523    if (enmAccessType == PGMACCESSTYPE_READ)

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

    r55896 r55903  
    518518 * @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
    519519 * @param   pVM             Pointer to the VM.
     520 * @param   pVCpu           The cross context CPU structure for the calling EMT.
    520521 * @param   GCPhys          The physical address the guest is writing to.
    521522 * @param   pvPhys          The HC mapping of that address.
    … …  
    523524 * @param   cbBuf           How much it's reading/writing.
    524525 * @param   enmAccessType   The access type.
     526 * @param   enmOrigin       Who is making the access.
    525527 * @param   pvUser          User argument.
    526528 */
    527 static DECLCALLBACK(int) pgmR3PoolAccessHandler(PVM pVM, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
    528                                                 PGMACCESSTYPE enmAccessType, void *pvUser)
     529static DECLCALLBACK(int) pgmR3PoolAccessHandler(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
     530                                                PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, void *pvUser)
    529531{
    530532    STAM_PROFILE_START(&pVM->pgm.s.pPoolR3->StatMonitorR3, a);
    531533    PPGMPOOL        pPool = pVM->pgm.s.pPoolR3;
    532534    PPGMPOOLPAGE    pPage = (PPGMPOOLPAGE)pvUser;
    533     PVMCPU          pVCpu = VMMGetCpu(pVM);
    534535    LogFlow(("pgmR3PoolAccessHandler: GCPhys=%RGp %p:{.Core=%RHp, .idx=%d, .GCPhys=%RGp, .enmType=%d}\n",
    535536             GCPhys, pPage, pPage->Core.Key, pPage->idx, pPage->GCPhys, pPage->enmKind));
    536537
    537     NOREF(pvBuf); NOREF(enmAccessType);
     538    NOREF(pvBuf); NOREF(enmAccessType); NOREF(enmOrigin);
    538539
    539540    /*

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

    r55896 r55903  
    423423
    424424#ifndef IN_RING3
    425 DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER))    iomMmioPfHandler;
     425DECLEXPORT(FNPGMRZPHYSPFHANDLER)    iomMmioPfHandler;
    426426#endif
    427427#ifdef IN_RING3
    428 FNPGMR3PHYSHANDLER                          iomR3MmioHandler;
     428FNPGMR3PHYSHANDLER                  iomR3MmioHandler;
    429429#endif
    430430

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

    r55896 r55903  
    591591    uint32_t                            uState;
    592592    /** Pointer to RC callback function for \#PFs. */
    593     RCPTRTYPE(PFNPGMRCPHYSPFHANDLER)    pfnPfHandlerRC;
     593    RCPTRTYPE(PFNPGMRZPHYSPFHANDLER)    pfnPfHandlerRC;
    594594    /** Explicit alignment padding. */
    595595    RTRCPTR                             RCPtrPadding;
    … …  
    597597    R3PTRTYPE(PFNPGMR3PHYSHANDLER)      pfnHandlerR3;
    598598    /** Pointer to R0 callback function for \#PFs. */
    599     R0PTRTYPE(PFNPGMR0PHYSPFHANDLER)    pfnPfHandlerR0;
     599    R0PTRTYPE(PFNPGMRZPHYSPFHANDLER)    pfnPfHandlerR0;
    600600    /** Description / Name. For easing debugging. */
    601601    R3PTRTYPE(const char *)             pszDesc;
    … …  
    41474147void            pgmPhysReleaseInternalPageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock);
    41484148#ifndef IN_RING3
    4149 DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysPfHandlerRedirectToHC;
    4150 DECLEXPORT(CTX_MID(FNPGM,PHYSPFHANDLER)) pgmPhysRomWritePfHandler;
     4149DECLEXPORT(FNPGMRZPHYSPFHANDLER) pgmPhysPfHandlerRedirectToHC;
     4150DECLEXPORT(FNPGMRZPHYSPFHANDLER) pgmPhysRomWritePfHandler;
    41514151#endif
    41524152int             pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys);
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