VirtualBox

Changeset 31849 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Aug 22, 2010 4:15:03 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
65051
Message:

PGM: Don't shadow PDE bits 62/3:52 (NXE=1/0), only shadow the bits we need to (exception G, A and D).

Location:
trunk/src/VBox/VMM
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r31807 r31849  
    20982098         *        address width is relevant.  See table 5-9 in the intel
    20992099         *        manual vs the PDE4M descriptions.  Write testcase (NP). */
    2100         pVCpu->pgm.s.fGst32BitMbzBigPdeMask  = ((uint32_t)(fMbzPageFrameMask >> (32 - 13)) & X86_PDE4M_PG_HIGH_MASK)
    2101                                              | X86_PDE4M_MBZ_MASK;
    2102 
    2103         pVCpu->pgm.s.fGstPaeMbzPteMask       = fMbzPageFrameMask | X86_PTE_PAE_MBZ_MASK_NO_NX;
    2104         pVCpu->pgm.s.fGstPaeMbzPdeMask       = fMbzPageFrameMask | X86_PDE_PAE_MBZ_MASK_NO_NX;
    2105         pVCpu->pgm.s.fGstPaeMbzBigPdeMask    = fMbzPageFrameMask | X86_PDE2M_PAE_MBZ_MASK_NO_NX;
    2106         pVCpu->pgm.s.fGstPaeMbzPdpeMask      = fMbzPageFrameMask | X86_PDPE_PAE_MBZ_MASK;
    2107 
    2108         pVCpu->pgm.s.fGstAmd64MbzPteMask     = fMbzPageFrameMask | X86_PTE_LM_MBZ_MASK_NO_NX;
    2109         pVCpu->pgm.s.fGstAmd64MbzPdeMask     = fMbzPageFrameMask | X86_PDE_LM_MBZ_MASK_NX;
    2110         pVCpu->pgm.s.fGstAmd64MbzBigPdeMask  = fMbzPageFrameMask | X86_PDE2M_LM_MBZ_MASK_NX;
    2111         pVCpu->pgm.s.fGstAmd64MbzPdpeMask    = fMbzPageFrameMask | X86_PDPE_LM_MBZ_MASK_NO_NX;
    2112         pVCpu->pgm.s.fGstAmd64MbzBigPdpeMask = fMbzPageFrameMask | X86_PDPE1G_LM_MBZ_MASK_NO_NX;
    2113         pVCpu->pgm.s.fGstAmd64MbzPml4eMask   = fMbzPageFrameMask | X86_PML4E_MBZ_MASK_NO_NX;
     2100        pVCpu->pgm.s.fGst32BitMbzBigPdeMask   = ((uint32_t)(fMbzPageFrameMask >> (32 - 13)) & X86_PDE4M_PG_HIGH_MASK)
     2101                                              | X86_PDE4M_MBZ_MASK;
     2102
     2103        pVCpu->pgm.s.fGstPaeMbzPteMask        = fMbzPageFrameMask | X86_PTE_PAE_MBZ_MASK_NO_NX;
     2104        pVCpu->pgm.s.fGstPaeMbzPdeMask        = fMbzPageFrameMask | X86_PDE_PAE_MBZ_MASK_NO_NX;
     2105        pVCpu->pgm.s.fGstPaeMbzBigPdeMask     = fMbzPageFrameMask | X86_PDE2M_PAE_MBZ_MASK_NO_NX;
     2106        pVCpu->pgm.s.fGstPaeMbzPdpeMask       = fMbzPageFrameMask | X86_PDPE_PAE_MBZ_MASK;
     2107
     2108        pVCpu->pgm.s.fGstAmd64MbzPteMask      = fMbzPageFrameMask | X86_PTE_LM_MBZ_MASK_NO_NX;
     2109        pVCpu->pgm.s.fGstAmd64MbzPdeMask      = fMbzPageFrameMask | X86_PDE_LM_MBZ_MASK_NX;
     2110        pVCpu->pgm.s.fGstAmd64MbzBigPdeMask   = fMbzPageFrameMask | X86_PDE2M_LM_MBZ_MASK_NX;
     2111        pVCpu->pgm.s.fGstAmd64MbzPdpeMask     = fMbzPageFrameMask | X86_PDPE_LM_MBZ_MASK_NO_NX;
     2112        pVCpu->pgm.s.fGstAmd64MbzBigPdpeMask  = fMbzPageFrameMask | X86_PDPE1G_LM_MBZ_MASK_NO_NX;
     2113        pVCpu->pgm.s.fGstAmd64MbzPml4eMask    = fMbzPageFrameMask | X86_PML4E_MBZ_MASK_NO_NX;
     2114
     2115        pVCpu->pgm.s.fGst64ShadowedPteMask    = X86_PTE_P   | X86_PTE_RW   | X86_PTE_US   | X86_PTE_G | X86_PTE_A | X86_PTE_D;
     2116        pVCpu->pgm.s.fGst64ShadowedPdeMask    = X86_PDE_P   | X86_PDE_RW   | X86_PDE_US   | X86_PDE_A;
     2117        pVCpu->pgm.s.fGst64ShadowedBigPdeMask = X86_PDE4M_P | X86_PDE4M_RW | X86_PDE4M_US | X86_PDE4M_A;
     2118        pVCpu->pgm.s.fGst64ShadowedBigPde4PteMask =
     2119            X86_PDE4M_P | X86_PDE4M_RW | X86_PDE4M_US | X86_PDE4M_G | X86_PDE4M_A | X86_PDE4M_D;
    21142120    }
    21152121

  • trunk/src/VBox/VMM/PGMGstDefs.h

    r31775 r31849  
    3838#undef GST_PD_MASK
    3939#undef GST_PTE_PG_MASK
     40#undef GST_GET_PTE_SHW_FLAGS
    4041#undef GST_PT_SHIFT
    4142#undef GST_PT_MASK
    … …  
    4647#undef GST_PDPT_MASK
    4748#undef GST_PDPE_PG_MASK
    48 #undef GST_GET_PDE_BIG_PG_GCPHYS
     49#undef GST_GET_PDE_GCPHYS
     50#undef GST_GET_BIG_PDE_GCPHYS
     51#undef GST_GET_PDE_SHW_FLAGS
     52#undef GST_GET_BIG_PDE_SHW_FLAGS
     53#undef GST_GET_BIG_PDE_SHW_FLAGS_4_PTE
    4954#undef GST_IS_PTE_VALID
    5055#undef GST_IS_PDE_VALID
    … …  
    101106#  endif
    102107# endif
     108# define GST_GET_PTE_SHW_FLAGS(pVCpu, Pte)      (true && This_should_perhaps_not_be_used_in_this_context) //??
     109# define GST_GET_PDE_SHW_FLAGS(pVCpu, Pde)      (true && This_should_perhaps_not_be_used_in_this_context) //??
     110# define GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, Pde)  (true && This_should_perhaps_not_be_used_in_this_context) //??
     111# define GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, Pde) (true && This_should_perhaps_not_be_used_in_this_context) //??
    103112# define GST_IS_PTE_VALID(pVCpu, Pte)           (true)
    104113# define GST_IS_PDE_VALID(pVCpu, Pde)           (true)
    … …  
    125134# define GST_PDE_PG_MASK                        X86_PDE_PG_MASK
    126135# define GST_PDE_BIG_PG_MASK                    X86_PDE4M_PG_MASK
    127 # define GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeGst) pgmGstGet4MBPhysPage(&(pVM)->pgm.s, PdeGst)
     136# define GST_GET_PDE_GCPHYS(Pde)                ((Pde).u & GST_PDE_PG_MASK)
     137# define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       pgmGstGet4MBPhysPage(&(pVM)->pgm.s, Pde)
     138# define GST_GET_PDE_SHW_FLAGS(pVCpu, Pde)      ((Pde).u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US | X86_PDE_A))
     139# define GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, Pde) \
     140    ((Pde).u & (X86_PDE4M_P | X86_PDE4M_RW | X86_PDE4M_US | X86_PDE4M_A))
     141# define GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, Pde) \
     142    ((Pde).u & (X86_PDE4M_P | X86_PDE4M_RW | X86_PDE4M_US | X86_PDE4M_A | X86_PDE4M_D | X86_PDE4M_G))
    128143# define GST_PD_SHIFT                           X86_PD_SHIFT
    129144# define GST_PD_MASK                            X86_PD_MASK
    130145# define GST_TOTAL_PD_ENTRIES                   X86_PG_ENTRIES
    131146# define GST_PTE_PG_MASK                        X86_PTE_PG_MASK
     147# define GST_GET_PTE_SHW_FLAGS(pVCpu, Pte)      ((Pte).u & (X86_PTE_P | X86_PTE_RW | X86_PTE_US | X86_PTE_A | X86_PTE_D | X86_PTE_G))
    132148# define GST_PT_SHIFT                           X86_PT_SHIFT
    133149# define GST_PT_MASK                            X86_PT_MASK
    … …  
    157173# define GST_PDE_PG_MASK                        X86_PDE_PAE_PG_MASK_FULL
    158174# define GST_PDE_BIG_PG_MASK                    X86_PDE2M_PAE_PG_MASK
    159 # define GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeGst) ((PdeGst).u & GST_PDE_BIG_PG_MASK)
     175# define GST_GET_PDE_GCPHYS(Pde)                ((Pde).u & X86_PDE_PAE_PG_MASK_FULL)
     176# define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       ((Pde).u & GST_PDE_BIG_PG_MASK)
     177# define GST_GET_PTE_SHW_FLAGS(pVCpu, Pte)      ((Pte).u & (pVCpu)->pgm.s.fGst64ShadowedPteMask )
     178# define GST_GET_PDE_SHW_FLAGS(pVCpu, Pde)      ((Pde).u & (pVCpu)->pgm.s.fGst64ShadowedPdeMask )
     179# define GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, Pde)  ((Pde).u & (pVCpu)->pgm.s.fGst64ShadowedBigPdeMask )
     180# define GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, Pde)  ((Pde).u & (pVCpu)->pgm.s.fGst64ShadowedBigPde4PteMask )
     181
    160182# define GST_PD_SHIFT                           X86_PD_PAE_SHIFT
    161183# define GST_PD_MASK                            X86_PD_PAE_MASK

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

    r31834 r31849  
    35123512    /** @} */
    35133513
     3514    /** @name PAE and AMD64 Guest Paging.
     3515     * @{ */
     3516    /** Mask containing the PTE bits that we shadow. */
     3517    uint64_t                        fGst64ShadowedPteMask;
     3518    /** Mask containing the PDE bits that we shadow. */
     3519    uint64_t                        fGst64ShadowedPdeMask;
     3520    /** Mask containing the big page PDE bits that we shadow in the PDE. */
     3521    uint64_t                        fGst64ShadowedBigPdeMask;
     3522    /** Mask containing the big page PDE bits that we shadow in the PTE. */
     3523    uint64_t                        fGst64ShadowedBigPde4PteMask;
     3524    /** @}  */
     3525
    35143526    /** @name PAE Guest Paging.
    35153527     * @{ */

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

    r31780 r31849  
    22362236        pVCpu->pgm.s.fGstAmd64MbzBigPdpeMask &= ~X86_PDPE_LM_NX;
    22372237        pVCpu->pgm.s.fGstAmd64MbzPml4eMask   &= ~X86_PML4E_NX;
     2238
     2239        pVCpu->pgm.s.fGst64ShadowedPteMask        |= X86_PTE_PAE_NX;
     2240        pVCpu->pgm.s.fGst64ShadowedPdeMask        |= X86_PDE_PAE_NX;
     2241        pVCpu->pgm.s.fGst64ShadowedBigPdeMask     |= X86_PDE2M_PAE_NX;
     2242        pVCpu->pgm.s.fGst64ShadowedBigPde4PteMask |= X86_PDE2M_PAE_NX;
    22382243    }
    22392244    else
    … …  
    22432248        pVCpu->pgm.s.fGstPaeMbzPdeMask       |= X86_PDE_PAE_NX;
    22442249        pVCpu->pgm.s.fGstPaeMbzBigPdeMask    |= X86_PDE2M_PAE_NX;
    2245         /*pVCpu->pgm.s.fGstPaeMbzPdpeMask - N/A */
     2250        /*pVCpu->pgm.s.fGstPaeMbzPdpeMask -N/A */
    22462251        pVCpu->pgm.s.fGstAmd64MbzPteMask     |= X86_PTE_PAE_NX;
    22472252        pVCpu->pgm.s.fGstAmd64MbzPdeMask     |= X86_PDE_PAE_NX;
    … …  
    22502255        pVCpu->pgm.s.fGstAmd64MbzBigPdpeMask |= X86_PDPE_LM_NX;
    22512256        pVCpu->pgm.s.fGstAmd64MbzPml4eMask   |= X86_PML4E_NX;
     2257
     2258        pVCpu->pgm.s.fGst64ShadowedPteMask        &= ~X86_PTE_PAE_NX;
     2259        pVCpu->pgm.s.fGst64ShadowedPdeMask        &= ~X86_PDE_PAE_NX;
     2260        pVCpu->pgm.s.fGst64ShadowedBigPdeMask     &= ~X86_PDE2M_PAE_NX;
     2261        pVCpu->pgm.s.fGst64ShadowedBigPde4PteMask &= ~X86_PDE2M_PAE_NX;
    22522262    }
    22532263}

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

    r31835 r31849  
    12701270             */
    12711271            PPGMPOOLPAGE    pShwPage = pgmPoolGetPage(pPool, PdeDst.u & SHW_PDE_PG_MASK);
    1272             RTGCPHYS        GCPhys   = PdeSrc.u & GST_PDE_PG_MASK;
     1272            RTGCPHYS        GCPhys   = GST_GET_PDE_GCPHYS(PdeSrc);
    12731273
    12741274# ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
    … …  
    13211321            /* Before freeing the page, check if anything really changed. */
    13221322            PPGMPOOLPAGE    pShwPage = pgmPoolGetPage(pPool, PdeDst.u & SHW_PDE_PG_MASK);
    1323             RTGCPHYS        GCPhys   = GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeSrc);
     1323            RTGCPHYS        GCPhys   = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    13241324# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    13251325            /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    … …  
    13301330            {
    13311331                /* ASSUMES a the given bits are identical for 4M and normal PDEs */
    1332                 /** @todo PAT */
    1333                 if (        (PdeSrc.u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US | X86_PDE_PWT | X86_PDE_PCD))
    1334                         ==  (PdeDst.u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US | X86_PDE_PWT | X86_PDE_PCD))
     1332                /** @todo This test is wrong as it cannot check the G bit!
     1333                 *        FIXME */
     1334                if (        (PdeSrc.u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US))
     1335                        ==  (PdeDst.u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US))
    13351336                    &&  (   PdeSrc.b.u1Dirty /** @todo rainy day: What about read-only 4M pages? not very common, but still... */
    13361337                         || (PdeDst.u & PGM_PDFLAGS_TRACK_DIRTY)))
    … …  
    18321833    if (!fBigPage)
    18331834    {
    1834         GCPhys = PdeSrc.u & GST_PDE_PG_MASK;
     1835        GCPhys = GST_GET_PDE_GCPHYS(PdeSrc);
    18351836# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    18361837        /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    … …  
    18401841    else
    18411842    {
    1842         GCPhys = GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeSrc);
     1843        GCPhys = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    18431844# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    18441845        /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    … …  
    18461847# endif
    18471848    }
     1849    /** @todo This doesn't check the G bit of 2/4MB pages. FIXME */
    18481850    if (    fPdeValid
    18491851        &&  pShwPage->GCPhys == GCPhys
    … …  
    18701872                 */
    18711873                PGSTPT pPTSrc;
    1872                 int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
     1874                int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, GST_GET_PDE_GCPHYS(PdeSrc), &pPTSrc);
    18731875                if (RT_SUCCESS(rc))
    18741876                {
    … …  
    19591961                 */
    19601962                /* Calculate the GC physical address of this 4KB shadow page. */
    1961                 GCPhys = GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeSrc) | (GCPtrPage & GST_BIG_PAGE_OFFSET_MASK);
     1963                GCPhys = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc) | (GCPtrPage & GST_BIG_PAGE_OFFSET_MASK);
    19621964                /* Find ram range. */
    19631965                PPGMPAGE pPage;
    … …  
    19931995                    SHWPTE PteDst;
    19941996                    if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage))
    1995                         PGM_BTH_NAME(SyncHandlerPte)(pVM, pPage,
    1996                                                      PdeSrc.u & ~(  X86_PTE_PAE_PG_MASK | X86_PTE_AVL_MASK
    1997                                                                   | X86_PTE_PAT | X86_PTE_PCD | X86_PTE_PWT),
    1998                                                      &PteDst);
     1997                        PGM_BTH_NAME(SyncHandlerPte)(pVM, pPage, GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, PdeSrc), &PteDst);
    19991998                    else
    2000                         SHW_PTE_SET(PteDst,
    2001                                       (PdeSrc.u & ~(X86_PTE_PAE_PG_MASK | X86_PTE_AVL_MASK | X86_PTE_PAT | X86_PTE_PCD | X86_PTE_PWT))
    2002                                     | PGM_PAGE_GET_HCPHYS(pPage));
     1999                        SHW_PTE_SET(PteDst, GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, PdeSrc) | PGM_PAGE_GET_HCPHYS(pPage));
    20032000
    20042001                    const unsigned iPTDst = (GCPtrPage >> SHW_PT_SHIFT) & SHW_PT_MASK;
    … …  
    20502047                {
    20512048                    LogFlow(("PGM_GCPHYS_2_PTR %RGp (big) failed with %Rrc\n", GCPhys, rc));
    2052                     /** @todo must wipe the shadow page table in this case. */
     2049                    /** @todo must wipe the shadow page table entry in this
     2050                     *        case. */
    20532051                }
    20542052            }
    … …  
    20672065    else
    20682066    {
    2069 /// @todo        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncPagePDOutOfSync));
     2067/// @todo        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncPagePDOutOfSyncAndInvalid));
    20702068        Log2(("SyncPage: Bad PDE at %RGp PdeSrc=%RX64 PdeDst=%RX64 (GCPhys %RGp vs %RGp)\n",
    20712069              GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u, pShwPage->GCPhys, GCPhys));
    … …  
    23672365     */
    23682366    PGSTPT pPTSrc;
    2369     int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, pPdeSrc->u & GST_PDE_PG_MASK, &pPTSrc);
     2367    int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, GST_GET_PDE_GCPHYS(*pPdeSrc), &pPTSrc);
    23702368    if (RT_FAILURE(rc))
    23712369    {
    … …  
    24762474 * Sync a shadow page table.
    24772475 *
    2478  * The shadow page table is not present. This includes the case where
    2479  * there is a conflict with a mapping.
     2476 * The shadow page table is not present in the shadow PDE.
     2477 *
     2478 * Handles mapping conflicts.
     2479 *
     2480 * This is called by VerifyAccessSyncPage, PrefetchPage, InvalidatePage (on
     2481 * conflict), and Trap0eHandler.
     2482 *
     2483 * A precodition for this method is that the shadow PDE is not present.  The
     2484 * caller must take the PGM lock before checking this and continue to hold it
     2485 * when calling this method.
    24802486 *
    24812487 * @returns VBox status code.
    … …  
    25082514
    25092515    /*
    2510      * Validate input a little bit.
     2516     * Some input validation first.
    25112517     */
    25122518    AssertMsg(iPDSrc == ((GCPtrPage >> GST_PD_SHIFT) & GST_PD_MASK), ("iPDSrc=%x GCPtrPage=%RGv\n", iPDSrc, GCPtrPage));
     2519
     2520    /*
     2521     * Get the relevant shadow PDE entry.
     2522     */
    25132523# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    25142524    const unsigned  iPDDst   = GCPtrPage >> SHW_PD_SHIFT;
    … …  
    25872597
    25882598    /*
    2589      * Sync page directory entry.
    2590      */
    2591     GSTPDE  PdeSrc = pPDSrc->a[iPDSrc];
    2592     if (PdeSrc.n.u1Present)
     2599     * Sync the page directory entry.
     2600     */
     2601    GSTPDE      PdeSrc = pPDSrc->a[iPDSrc];
     2602    const bool  fPageTable = !PdeSrc.b.u1Size || !GST_IS_PSE_ACTIVE(pVCpu);
     2603    if (   PdeSrc.n.u1Present
     2604        && (fPageTable ? GST_IS_PDE_VALID(pVCpu, PdeSrc) : GST_IS_BIG_PDE_VALID(pVCpu, PdeSrc)) )
    25932605    {
    25942606        /*
    … …  
    25962608         */
    25972609        PSHWPT          pPTDst;
    2598         const bool      fPageTable = !PdeSrc.b.u1Size || !GST_IS_PSE_ACTIVE(pVCpu);
    25992610        PPGMPOOLPAGE    pShwPage;
    26002611        RTGCPHYS        GCPhys;
    26012612        if (fPageTable)
    26022613        {
    2603             GCPhys = PdeSrc.u & GST_PDE_PG_MASK;
     2614            GCPhys = GST_GET_PDE_GCPHYS(PdeSrc);
    26042615# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    26052616            /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    … …  
    26122623            PGMPOOLACCESS enmAccess;
    26132624# if PGM_WITH_NX(PGM_GST_TYPE, PGM_SHW_TYPE)
    2614             const bool fNoExecute = PdeSrc.n.u1NoExecute && GST_IS_NX_ACTIVE(pVCpu);
     2625            const bool  fNoExecute = PdeSrc.n.u1NoExecute && GST_IS_NX_ACTIVE(pVCpu);
    26152626# else
    2616             const bool fNoExecute = false;
    2617 # endif
    2618 
    2619             GCPhys = GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeSrc);
     2627            const bool  fNoExecute = false;
     2628# endif
     2629
     2630            GCPhys = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    26202631# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    26212632            /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    … …  
    26472658             */
    26482659            if (fPageTable)
    2649                 PdeDst.u = pShwPage->Core.Key
    2650                          | (PdeSrc.u & ~(GST_PDE_PG_MASK | X86_PDE_AVL_MASK | X86_PDE_PCD | X86_PDE_PWT | X86_PDE_PS | X86_PDE4M_G | X86_PDE4M_D));
     2660                PdeDst.u = pShwPage->Core.Key | GST_GET_PDE_SHW_FLAGS(pVCpu, PdeSrc);
    26512661            else
    26522662            {
    2653                 PdeDst.u = pShwPage->Core.Key
    2654                          | (PdeSrc.u & ~(GST_PDE_PG_MASK | X86_PDE_AVL_MASK | X86_PDE_PCD | X86_PDE_PWT | X86_PDE_PS | X86_PDE4M_G | X86_PDE4M_D));
     2663                PdeDst.u = pShwPage->Core.Key | GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, PdeSrc);
    26552664                /* (see explanation and assumptions further down.) */
    26562665                if (    !PdeSrc.b.u1Dirty
    … …  
    26742683        else
    26752684            AssertMsgFailedReturn(("rc=%Rrc\n", rc), VERR_INTERNAL_ERROR);
     2685        /** @todo Why do we bother preserving X86_PDE_AVL_MASK here?
     2686         * Both PGM_PDFLAGS_MAPPING and PGM_PDFLAGS_TRACK_DIRTY should be
     2687         * irrelevant at this point. */
    26762688        PdeDst.u &= X86_PDE_AVL_MASK;
    26772689        PdeDst.u |= pShwPage->Core.Key;
    … …  
    26802692         * Page directory has been accessed (this is a fault situation, remember).
    26812693         */
     2694        /** @todo
     2695         * Well, when the caller is PrefetchPage or InvalidatePage is isn't a
     2696         * fault situation.  What's more, the Trap0eHandler has already set the
     2697         * accessed bit.  So, it's actually just VerifyAccessSyncPage which
     2698         * might need setting the accessed flag.
     2699         *
     2700         * The best idea is to leave this change to the caller and add an
     2701         * assertion that it's set already. */
    26822702        pPDSrc->a[iPDSrc].n.u1Accessed = 1;
    26832703        if (fPageTable)
    … …  
    26912711                  GCPtrPage, PdeSrc.b.u1Present, PdeSrc.b.u1Write, PdeSrc.b.u1User, (uint64_t)PdeSrc.u));
    26922712            PGSTPT pPTSrc;
    2693             rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
     2713            rc = PGM_GCPHYS_2_PTR(pVM, GST_GET_PDE_GCPHYS(PdeSrc), &pPTSrc);
    26942714            if (RT_SUCCESS(rc))
    26952715            {
    … …  
    26982718                 */
    26992719                PdeDst.u = (PdeDst.u & (SHW_PDE_PG_MASK | X86_PDE_AVL_MASK))
    2700                          | (PdeSrc.u & ~(GST_PDE_PG_MASK | X86_PDE_AVL_MASK | X86_PDE_PCD | X86_PDE_PWT | X86_PDE_PS | X86_PDE4M_G | X86_PDE4M_D));
     2720                         | GST_GET_PDE_SHW_FLAGS(pVCpu, PdeSrc);
    27012721                ASMAtomicWriteSize(pPdeDst, PdeDst.u);
    27022722                PGM_DYNMAP_UNUSED_HINT(pVCpu, pPdeDst);
    … …  
    27622782                              (uint64_t)PteSrc.u,
    27632783                              SHW_PTE_IS_TRACK_DIRTY(pPTDst->a[iPTDst]) ? " Track-Dirty" : "", SHW_PTE_LOG64(pPTDst->a[iPTDst]), iPTSrc, PdeSrc.au32[0],
    2764                               (RTGCPHYS)((PdeSrc.u & GST_PDE_PG_MASK) + iPTSrc*sizeof(PteSrc)) ));
     2784                              (RTGCPHYS)(GST_GET_PDE_GCPHYS(PdeSrc) + iPTSrc*sizeof(PteSrc)) ));
    27652785                    }
    27662786                    /* else: the page table was cleared by the pool */
    … …  
    27872807             */
    27882808            PdeDst.u = (PdeDst.u & (SHW_PDE_PG_MASK | (X86_PDE_AVL_MASK & ~PGM_PDFLAGS_TRACK_DIRTY)))
    2789                      | (PdeSrc.u & ~(GST_PDE_PG_MASK | X86_PDE_AVL_MASK | X86_PDE_PCD | X86_PDE_PWT | X86_PDE_PS | X86_PDE4M_G | X86_PDE4M_D));
     2809                     | GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, PdeSrc);
    27902810
    27912811            /*
    … …  
    28132833             */
    28142834            /* Get address and flags from the source PDE. */
    2815             Assert(GST_IS_BIG_PDE_VALID(pVCpu, PdeSrc));
    28162835            SHWPTE PteDstBase;
    2817             SHW_PTE_SET(PteDstBase, PdeSrc.u & ~(GST_PDE_PG_MASK | X86_PTE_AVL_MASK | X86_PTE_PAT | X86_PTE_PCD | X86_PTE_PWT));
     2836            SHW_PTE_SET(PteDstBase, GST_GET_BIG_PDE_SHW_FLAGS_4_PTE(pVCpu, PdeSrc));
    28182837
    28192838            /* Loop thru the entries in the shadow PT. */
    … …  
    38483867                        ||  !fBigPagesSupported)
    38493868                    {
    3850                         GCPhysGst = PdeSrc.u & GST_PDE_PG_MASK;
     3869                        GCPhysGst = GST_GET_PDE_GCPHYS(PdeSrc);
    38513870# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    38523871                        GCPhysGst |= (iPDDst & 1) * (PAGE_SIZE / 2);
    … …  
    38643883                        }
    38653884# endif
    3866                         GCPhysGst = GST_GET_PDE_BIG_PG_GCPHYS(pVM, PdeSrc);
     3885                        GCPhysGst = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    38673886# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    38683887                        GCPhysGst |= GCPtr & RT_BIT(X86_PAGE_2M_SHIFT);
    … …  
    39513970# ifdef IN_RING3
    39523971                                PGMAssertHandlerAndFlagsInSync(pVM);
    3953                                 PGMR3DumpHierarchyGC(pVM, cr3, cr4, (PdeSrc.u & GST_PDE_PG_MASK));
     3972                                PGMR3DumpHierarchyGC(pVM, cr3, cr4, GST_GET_PDE_GCPHYS(PdeSrc));
    39543973# endif
    39553974                                AssertMsgFailed(("Out of sync (!P) PTE at %RGv! PteSrc=%#RX64 PteDst=%#RX64 pPTSrc=%RGv iPTSrc=%x PdeSrc=%x physpte=%RGp\n",
    39563975                                                GCPtr + off, (uint64_t)PteSrc.u, SHW_PTE_LOG64(PteDst), pPTSrc, iPT + offPTSrc, PdeSrc.au32[0],
    3957                                                 (PdeSrc.u & GST_PDE_PG_MASK) + (iPT + offPTSrc)*sizeof(PteSrc)));
     3976                                                (uint64_t)GST_GET_PDE_GCPHYS(PdeSrc) + (iPT + offPTSrc)*sizeof(PteSrc)));
    39583977                                cErrors++;
    39593978                                continue;

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

    r31528 r31849  
    164164                return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 2);
    165165
    166             pWalk->Core.GCPhys       = GST_GET_PDE_BIG_PG_GCPHYS(pVCpu->CTX_SUFF(pVM), Pde)
     166            pWalk->Core.GCPhys       = GST_GET_BIG_PDE_GCPHYS(pVCpu->CTX_SUFF(pVM), Pde)
    167167                                     | (GCPtr & GST_BIG_PAGE_OFFSET_MASK);
    168168            uint8_t fEffectiveXX     = (uint8_t)pWalk->Pde.u
    … …  
    195195         * The PTE.
    196196         */
    197         rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pde.u & GST_PDE_PG_MASK, &pWalk->pPt);
     197        rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, GST_GET_PDE_GCPHYS(Pde), &pWalk->pPt);
    198198        if (RT_FAILURE(rc))
    199199            return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 1, rc);
    … …  
    214214         * We're done.
    215215         */
    216         pWalk->Core.GCPhys       = (Pte.u & GST_PDE_PG_MASK)
     216        pWalk->Core.GCPhys       = GST_GET_PDE_GCPHYS(Pte)
    217217                                 | (GCPtr & PAGE_OFFSET_MASK);
    218218        uint8_t fEffectiveXX     = (uint8_t)pWalk->Pte.u
    … …  
    368368        {
    369369            /*
    370              * 4MB Page table
     370             * 2/4MB Page table
    371371             */
    372372            GSTPDE PdeNew;
    … …  
    501501                 */
    502502                PGSTPT pPT;
    503                 int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, Pde.u & GST_PDE_PG_MASK, &pPT);
     503                int rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, GST_GET_PDE_GCPHYS(Pde), &pPT);
    504504                if (RT_SUCCESS(rc))
    505505                {
    … …  
    558558                 * 2/4MB page.
    559559                 */
    560                 RTGCPHYS GCPhys = (RTGCPHYS)(Pde.u & GST_PDE_PG_MASK);
     560                RTGCPHYS GCPhys = (RTGCPHYS)GST_GET_PDE_GCPHYS(Pde);
    561561                for (unsigned i4KB = (GCPtr >> GST_PT_SHIFT) & GST_PT_MASK;
    562562                     i4KB < PAGE_SIZE / sizeof(GSTPDE) && iPage < pCur->cPages;

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

    r31836 r31849  
    16521652        return false;
    16531653
    1654     GCPhys = GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1);
     1654    GCPhys = GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    16551655
    16561656    for (unsigned i = 0; i < RT_ELEMENTS(pPool->aIdxDirtyPages); i++)
    … …  
    17231723        return;
    17241724
    1725     GCPhysPT = GCPhysPT & ~(RTGCPHYS)(PAGE_SIZE - 1);
     1725    GCPhysPT = GCPhysPT & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    17261726
    17271727    for (unsigned i = 0; i < RT_ELEMENTS(pPool->aIdxDirtyPages); i++)
    … …  
    21552155     * Look up the GCPhys in the hash.
    21562156     */
    2157     RTGCPHYS GCPhys = pNewPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1);
     2157    RTGCPHYS GCPhys = pNewPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    21582158    unsigned i = pPool->aiHash[PGMPOOL_HASH(GCPhys)];
    21592159    if (i == NIL_PGMPOOL_IDX)
    … …  
    22292229static int pgmPoolMonitorInsert(PPGMPOOL pPool, PPGMPOOLPAGE pPage)
    22302230{
    2231     LogFlow(("pgmPoolMonitorInsert %RGp\n", pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1)));
     2231    LogFlow(("pgmPoolMonitorInsert %RGp\n", pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK));
    22322232
    22332233    /*
    … …  
    23012301        Assert(pPage->iMonitoredNext == NIL_PGMPOOL_IDX); Assert(pPage->iMonitoredPrev == NIL_PGMPOOL_IDX);
    23022302        PVM pVM = pPool->CTX_SUFF(pVM);
    2303         const RTGCPHYS GCPhysPage = pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1);
     2303        const RTGCPHYS GCPhysPage = pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    23042304        rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
    2305                                           GCPhysPage, GCPhysPage + (PAGE_SIZE - 1),
     2305                                          GCPhysPage, GCPhysPage + PAGE_OFFSET_MASK,
    23062306                                          pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pPage),
    23072307                                          pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pPage),
    … …  
    23842384            PPGMPOOLPAGE pNewHead = &pPool->aPages[pPage->iMonitoredNext];
    23852385            pNewHead->iMonitoredPrev = NIL_PGMPOOL_IDX;
    2386             rc = PGMHandlerPhysicalChangeCallbacks(pVM, pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1),
     2386            rc = PGMHandlerPhysicalChangeCallbacks(pVM, pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK,
    23872387                                                   pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pNewHead),
    23882388                                                   pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pNewHead),
    … …  
    24062406    else
    24072407    {
    2408         rc = PGMHandlerPhysicalDeregister(pVM, pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1));
     2408        rc = PGMHandlerPhysicalDeregister(pVM, pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK);
    24092409        AssertFatalRC(rc);
    24102410        PVMCPU pVCpu = VMMGetCpu(pVM);
    … …  
    30483048                    case PGM_PAGE_HNDL_PHYS_STATE_WRITE:        /* Write access is monitored. */
    30493049                        u64OrMask = 0;
    3050                         u64AndMask = ~((uint64_t)X86_PTE_RW);
     3050                        u64AndMask = ~(uint64_t)X86_PTE_RW;
    30513051                        fRet = true;
    30523052                        STAM_COUNTER_INC(&pPool->StatTrackFlushEntryKeep);
    … …  
    49304930     * Look up the GCPhys in the hash.
    49314931     */
    4932     GCPhys = GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1);
     4932    GCPhys = GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    49334933    unsigned i = pPool->aiHash[PGMPOOL_HASH(GCPhys)];
    49344934    if (i == NIL_PGMPOOL_IDX)
    … …  
    51685168        if (pPage->fMonitored)
    51695169        {
    5170             int rc = PGMHandlerPhysicalChangeCallbacks(pVM, pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1),
     5170            int rc = PGMHandlerPhysicalChangeCallbacks(pVM, pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK,
    51715171                                                       pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pPage),
    51725172                                                       pPool->pfnAccessHandlerR0, MMHyperCCToR0(pVM, pPage),
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