VirtualBox

Changeset 18988 in vbox for trunk/src/VBox/VMM/VMMAll


Ignore:
Timestamp:
Apr 17, 2009 1:00:59 PM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
46080
Message:

PGM api changes

Location:
trunk/src/VBox/VMM/VMMAll
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r18927 r18988  
    456456        PIOMMMIORANGE pMMIODst;
    457457        RTGCPHYS PhysDst;
    458         rc = PGMGstGetPage(pVM, (RTGCPTR)pu8Virt, NULL, &PhysDst);
     458        rc = PGMGstGetPage((RTGCPTR)pu8Virt, NULL, &PhysDst);
    459459        PhysDst |= (RTGCUINTPTR)pu8Virt & PAGE_OFFSET_MASK;
    460460        if (    RT_SUCCESS(rc)
    … …  
    18761876            uint64_t fFlags;
    18771877            RTHCPHYS HCPhys;
    1878             rc = PGMShwGetPage(pVM, pVCpu, (RTGCPTR)GCPhys, &fFlags, &HCPhys);
     1878            rc = PGMShwGetPage(pVCpu, (RTGCPTR)GCPhys, &fFlags, &HCPhys);
    18791879            Assert(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
    18801880            cb     -= PAGE_SIZE;

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

    r18958 r18988  
    451451     * Call the worker.
    452452     */
    453     int rc = PGM_BTH_PFN(Trap0eHandler, pVM)(pVM, pVCpu, uErr, pRegFrame, pvFault);
     453    int rc = PGM_BTH_PFN(Trap0eHandler, pVCpu)(pVM, pVCpu, uErr, pRegFrame, pvFault);
    454454    if (rc == VINF_PGM_SYNCPAGE_MODIFIED_PDE)
    455455        rc = VINF_SUCCESS;
    … …  
    479479{
    480480    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
    481     int rc = PGM_BTH_PFN(PrefetchPage, pVM)(pVM, pVCpu, GCPtrPage);
     481    int rc = PGM_BTH_PFN(PrefetchPage, pVCpu)(pVM, pVCpu, GCPtrPage);
    482482    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,Prefetch), a);
    483483    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
    … …  
    535535
    536536    uint64_t fPage;
    537     int rc = PGMGstGetPage(pVM, pVCpu, (RTGCPTR)Addr, &fPage, NULL);
     537    int rc = PGMGstGetPage(pVCpu, (RTGCPTR)Addr, &fPage, NULL);
    538538    if (RT_FAILURE(rc))
    539539    {
    … …  
    584584     */
    585585    uint64_t fPageGst;
    586     int rc = PGMGstGetPage(pVM, pVCpu, (RTGCPTR)Addr, &fPageGst, NULL);
     586    int rc = PGMGstGetPage(pVCpu, (RTGCPTR)Addr, &fPageGst, NULL);
    587587    if (RT_FAILURE(rc))
    588588    {
    … …  
    612612         * Next step is to verify if we protected this page for dirty bit tracking or for CSAM scanning
    613613         */
    614         rc = PGMShwGetPage(pVM, pVCpu, (RTGCPTR)Addr, NULL, NULL);
     614        rc = PGMShwGetPage(pVCpu, (RTGCPTR)Addr, NULL, NULL);
    615615        if (    rc == VERR_PAGE_NOT_PRESENT
    616616            ||  rc == VERR_PAGE_TABLE_NOT_PRESENT)
    … …  
    622622            Assert(X86_TRAP_PF_RW == X86_PTE_RW && X86_TRAP_PF_US == X86_PTE_US);
    623623            uint32_t uErr = fAccess & (X86_TRAP_PF_RW | X86_TRAP_PF_US);
    624             rc = PGM_BTH_PFN(VerifyAccessSyncPage, pVM)(pVM, pVCpu, Addr, fPageGst, uErr);
     624            rc = PGM_BTH_PFN(VerifyAccessSyncPage, pVCpu)(pVM, pVCpu, Addr, fPageGst, uErr);
    625625            if (rc != VINF_SUCCESS)
    626626                return rc;
    … …  
    636636    /** @note this will assert when writing to monitored pages (a bit annoying actually) */
    637637    uint64_t fPageShw;
    638     rc = PGMShwGetPage(pVM, pVCpu, (RTGCPTR)Addr, &fPageShw, NULL);
     638    rc = PGMShwGetPage(pVCpu, (RTGCPTR)Addr, &fPageShw, NULL);
    639639    if (    (rc == VERR_PAGE_NOT_PRESENT || RT_FAILURE(rc))
    640640        || (fWrite && !(fPageShw & X86_PTE_RW))
    … …  
    710710    {
    711711        if (    pgmGetMapping(pVM, GCPtrPage)
    712             &&  PGMGstGetPage(pVM, pVCpu, GCPtrPage, NULL, NULL) != VERR_PAGE_TABLE_NOT_PRESENT)
     712            &&  PGMGstGetPage(pVCpu, GCPtrPage, NULL, NULL) != VERR_PAGE_TABLE_NOT_PRESENT)
    713713        {
    714714            LogFlow(("PGMGCInvalidatePage: Conflict!\n"));
    … …  
    731731     */
    732732    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
    733     rc = PGM_BTH_PFN(InvalidatePage, pVM)(pVM, pVCpu, GCPtrPage);
     733    rc = PGM_BTH_PFN(InvalidatePage, pVCpu)(pVM, pVCpu, GCPtrPage);
    734734    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePage), a);
    735735
    … …  
    782782 *
    783783 * @returns VBox status.
    784  * @param   pVM         VM Handle.
    785784 * @param   pVCpu       VMCPU handle.
    786785 * @param   GCPtr       Guest Context virtual address of the page.
    … …  
    790789 * @remark  You should use PGMMapGetPage() for pages in a mapping.
    791790 */
    792 VMMDECL(int) PGMShwGetPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
    793 {
    794     return PGM_SHW_PFN(GetPage,pVM)(pVM, pVCpu, GCPtr, pfFlags, pHCPhys);
     791VMMDECL(int) PGMShwGetPage(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
     792{
     793    return PGM_SHW_PFN(GetPage, pVCpu)(pVCpu, GCPtr, pfFlags, pHCPhys);
    795794}
    796795
    … …  
    800799 *
    801800 * @returns VBox status.
    802  * @param   pVM         VM handle.
    803801 * @param   pVCpu       VMCPU handle.
    804802 * @param   GCPtr       The address of the first page.
    … …  
    807805 * @remark  You must use PGMMapSetPage() for pages in a mapping.
    808806 */
    809 VMMDECL(int) PGMShwSetPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
    810 {
    811     return PGMShwModifyPage(pVM, pVCpu, GCPtr, cb, fFlags, 0);
     807VMMDECL(int) PGMShwSetPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
     808{
     809    return PGMShwModifyPage(pVCpu, GCPtr, cb, fFlags, 0);
    812810}
    813811
    … …  
    819817 *
    820818 * @returns VBox status code.
    821  * @param   pVM         VM handle.
    822819 * @param   pVCpu       VMCPU handle.
    823820 * @param   GCPtr       Virtual address of the first page in the range.
    … …  
    828825 * @remark  You must use PGMMapModifyPage() for pages in a mapping.
    829826 */
    830 VMMDECL(int) PGMShwModifyPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
     827VMMDECL(int) PGMShwModifyPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
    831828{
    832829    AssertMsg(!(fFlags & X86_PTE_PAE_PG_MASK), ("fFlags=%#llx\n", fFlags));
    … …  
    843840     * Call worker.
    844841     */
    845     return PGM_SHW_PFN(ModifyPage, pVM)(pVM, pVCpu, GCPtr, cb, fFlags, fMask);
     842    return PGM_SHW_PFN(ModifyPage, pVCpu)(pVCpu, GCPtr, cb, fFlags, fMask);
    846843}
    847844
    … …  
    12571254 *
    12581255 * @returns VBox status.
    1259  * @param   pVM         VM Handle.
    12601256 * @param   pVCpu       VMCPU handle.
    12611257 * @param   GCPtr       Guest Context virtual address of the page.
    … …  
    12641260 *                      This is page aligned. The fact that the
    12651261 */
    1266 VMMDECL(int) PGMGstGetPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
    1267 {
    1268     return PGM_GST_PFN(GetPage,pVM)(pVM, pVCpu, GCPtr, pfFlags, pGCPhys);
     1262VMMDECL(int) PGMGstGetPage(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
     1263{
     1264    return PGM_GST_PFN(GetPage, pVCpu)(pVCpu, GCPtr, pfFlags, pGCPhys);
    12691265}
    12701266
    … …  
    12751271 * @returns true if the page is present.
    12761272 * @returns false if the page is not present.
    1277  * @param   pVM         The VM handle.
    12781273 * @param   pVCpu       VMCPU handle.
    12791274 * @param   GCPtr       Address within the page.
    12801275 */
    1281 VMMDECL(bool) PGMGstIsPagePresent(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr)
    1282 {
    1283     int rc = PGMGstGetPage(pVM, pVCpu, GCPtr, NULL, NULL);
     1276VMMDECL(bool) PGMGstIsPagePresent(PVMCPU pVCpu, RTGCPTR GCPtr)
     1277{
     1278    int rc = PGMGstGetPage(pVCpu, GCPtr, NULL, NULL);
    12841279    return RT_SUCCESS(rc);
    12851280}
    … …  
    12901285 *
    12911286 * @returns VBox status.
    1292  * @param   pVM         VM handle.
    12931287 * @param   pVCpu       VMCPU handle.
    12941288 * @param   GCPtr       The address of the first page.
    … …  
    12961290 * @param   fFlags      Page flags X86_PTE_*, excluding the page mask of course.
    12971291 */
    1298 VMMDECL(int)  PGMGstSetPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
    1299 {
    1300     return PGMGstModifyPage(pVM, pVCpu, GCPtr, cb, fFlags, 0);
     1292VMMDECL(int)  PGMGstSetPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags)
     1293{
     1294    return PGMGstModifyPage(pVCpu, GCPtr, cb, fFlags, 0);
    13011295}
    13021296
    … …  
    13081302 *
    13091303 * @returns VBox status code.
    1310  * @param   pVM         VM handle.
    13111304 * @param   pVCpu       VMCPU handle.
    13121305 * @param   GCPtr       Virtual address of the first page in the range.
    … …  
    13161309 *                      Be very CAREFUL when ~'ing constants which could be 32-bit!
    13171310 */
    1318 VMMDECL(int)  PGMGstModifyPage(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
     1311VMMDECL(int)  PGMGstModifyPage(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
    13191312{
    13201313    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
    … …  
    13381331     * Call worker.
    13391332     */
    1340     int rc = PGM_GST_PFN(ModifyPage, pVM)(pVM, pVCpu, GCPtr, cb, fFlags, fMask);
     1333    int rc = PGM_GST_PFN(ModifyPage, pVCpu)(pVCpu, GCPtr, cb, fFlags, fMask);
    13411334
    13421335    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,GstModifyPage), a);
    … …  
    16871680        RTGCPHYS GCPhysOldCR3 = pVCpu->pgm.s.GCPhysCR3;
    16881681        pVCpu->pgm.s.GCPhysCR3  = GCPhysCR3;
    1689         rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, pVCpu, GCPhysCR3);
     1682        rc = PGM_BTH_PFN(MapCR3, pVCpu)(pVM, pVCpu, GCPhysCR3);
    16901683        if (RT_LIKELY(rc == VINF_SUCCESS))
    16911684        {
    … …  
    17801773    {
    17811774        pVCpu->pgm.s.GCPhysCR3 = GCPhysCR3;
    1782         rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, pVCpu, GCPhysCR3);
     1775        rc = PGM_BTH_PFN(MapCR3, pVCpu)(pVM, pVCpu, GCPhysCR3);
    17831776        AssertRCSuccess(rc); /* Assumes VINF_PGM_SYNC_CR3 doesn't apply to nested paging. */ /** @todo this isn't true for the mac, but we need hw to test/fix this. */
    17841777    }
    … …  
    18661859        {
    18671860            pVCpu->pgm.s.GCPhysCR3 = GCPhysCR3;
    1868             rc = PGM_BTH_PFN(MapCR3, pVM)(pVM, pVCpu, GCPhysCR3);
     1861            rc = PGM_BTH_PFN(MapCR3, pVCpu)(pVM, pVCpu, GCPhysCR3);
    18691862        }
    18701863#ifdef IN_RING3
    … …  
    18861879     */
    18871880    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    1888     rc = PGM_BTH_PFN(SyncCR3, pVM)(pVM, pVCpu, cr0, cr3, cr4, fGlobal);
     1881    rc = PGM_BTH_PFN(SyncCR3, pVCpu)(pVM, pVCpu, cr0, cr3, cr4, fGlobal);
    18891882    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    18901883    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 || RT_FAILURE(rc), ("rc=%Rrc\n", rc));
    … …  
    25142507              GCPtr += PAGE_SIZE)
    25152508        {
    2516             int rc = PGMGstGetPage(pVM, pVCpu, (RTGCPTR)GCPtr, NULL, NULL);
     2509            int rc = PGMGstGetPage(pVCpu, (RTGCPTR)GCPtr, NULL, NULL);
    25172510            if (rc != VERR_PAGE_TABLE_NOT_PRESENT)
    25182511            {
    … …  
    25442537{
    25452538    STAM_PROFILE_START(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    2546     unsigned cErrors = PGM_BTH_PFN(AssertCR3, pVM)(pVM, pVCpu, cr3, cr4, 0, ~(RTGCPTR)0);
     2539    unsigned cErrors = PGM_BTH_PFN(AssertCR3, pVCpu)(pVM, pVCpu, cr3, cr4, 0, ~(RTGCPTR)0);
    25472540    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncCR3), a);
    25482541    return cErrors;

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

    r18947 r18988  
    652652                RTGCPHYS   GCPhys;
    653653                uint64_t   fPageGst;
    654                 PGMGstGetPage(pVM, pVCpu, pvFault, &fPageGst, &GCPhys);
     654                PGMGstGetPage(pVCpu, pvFault, &fPageGst, &GCPhys);
    655655                Log(("Page out of sync: %RGv eip=%08x PdeSrc.n.u1User=%d fPageGst=%08llx GCPhys=%RGp scan=%d\n",
    656656                     pvFault, pRegFrame->eip, PdeSrc.n.u1User, fPageGst, GCPhys, CSAMDoesPageNeedScanning(pVM, (RTRCPTR)pRegFrame->eip)));
    … …  
    661661                {
    662662                    uint64_t fPageGst;
    663                     rc = PGMGstGetPage(pVM, pVCpu, pvFault, &fPageGst, NULL);
     663                    rc = PGMGstGetPage(pVCpu, pvFault, &fPageGst, NULL);
    664664                    if (    RT_SUCCESS(rc)
    665665                        && !(fPageGst & X86_PTE_US))
    … …  
    787787                        RTGCPHYS GCPhys;
    788788                        uint64_t fPageGst;
    789                         rc = PGMGstGetPage(pVM, pVCpu, pvFault, &fPageGst, &GCPhys);
     789                        rc = PGMGstGetPage(pVCpu, pvFault, &fPageGst, &GCPhys);
    790790                        Assert(RT_SUCCESS(rc) && fPageGst & X86_PTE_RW);
    791791                        LogFlow(("Obsolete physical monitor page out of sync %RGv - phys %RGp flags=%08llx\n", pvFault, GCPhys, (uint64_t)fPageGst));
    792792
    793793                        uint64_t fPageShw;
    794                         rc = PGMShwGetPage(pVM, pVCpu, pvFault, &fPageShw, NULL);
     794                        rc = PGMShwGetPage(pVCpu, pvFault, &fPageShw, NULL);
    795795                        AssertMsg(RT_SUCCESS(rc) && fPageShw & X86_PTE_RW, ("rc=%Rrc fPageShw=%RX64\n", rc, fPageShw));
    796796#   endif /* VBOX_STRICT */
    … …  
    806806                    {
    807807                        uint64_t fPageGst;
    808                         rc = PGMGstGetPage(pVM, pVCpu, pvFault, &fPageGst, NULL);
     808                        rc = PGMGstGetPage(pVCpu, pvFault, &fPageGst, NULL);
    809809                        if (    RT_SUCCESS(rc)
    810810                            && !(fPageGst & X86_PTE_RW))
    … …  
    831831                    /* Get guest page flags. */
    832832                    uint64_t fPageGst;
    833                     rc = PGMGstGetPage(pVM, pVCpu, pvFault, &fPageGst, NULL);
     833                    rc = PGMGstGetPage(pVCpu, pvFault, &fPageGst, NULL);
    834834                    if (RT_SUCCESS(rc))
    835835                    {
    836836                        uint64_t fPageShw;
    837                         rc = PGMShwGetPage(pVM, pVCpu, pvFault, &fPageShw, NULL);
     837                        rc = PGMShwGetPage(pVCpu, pvFault, &fPageShw, NULL);
    838838
    839839                        /*
    … …  
    34043404# if !defined(IN_RING0) && PGM_GST_TYPE != PGM_TYPE_AMD64
    34053405#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    3406     rc = PGMShwGetPage(pVM, pVCpu, (RTGCPTR)pPGM->pGst32BitPdRC, NULL, &HCPhysShw);
     3406    rc = PGMShwGetPage(pVCpu, (RTGCPTR)pPGM->pGst32BitPdRC, NULL, &HCPhysShw);
    34073407#  else
    3408     rc = PGMShwGetPage(pVM, pVCpu, (RTGCPTR)pPGM->pGstPaePdptRC, NULL, &HCPhysShw);
     3408    rc = PGMShwGetPage(pVCpu, (RTGCPTR)pPGM->pGstPaePdptRC, NULL, &HCPhysShw);
    34093409#  endif
    34103410    AssertRCReturn(rc, 1);

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

    r18987 r18988  
    2525*******************************************************************************/
    2626__BEGIN_DECLS
    27 PGM_GST_DECL(int, GetPage)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys);
    28 PGM_GST_DECL(int, ModifyPage)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask);
    29 PGM_GST_DECL(int, GetPDE)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, PX86PDEPAE pPDE);
     27PGM_GST_DECL(int, GetPage)(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys);
     28PGM_GST_DECL(int, ModifyPage)(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask);
     29PGM_GST_DECL(int, GetPDE)(PVMCPU pVCpu, RTGCPTR GCPtr, PX86PDEPAE pPDE);
    3030PGM_GST_DECL(bool, HandlerVirtualUpdate)(PVM pVM, uint32_t cr4);
    3131__END_DECLS
    … …  
    4242 *
    4343 * @returns VBox status.
    44  * @param   pVM         VM Handle.
    4544 * @param   pVCpu       The VMCPU handle.
    4645 * @param   GCPtr       Guest Context virtual address of the page. Page aligned!
    … …  
    4948 *                      This is page aligned. The fact that the
    5049 */
    51 PGM_GST_DECL(int, GetPage)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
     50PGM_GST_DECL(int, GetPage)(PVMCPU pVCpu, RTGCPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys)
    5251{
    5352#if PGM_GST_TYPE == PGM_TYPE_REAL \
    … …  
    6463#elif PGM_GST_TYPE == PGM_TYPE_32BIT || PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    6564
     65    PVM pVM = pVCpu->CTX_SUFF(pVM);
    6666    /*
    6767     * Get the PDE.
    … …  
    168168 *
    169169 * @returns VBox status code.
    170  * @param   pVM         VM handle.
    171170 * @param   pVCpu       The VMCPU handle.
    172171 * @param   GCPtr       Virtual address of the first page in the range. Page aligned!
    … …  
    175174 * @param   fMask       The AND mask - page flags X86_PTE_*.
    176175 */
    177 PGM_GST_DECL(int, ModifyPage)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
     176PGM_GST_DECL(int, ModifyPage)(PVMCPU pVCpu, RTGCPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
    178177{
    179178#if PGM_GST_TYPE == PGM_TYPE_32BIT \
    … …  
    181180 || PGM_GST_TYPE == PGM_TYPE_AMD64
    182181
     182    PVM pVM = pVCpu->CTX_SUFF(pVM);
    183183    for (;;)
    184184    {
    … …  
    275275 *
    276276 * @returns VBox status code.
    277  * @param   pVM         The virtual machine.
    278277 * @param   pVCpu       The VMCPU handle.
    279278 * @param   GCPtr       Guest context pointer
    280279 * @param   pPDE        Pointer to guest PDE structure
    281280 */
    282 PGM_GST_DECL(int, GetPDE)(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, PX86PDEPAE pPDE)
     281PGM_GST_DECL(int, GetPDE)(PVMCPU pVCpu, RTGCPTR GCPtr, PX86PDEPAE pPDE)
    283282{
    284283#if PGM_GST_TYPE == PGM_TYPE_32BIT \

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

    r18927 r18988  
    14251425            RTGCPHYS   GCPhysGst;
    14261426            uint64_t   fGst;
    1427             int rc = PGMGstGetPage(pVM, pVCpu, (RTGCPTR)GCPtr, &fGst, &GCPhysGst);
     1427            int rc = PGMGstGetPage(pVCpu, (RTGCPTR)GCPtr, &fGst, &GCPhysGst);
    14281428            if (    rc == VERR_PAGE_NOT_PRESENT
    14291429                ||  rc == VERR_PAGE_TABLE_NOT_PRESENT)

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

    r18927 r18988  
    12831283VMMDECL(int) PGMPhysGCPtr2GCPhys(PVMCPU pVCpu, RTGCPTR GCPtr, PRTGCPHYS pGCPhys)
    12841284{
    1285     int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu->CTX_SUFF(pVM), pVCpu, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
     1285    int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, pGCPhys);
    12861286    if (pGCPhys && RT_SUCCESS(rc))
    12871287        *pGCPhys |= (RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK;
    … …  
    13041304    PVM pVM = pVCpu->CTX_SUFF(pVM);
    13051305    RTGCPHYS GCPhys;
    1306     int rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
     1306    int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    13071307    if (RT_SUCCESS(rc))
    13081308        rc = PGMPhysGCPhys2HCPhys(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), pHCPhys);
    … …  
    13281328    VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
    13291329    RTGCPHYS GCPhys;
    1330     int rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
     1330    int rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    13311331    if (RT_SUCCESS(rc))
    13321332        rc = PGMPhysGCPhys2R3Ptr(pVM, GCPhys | ((RTGCUINTPTR)GCPtr & PAGE_OFFSET_MASK), 1 /* we always stay within one page */, pR3Ptr);
    … …  
    23852385        memcpy(pvDst, pvSrc, cb);
    23862386        PGMPhysReleasePageMappingLock(pVM, &Lock);
    2387         rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
     2387        rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
    23882388        return VINF_SUCCESS;
    23892389    }
    … …  
    23922392    memcpy(pvDst, pvSrc, cbPage);
    23932393    PGMPhysReleasePageMappingLock(pVM, &Lock);
    2394     rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
     2394    rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
    23952395    GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + cbPage);
    23962396    pvSrc = (const uint8_t *)pvSrc + cbPage;
    … …  
    24122412            memcpy(pvDst, pvSrc, cb);
    24132413            PGMPhysReleasePageMappingLock(pVM, &Lock);
    2414             rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
     2414            rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
    24152415            return VINF_SUCCESS;
    24162416        }
    … …  
    24192419        memcpy(pvDst, pvSrc, PAGE_SIZE);
    24202420        PGMPhysReleasePageMappingLock(pVM, &Lock);
    2421         rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
     2421        rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D)); AssertRC(rc);
    24222422        GCPtrDst = (RTGCPTR)((RTGCUINTPTR)GCPtrDst + PAGE_SIZE);
    24232423        pvSrc = (const uint8_t *)pvSrc + PAGE_SIZE;
    … …  
    24622462    {
    24632463        /* Convert virtual to physical address + flags */
    2464         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
     2464        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
    24652465        AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
    24662466        GCPhys |= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
    … …  
    24692469        if (!(fFlags & X86_PTE_A))
    24702470        {
    2471             rc = PGMGstModifyPage(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
     2471            rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
    24722472            AssertRC(rc);
    24732473        }
    … …  
    24822482    {
    24832483        /* Convert virtual to physical address + flags */
    2484         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
     2484        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrSrc, &fFlags, &GCPhys);
    24852485        AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrSrc), rc);
    24862486        GCPhys |= (RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK;
    … …  
    24892489        if (!(fFlags & X86_PTE_A))
    24902490        {
    2491             rc = PGMGstModifyPage(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
     2491            rc = PGMGstModifyPage(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)(X86_PTE_A));
    24922492            AssertRC(rc);
    24932493        }
    … …  
    25432543    {
    25442544        /* Convert virtual to physical address + flags */
    2545         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
     2545        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
    25462546        AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
    25472547        GCPhys |= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
    … …  
    25542554        if ((fFlags & (X86_PTE_A | X86_PTE_D)) != (X86_PTE_A | X86_PTE_D))
    25552555        {
    2556             rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
     2556            rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
    25572557            AssertRC(rc);
    25582558        }
    … …  
    25672567    {
    25682568        /* Convert virtual to physical address + flags */
    2569         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
     2569        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, (RTGCUINTPTR)GCPtrDst, &fFlags, &GCPhys);
    25702570        AssertMsgRCReturn(rc, ("GetPage failed with %Rrc for %RGv\n", rc, GCPtrDst), rc);
    25712571        GCPhys |= (RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK;
    … …  
    25782578        if ((fFlags & (X86_PTE_A | X86_PTE_D)) != (X86_PTE_A | X86_PTE_D))
    25792579        {
    2580             rc = PGMGstModifyPage(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
     2580            rc = PGMGstModifyPage(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
    25812581            AssertRC(rc);
    25822582        }
    … …  
    26452645        RTGCPHYS GCPhys;
    26462646        uint64_t fFlags;
    2647         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc, &fFlags, &GCPhys);
     2647        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
    26482648        if (RT_SUCCESS(rc))
    26492649        {
    … …  
    26682668            if (!(fFlags & X86_PTE_A))
    26692669            {
    2670                 rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2670                rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    26712671                AssertRC(rc);
    26722672            }
    … …  
    26842684        uint64_t fFlags2;
    26852685        RTGCPHYS GCPhys2;
    2686         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
     2686        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
    26872687        if (RT_SUCCESS(rc))
    2688             rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
     2688            rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
    26892689        if (RT_SUCCESS(rc))
    26902690        {
    … …  
    27212721            if (!(fFlags1 & X86_PTE_A))
    27222722            {
    2723                 rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2723                rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    27242724                AssertRC(rc);
    27252725            }
    27262726            if (!(fFlags2 & X86_PTE_A))
    27272727            {
    2728                 rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2728                rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    27292729                AssertRC(rc);
    27302730            }
    … …  
    28112811        RTGCPHYS    GCPhys;
    28122812        uint64_t    fFlags;
    2813         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc, &fFlags, &GCPhys);
     2813        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags, &GCPhys);
    28142814        if (RT_SUCCESS(rc))
    28152815        {
    … …  
    28402840                {
    28412841                    /** @todo access bit emulation isn't 100% correct. */
    2842                     rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2842                    rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    28432843                    AssertRC(rc);
    28442844                }
    … …  
    28572857        uint64_t    fFlags2;
    28582858        RTGCPHYS    GCPhys2;
    2859         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
     2859        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc, &fFlags1, &GCPhys1);
    28602860        if (RT_SUCCESS(rc))
    28612861        {
    2862             rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
     2862            rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrSrc + cb1, &fFlags2, &GCPhys2);
    28632863            if (RT_SUCCESS(rc))
    28642864            {
    … …  
    29052905                    if (!(fFlags1 & X86_PTE_A))
    29062906                    {
    2907                         rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2907                        rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    29082908                        AssertRC(rc);
    29092909                    }
    29102910                    if (!(fFlags2 & X86_PTE_A))
    29112911                    {
    2912                         rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
     2912                        rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrSrc + cb1, 1, X86_PTE_A, ~(uint64_t)X86_PTE_A);
    29132913                        AssertRC(rc);
    29142914                    }
    … …  
    30023002        RTGCPHYS    GCPhys;
    30033003        uint64_t    fFlags;
    3004         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrDst, &fFlags, &GCPhys);
     3004        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags, &GCPhys);
    30053005        if (RT_SUCCESS(rc))
    30063006        {
    … …  
    30333033                {
    30343034                    /** @todo dirty & access bit emulation isn't 100% correct. */
    3035                     rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
     3035                    rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrDst, 1, X86_PTE_A | X86_PTE_D, ~(uint64_t)(X86_PTE_A | X86_PTE_D));
    30363036                    AssertRC(rc);
    30373037                }
    … …  
    30513051        uint64_t    fFlags2;
    30523052        RTGCPHYS    GCPhys2;
    3053         rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrDst, &fFlags1, &GCPhys1);
     3053        rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst, &fFlags1, &GCPhys1);
    30543054        if (RT_SUCCESS(rc))
    30553055        {
    3056             rc = PGM_GST_PFN(GetPage,pVCpu)(pVM, pVCpu, GCPtrDst + cb1, &fFlags2, &GCPhys2);
     3056            rc = PGM_GST_PFN(GetPage,pVCpu)(pVCpu, GCPtrDst + cb1, &fFlags2, &GCPhys2);
    30573057            if (RT_SUCCESS(rc))
    30583058            {
    … …  
    31023102                    if (!(fFlags1 & (X86_PTE_A | X86_PTE_RW)))
    31033103                    {
    3104                         rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrDst, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
     3104                        rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrDst, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
    31053105                        AssertRC(rc);
    31063106                    }
    31073107                    if (!(fFlags2 & (X86_PTE_A | X86_PTE_RW)))
    31083108                    {
    3109                         rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVM, pVCpu, GCPtrDst + cb1, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
     3109                        rc = PGM_GST_PFN(ModifyPage,pVCpu)(pVCpu, GCPtrDst + cb1, 1, (X86_PTE_A | X86_PTE_RW), ~(uint64_t)(X86_PTE_A | X86_PTE_RW));
    31103110                        AssertRC(rc);
    31113111                    }

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

    r18986 r18988  
    38243824
    38253825    /* Exit the current shadow paging mode as well; nested paging and EPT use a root CR3 which will get flushed here. */
    3826     rc = PGM_SHW_PFN(Exit, pVCpu)(pVM, pVCpu);
     3826    rc = PGM_SHW_PFN(Exit, pVCpu)(pVCpu);
    38273827    AssertRC(rc);
    38283828

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

    r18927 r18988  
    121121*******************************************************************************/
    122122__BEGIN_DECLS
    123 PGM_SHW_DECL(int, GetPage)(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys);
    124 PGM_SHW_DECL(int, ModifyPage)(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtr, size_t cbPages, uint64_t fFlags, uint64_t fMask);
     123PGM_SHW_DECL(int, GetPage)(PVMCPU pVCpu, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys);
     124PGM_SHW_DECL(int, ModifyPage)(PVMCPU pVCpu, RTGCUINTPTR GCPtr, size_t cbPages, uint64_t fFlags, uint64_t fMask);
    125125__END_DECLS
    126126
    … …  
    131131 *
    132132 * @returns VBox status.
    133  * @param   pVM         VM Handle.
    134133 * @param   pVCpu       The VMCPU handle.
    135134 * @param   GCPtr       Guest Context virtual address of the page.
    … …  
    139138 * @remark  You should use PGMMapGetPage() for pages in a mapping.
    140139 */
    141 PGM_SHW_DECL(int, GetPage)(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
     140PGM_SHW_DECL(int, GetPage)(PVMCPU pVCpu, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTHCPHYS pHCPhys)
    142141{
    143142#if PGM_SHW_TYPE == PGM_TYPE_NESTED
    … …  
    145144
    146145#else /* PGM_SHW_TYPE != PGM_TYPE_NESTED && PGM_SHW_TYPE != PGM_TYPE_EPT */
     146    PVM pVM = pVCpu->CTX_SUFF(pVM);
     147
    147148    /*
    148149     * Get the PDE.
    … …  
    269270 *
    270271 * @returns VBox status code.
    271  * @param   pVM         VM handle.
    272272 * @param   pVCpu       The VMCPU handle.
    273273 * @param   GCPtr       Virtual address of the first page in the range. Page aligned!
    … …  
    278278 * @remark  You must use PGMMapModifyPage() for pages in a mapping.
    279279 */
    280 PGM_SHW_DECL(int, ModifyPage)(PVM pVM, PVMCPU pVCpu, RTGCUINTPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
     280PGM_SHW_DECL(int, ModifyPage)(PVMCPU pVCpu, RTGCUINTPTR GCPtr, size_t cb, uint64_t fFlags, uint64_t fMask)
    281281{
    282282# if PGM_SHW_TYPE == PGM_TYPE_NESTED
    … …  
    284284
    285285# else /* PGM_SHW_TYPE != PGM_TYPE_NESTED && PGM_SHW_TYPE != PGM_TYPE_EPT */
     286    PVM pVM = pVCpu->CTX_SUFF(pVM);
    286287    int rc;
    287288
Note: See TracChangeset for help on using the changeset viewer.

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