VirtualBox

Changeset 32009 in vbox


Ignore:
Timestamp:
Aug 26, 2010 4:41:19 PM (14 years ago)
Author:
vboxsync
Message:

Removed GST_PDPE_PG_MASK and renamed GST_PDPE_PG_MASK_FULL to GST_PDPE_PG_MASK.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/hwacc_vmx.h

    r32000 r32009  
    140140
    141141/** Bits 12-51 - - EPT - Physical Page number of the next level. */
    142 #define EPT_PDPTE_PG_MASK       X86_PDPE_PG_MASK_FULL
     142#define EPT_PDPTE_PG_MASK       X86_PDPE_PG_MASK
    143143/** The page shift to get the PDPT index. */
    144144#define EPT_PDPT_SHIFT          X86_PDPT_SHIFT

  • trunk/include/VBox/x86.h

    r32000 r32009  
    16581658#define X86_PDPE_AVL_MASK                   (RT_BIT(9) | RT_BIT(10) | RT_BIT(11))
    16591659/** Bits 12-51 - - PAE - Physical Page number of the next level. */
    1660 #if 1 /* we're using this internally and have to mask of the top 16-bit. */
    1661 #define X86_PDPE_PG_MASK                    UINT64_C(0x0000fffffffff000)
    1662 /** @todo Get rid of the above hack; makes code unreadable. */
    1663 #define X86_PDPE_PG_MASK_FULL               UINT64_C(0x000ffffffffff000)
    1664 #else
    16651660#define X86_PDPE_PG_MASK                    UINT64_C(0x000ffffffffff000)
    1666 #endif
    16671661/** Bits 63-52, 8-5, 2-1 - - PAE - MBZ bits (NX is long mode only). */
    16681662#define X86_PDPE_PAE_MBZ_MASK               UINT64_C(0xfff00000000001e6)

  • trunk/include/VBox/x86.mac

    r32000 r32009  
    426426%define X86_PDPE_LM_PS                      RT_BIT(7)
    427427%define X86_PDPE_AVL_MASK                   (RT_BIT(9) | RT_BIT(10) | RT_BIT(11))
    428 %if 1
    429 %define X86_PDPE_PG_MASK                    0x0000fffffffff000
    430 %define X86_PDPE_PG_MASK_FULL               0x000ffffffffff000
    431 %else
    432428%define X86_PDPE_PG_MASK                    0x000ffffffffff000
    433 %endif
    434429%define X86_PDPE_PAE_MBZ_MASK               0xfff00000000001e6
    435430%define X86_PDPE_LM_NX                      RT_BIT_64(63)

  • trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp

    r32000 r32009  
    27472747            iEntry = (VarGCPtr.u.GCFlat >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
    27482748            VarPDEAddr = VarCur;
    2749             VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK_FULL;
     2749            VarPDEAddr.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
    27502750            VarPDEAddr.u.u64Number += iEntry * sizeof(X86PDEPAE);
    27512751        }
    … …  
    31163116                return DBGCCmdHlpPrintf(pCmdHlp, "Page directory is not present for %Dv.\n", &VarGCPtr);
    31173117
    3118             VarCur.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK_FULL;
     3118            VarCur.u.u64Number = Pdpe.u & X86_PDPE_PG_MASK;
    31193119
    31203120            /* Page directory (PAE). */

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

    r32000 r32009  
    12751275                                        Pdpe.u & PGM_PLXFLAGS_PERMANENT   ? 'p' : '-',
    12761276                                        Pdpe.u & RT_BIT(11)               ? '1' : '0',
    1277                                         Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1277                                        Pdpe.u & X86_PDPE_PG_MASK);
    12781278                if (pState->fDumpPageInfo)
    1279                     pgmR3DumpHierarchyShwTablePageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1279                    pgmR3DumpHierarchyShwTablePageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK);
    12801280                if ((Pdpe.u >> 52) & 0x7ff)
    12811281                    pState->pHlp->pfnPrintf(pState->pHlp, " 62:52=%03llx", (Pdpe.u >> 52) & 0x7ff);
    … …  
    12981298                                        Pdpe.u & PGM_PLXFLAGS_PERMANENT   ? 'p' : '-',
    12991299                                        Pdpe.u & RT_BIT(11)               ? '1' : '0',
    1300                                         Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1300                                        Pdpe.u & X86_PDPE_PG_MASK);
    13011301                if (pState->fDumpPageInfo)
    1302                     pgmR3DumpHierarchyShwTablePageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1302                    pgmR3DumpHierarchyShwTablePageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK);
    13031303                if ((Pdpe.u >> 52) & 0xfff)
    13041304                    pState->pHlp->pfnPrintf(pState->pHlp, " 63:52=%03llx!", (Pdpe.u >> 52) & 0xfff);
    … …  
    13081308            if (cMaxDepth)
    13091309            {
    1310                 int rc2 = pgmR3DumpHierarchyShwPaePD(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL, cMaxDepth);
     1310                int rc2 = pgmR3DumpHierarchyShwPaePD(pState, Pdpe.u & X86_PDPE_PG_MASK, cMaxDepth);
    13111311                if (rc2 < rc && RT_SUCCESS(rc))
    13121312                    rc = rc2;
    … …  
    19471947                                        Pdpe.u & RT_BIT_64(10) ? '1' : '0',
    19481948                                        Pdpe.u & RT_BIT_64(11) ? '1' : '0',
    1949                                         Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1949                                        Pdpe.u & X86_PDPE_PG_MASK);
    19501950                if (pState->fDumpPageInfo)
    1951                     pgmR3DumpHierarchyGstPageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL, _4K);
     1951                    pgmR3DumpHierarchyGstPageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK, _4K);
    19521952                pgmR3DumpHierarchyGstCheckReservedHighBits(pState, Pdpe.u);
    19531953            }
    … …  
    19691969                                        Pdpe.u & RT_BIT_64(10) ? '1' : '0',
    19701970                                        Pdpe.u & RT_BIT_64(11) ? '1' : '0',
    1971                                         Pdpe.u & X86_PDPE_PG_MASK_FULL);
     1971                                        Pdpe.u & X86_PDPE_PG_MASK);
    19721972                if (pState->fDumpPageInfo)
    1973                     pgmR3DumpHierarchyGstPageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL, _4K);
     1973                    pgmR3DumpHierarchyGstPageInfo(pState, Pdpe.u & X86_PDPE_PG_MASK, _4K);
    19741974                pgmR3DumpHierarchyGstCheckReservedHighBits(pState, Pdpe.u);
    19751975            }
    … …  
    19781978            if (cMaxDepth)
    19791979            {
    1980                 int rc2 = pgmR3DumpHierarchyGstPaePD(pState, Pdpe.u & X86_PDPE_PG_MASK_FULL, cMaxDepth);
     1980                int rc2 = pgmR3DumpHierarchyGstPaePD(pState, Pdpe.u & X86_PDPE_PG_MASK, cMaxDepth);
    19811981                if (rc2 < rc && RT_SUCCESS(rc))
    19821982                    rc = rc2;

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

    r31996 r32009  
    194194#  define GST_TOTAL_PD_ENTRIES                  (X86_PG_PAE_ENTRIES * X86_PG_PAE_PDPE_ENTRIES)
    195195#  define GST_PDPE_ENTRIES                      X86_PG_PAE_PDPE_ENTRIES
    196 #  define GST_PDPE_PG_MASK                      X86_PDPE_PG_MASK_FULL
     196#  define GST_PDPE_PG_MASK                      X86_PDPE_PG_MASK
    197197#  define GST_PDPT_SHIFT                        X86_PDPT_SHIFT
    198198#  define GST_PDPT_MASK                         X86_PDPT_MASK_PAE
    … …  
    212212#  define GST_PDPE_ENTRIES                      X86_PG_AMD64_PDPE_ENTRIES
    213213#  define GST_PDPT_SHIFT                        X86_PDPT_SHIFT
    214 #  define GST_PDPE_PG_MASK                      X86_PDPE_PG_MASK_FULL
     214#  define GST_PDPE_PG_MASK                      X86_PDPE_PG_MASK
    215215#  define GST_PDPT_MASK                         X86_PDPT_MASK_AMD64
    216216#  define GST_PTE_PG_MASK                       X86_PTE_PAE_PG_MASK_FULL

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

    r32005 r32009  
    762762            PX86PDPAE   pGuestPD = NULL;
    763763            int rc = pgmRZDynMapGCPageInlined(pVCpu,
    764                                               pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK_FULL,
     764                                              pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK,
    765765                                              (void **)&pGuestPD
    766766                                              RTLOG_COMMA_SRC_POS);
    … …  
    771771            PX86PDPAE   pGuestPD = pVCpu->pgm.s.CTX_SUFF(apGstPaePDs)[iPdpt];
    772772            if (    !pGuestPD
    773                 ||  (pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK_FULL) != pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt])
     773                ||  (pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK) != pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt])
    774774                pgmGstLazyMapPaePD(pVCpu, iPdpt, &pGuestPD);
    775775            if (pGuestPD)
    … …  
    815815    PX86PDPAE   pGuestPD = NULL;
    816816    int rc = pgmRZDynMapGCPageInlined(pVCpu,
    817                                       pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK_FULL,
     817                                      pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK,
    818818                                      (void **)&pGuestPD
    819819                                      RTLOG_COMMA_SRC_POS);
    … …  
    826826    PX86PDPAE   pGuestPD = pVCpu->pgm.s.CTX_SUFF(apGstPaePDs)[iPdpt];
    827827    if (    !pGuestPD
    828         ||  (pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK_FULL) != pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt])
     828        ||  (pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK) != pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt])
    829829        pgmGstLazyMapPaePD(pVCpu, iPdpt, &pGuestPD);
    830830#endif
    … …  
    932932            {
    933933                PCX86PDPAE pPD;
    934                 rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, pPdptTemp->a[iPdpt].u & X86_PDPE_PG_MASK_FULL, &pPD);
     934                rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, pPdptTemp->a[iPdpt].u & X86_PDPE_PG_MASK, &pPD);
    935935                if (RT_SUCCESS(rc))
    936936                {
    … …  
    989989    /* The PDE. */
    990990    PX86PDPAE pPD;
    991     rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, pPdptTemp->a[iPdpt].u & X86_PDPE_PG_MASK_FULL, &pPD);
     991    rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, pPdptTemp->a[iPdpt].u & X86_PDPE_PG_MASK, &pPD);
    992992    if (RT_FAILURE(rc))
    993993    {
    … …  
    10821082    /* Fetch the pgm pool shadow descriptor. */
    10831083    PVM pVM = pVCpu->CTX_SUFF(pVM);
    1084     PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     1084    PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    10851085    AssertReturn(pShwPde, NULL);
    10861086
    … …  
    11051105    /* Fetch the pgm pool shadow descriptor. */
    11061106    PVM             pVM     = pVCpu->CTX_SUFF(pVM);
    1107     PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     1107    PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    11081108    AssertReturn(pShwPde, NULL);
    11091109

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

    r32005 r32009  
    9797#  define SHW_PDPT_SHIFT        X86_PDPT_SHIFT
    9898#  define SHW_PDPT_MASK         X86_PDPT_MASK_AMD64
    99 #  define SHW_PDPE_PG_MASK      X86_PDPE_PG_MASK_FULL
     99#  define SHW_PDPE_PG_MASK      X86_PDPE_PG_MASK
    100100#  define SHW_TOTAL_PD_ENTRIES  (X86_PG_AMD64_ENTRIES*X86_PG_AMD64_PDPE_ENTRIES)
    101101#  define SHW_POOL_ROOT_IDX     PGMPOOL_IDX_AMD64_CR3
    … …  
    104104#  define SHW_PDPT_SHIFT        X86_PDPT_SHIFT
    105105#  define SHW_PDPT_MASK         X86_PDPT_MASK_PAE
    106 #  define SHW_PDPE_PG_MASK      X86_PDPE_PG_MASK_FULL
     106#  define SHW_PDPE_PG_MASK      X86_PDPE_PG_MASK
    107107#  define SHW_TOTAL_PD_ENTRIES  (X86_PG_PAE_ENTRIES*X86_PG_PAE_PDPE_ENTRIES)
    108108#  define SHW_POOL_ROOT_IDX     PGMPOOL_IDX_PDPT

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

    r32005 r32009  
    940940    /* Allocate page directory if not present. */
    941941    if (    !pPdpe->n.u1Present
    942         &&  !(pPdpe->u & X86_PDPE_PG_MASK_FULL))
     942        &&  !(pPdpe->u & X86_PDPE_PG_MASK))
    943943    {
    944944        RTGCPTR64   GCPdPt;
    … …  
    962962                    Assert(!HWACCMIsEnabled(pVM));
    963963
    964                     GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK_FULL;
     964                    GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK;
    965965                    enmKind = PGMPOOLKIND_PAE_PD_PHYS;
    966966                    uGstPdpe |= X86_PDPE_P;
    … …  
    968968                else
    969969                {
    970                     GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK_FULL;
     970                    GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK;
    971971                    enmKind = PGMPOOLKIND_PAE_PD_FOR_PAE_PD;
    972972                }
    … …  
    998998    else
    999999    {
    1000         pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK_FULL);
     1000        pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
    10011001        AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
    1002         Assert((pPdpe->u & X86_PDPE_PG_MASK_FULL) == pShwPage->Core.Key);
     1002        Assert((pPdpe->u & X86_PDPE_PG_MASK) == pShwPage->Core.Key);
    10031003
    10041004        pgmPoolCacheUsed(pPool, pShwPage);
    … …  
    10311031        return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
    10321032    }
    1033     AssertMsg(pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK_FULL, ("GCPtr=%RGv\n", GCPtr));
     1033    AssertMsg(pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK, ("GCPtr=%RGv\n", GCPtr));
    10341034
    10351035    /* Fetch the pgm pool shadow descriptor. */
    1036     PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK_FULL);
     1036    PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
    10371037    AssertReturn(pShwPde, VERR_INTERNAL_ERROR);
    10381038
    … …  
    11121112    /* Allocate page directory if not present. */
    11131113    if (    !pPdpe->n.u1Present
    1114         &&  !(pPdpe->u & X86_PDPE_PG_MASK_FULL))
     1114        &&  !(pPdpe->u & X86_PDPE_PG_MASK))
    11151115    {
    11161116        RTGCPTR64   GCPdPt;
    … …  
    11251125        else
    11261126        {
    1127             GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK_FULL;
     1127            GCPdPt  = uGstPdpe & X86_PDPE_PG_MASK;
    11281128            enmKind = PGMPOOLKIND_64BIT_PD_FOR_64BIT_PD;
    11291129        }
    … …  
    11351135    else
    11361136    {
    1137         pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK_FULL);
     1137        pShwPage = pgmPoolGetPage(pPool, pPdpe->u & X86_PDPE_PG_MASK);
    11381138        AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
    11391139
    … …  
    11841184        return VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT;
    11851185
    1186     pShwPage = pgmPoolGetPage(pPool, pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK_FULL);
     1186    pShwPage = pgmPoolGetPage(pPool, pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
    11871187    AssertReturn(pShwPage, VERR_INTERNAL_ERROR);
    11881188
    … …  
    15331533    Assert(pGuestPDPT);
    15341534    Assert(pGuestPDPT->a[iPdpt].n.u1Present);
    1535     RTGCPHYS        GCPhys      = pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK_FULL;
     1535    RTGCPHYS        GCPhys      = pGuestPDPT->a[iPdpt].u & X86_PDPE_PG_MASK;
    15361536    bool const      fChanged    = pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt] != GCPhys;
    15371537

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

    r32005 r32009  
    18221822# if PGM_GST_TYPE == PGM_TYPE_AMD64
    18231823    /* Fetch the pgm pool shadow descriptor. */
    1824     PPGMPOOLPAGE    pShwPde  = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     1824    PPGMPOOLPAGE    pShwPde  = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK);
    18251825    Assert(pShwPde);
    18261826# endif
    … …  
    25582558# if PGM_GST_TYPE == PGM_TYPE_AMD64
    25592559    /* Fetch the pgm pool shadow descriptor. */
    2560     PPGMPOOLPAGE    pShwPde  = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     2560    PPGMPOOLPAGE    pShwPde  = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK);
    25612561    Assert(pShwPde);
    25622562# endif
    … …  
    29982998
    29992999    /* Fetch the pgm pool shadow descriptor. */
    3000     PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     3000    PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(pPool, pPdptDst->a[iPdpt].u & X86_PDPE_PG_MASK);
    30013001    Assert(pShwPde);
    30023002
    … …  
    37433743            }
    37443744
    3745             pShwPde      = pgmPoolGetPage(pPool, pPdpeDst->u & X86_PDPE_PG_MASK_FULL);
    3746             GCPhysPdeSrc = PdpeSrc.u & X86_PDPE_PG_MASK_FULL;
     3745            pShwPde      = pgmPoolGetPage(pPool, pPdpeDst->u & X86_PDPE_PG_MASK);
     3746            GCPhysPdeSrc = PdpeSrc.u & X86_PDPE_PG_MASK;
    37473747
    37483748            if (pPdpeDst->n.u1Present != PdpeSrc.n.u1Present)
    … …  
    43974397                    RTHCPTR     HCPtr;
    43984398                    RTHCPHYS    HCPhys;
    4399                     RTGCPHYS    GCPhys = pGuestPDPT->a[i].u & X86_PDPE_PG_MASK_FULL;
     4399                    RTGCPHYS    GCPhys = pGuestPDPT->a[i].u & X86_PDPE_PG_MASK;
    44004400                    pgmLock(pVM);
    44014401                    PPGMPAGE    pPage  = pgmPhysGetPage(&pVM->pgm.s, GCPhys);

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

    r32000 r32009  
    141141         * The PDE.
    142142         */
    143         rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pdpe.u & X86_PDPE_PG_MASK_FULL, &pWalk->pPd);
     143        rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pdpe.u & X86_PDPE_PG_MASK, &pWalk->pPd);
    144144        if (RT_FAILURE(rc))
    145145            return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 2, rc);

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

    r32005 r32009  
    352352                 * Mark the page as locked; disallow flushing.
    353353                 */
    354                 PPGMPOOLPAGE    pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdPt].u & X86_PDPE_PG_MASK_FULL);
     354                PPGMPOOLPAGE    pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
    355355                AssertFatal(pPoolPagePd);
    356356                if (!pgmPoolIsPageLocked(&pVM->pgm.s, pPoolPagePd))
    … …  
    500500                 */
    501501                if (    pCurrentShwPdpt
    502                     &&  (pCurrentShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL) == (pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL) )
     502                    &&  (pCurrentShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK) == (pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK) )
    503503                {
    504504                    LogFlow(("pgmMapClearShadowPDEs: Pdpe %d reused -> don't clear hypervisor mappings!\n", iPdpt));
    … …  
    524524                    ||  !(pShwPdpt->a[iPdpt].u & PGM_PLXFLAGS_MAPPING))
    525525                {
    526                     PPGMPOOLPAGE pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     526                    PPGMPOOLPAGE pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    527527                    AssertFatal(pPoolPagePd);
    528528                    if (pgmPoolIsPageLocked(&pVM->pgm.s, pPoolPagePd))
    … …  
    606606                           iPDE, iPdpt, iPaePDE, pMap->GCPtr, R3STRING(pMap->pszDesc) ));
    607607
    608                 PCPGMPOOLPAGE   pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK_FULL);
     608                PCPGMPOOLPAGE   pPoolPagePd = pgmPoolGetPage(pPool, pShwPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    609609                AssertFatal(pPoolPagePd);
    610610                AssertMsg(pPoolPagePd->cLocked, (".idx=%d .type=%d\n", pPoolPagePd->idx, pPoolPagePd->enmKind));

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

    r32005 r32009  
    541541                        LogFlow(("pgmPoolMonitorChainChanging: pae pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPT->a[iShw].u));
    542542                        pgmPoolFree(pVM,
    543                                     uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK_FULL,
     543                                    uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK,
    544544                                    pPage->idx,
    545545                                    iShw);
    … …  
    572572                                LogFlow(("pgmPoolMonitorChainChanging: pae pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPT->a[iShw2].u));
    573573                                pgmPoolFree(pVM,
    574                                             uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK_FULL,
     574                                            uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK,
    575575                                            pPage->idx,
    576576                                            iShw2);
    … …  
    632632                {
    633633                    LogFlow(("pgmPoolMonitorChainChanging: pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPT->a[iShw].u));
    634                     pgmPoolFree(pVM, uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK_FULL, pPage->idx, iShw);
     634                    pgmPoolFree(pVM, uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK, pPage->idx, iShw);
    635635                    ASMAtomicWriteSize(&uShw.pPDPT->a[iShw].u, 0);
    636636                }
    … …  
    643643                    {
    644644                        LogFlow(("pgmPoolMonitorChainChanging: pdpt iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPT->a[iShw2].u));
    645                         pgmPoolFree(pVM, uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK_FULL, pPage->idx, iShw2);
     645                        pgmPoolFree(pVM, uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK, pPage->idx, iShw2);
    646646                        ASMAtomicWriteSize(&uShw.pPDPT->a[iShw2].u, 0);
    647647                    }
    … …  
    42964296           )
    42974297        {
    4298             PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPDPT->a[i].u & X86_PDPE_PG_MASK_FULL);
     4298            PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPDPT->a[i].u & X86_PDPE_PG_MASK);
    42994299            if (pSubPage)
    43004300                pgmPoolTrackFreeUser(pPool, pSubPage, pPage->idx, i);
    43014301            else
    4302                 AssertFatalMsgFailed(("%RX64\n", pShwPDPT->a[i].u & X86_PDPE_PG_MASK_FULL));
     4302                AssertFatalMsgFailed(("%RX64\n", pShwPDPT->a[i].u & X86_PDPE_PG_MASK));
    43034303        }
    43044304    }
    … …  
    43204320        if (pShwPDPT->a[i].n.u1Present)
    43214321        {
    4322             PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPDPT->a[i].u & X86_PDPE_PG_MASK_FULL);
     4322            PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPDPT->a[i].u & X86_PDPE_PG_MASK);
    43234323            if (pSubPage)
    43244324                pgmPoolTrackFreeUser(pPool, pSubPage, pPage->idx, i);
    43254325            else
    4326                 AssertFatalMsgFailed(("%RX64\n", pShwPDPT->a[i].u & X86_PDPE_PG_MASK_FULL));
     4326                AssertFatalMsgFailed(("%RX64\n", pShwPDPT->a[i].u & X86_PDPE_PG_MASK));
    43274327            /** @todo 64-bit guests: have to ensure that we're not exhausting the dynamic mappings! */
    43284328        }
    … …  
    43444344        if (pShwPML4->a[i].n.u1Present)
    43454345        {
    4346             PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPML4->a[i].u & X86_PDPE_PG_MASK_FULL);
     4346            PPGMPOOLPAGE pSubPage = (PPGMPOOLPAGE)RTAvloHCPhysGet(&pPool->HCPhysTree, pShwPML4->a[i].u & X86_PDPE_PG_MASK);
    43474347            if (pSubPage)
    43484348                pgmPoolTrackFreeUser(pPool, pSubPage, pPage->idx, i);

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

    r32005 r32009  
    157157#  define SHW_PDPT_SHIFT                X86_PDPT_SHIFT
    158158#  define SHW_PDPT_MASK                 X86_PDPT_MASK_AMD64
    159 #  define SHW_PDPE_PG_MASK              X86_PDPE_PG_MASK_FULL
     159#  define SHW_PDPE_PG_MASK              X86_PDPE_PG_MASK
    160160#  define SHW_TOTAL_PD_ENTRIES          (X86_PG_AMD64_ENTRIES * X86_PG_AMD64_PDPE_ENTRIES)
    161161#  define SHW_POOL_ROOT_IDX             PGMPOOL_IDX_AMD64_CR3
    … …  
    164164#  define SHW_PDPT_SHIFT                X86_PDPT_SHIFT
    165165#  define SHW_PDPT_MASK                 X86_PDPT_MASK_PAE
    166 #  define SHW_PDPE_PG_MASK              X86_PDPE_PG_MASK_FULL
     166#  define SHW_PDPE_PG_MASK              X86_PDPE_PG_MASK
    167167#  define SHW_TOTAL_PD_ENTRIES          (X86_PG_PAE_ENTRIES * X86_PG_PAE_PDPE_ENTRIES)
    168168#  define SHW_POOL_ROOT_IDX             PGMPOOL_IDX_PDPT
    … …  
    227227    /* PD */
    228228    PX86PDPAE       pPd;
    229     rc = PGM_HCPHYS_2_PTR(pVM, pVCpu, Pdpe.u & X86_PDPE_PG_MASK_FULL, &pPd);
     229    rc = PGM_HCPHYS_2_PTR(pVM, pVCpu, Pdpe.u & X86_PDPE_PG_MASK, &pPd);
    230230    if (RT_FAILURE(rc))
    231231        return rc;
    … …  
    393393        /* PD */
    394394        PX86PDPAE       pPd;
    395         rc = PGM_HCPHYS_2_PTR(pVM, pVCpu, Pdpe.u & X86_PDPE_PG_MASK_FULL, &pPd);
     395        rc = PGM_HCPHYS_2_PTR(pVM, pVCpu, Pdpe.u & X86_PDPE_PG_MASK, &pPd);
    396396        if (RT_FAILURE(rc))
    397397            return rc;

  • trunk/src/VBox/VMM/VMMRZ/PGMRZDynMap.cpp

    r32000 r32009  
    732732            pPgLvl->a[0].fResMask  = X86_PDPE_P;
    733733
    734             pPgLvl->a[1].fPhysMask = X86_PDPE_PG_MASK_FULL;
     734            pPgLvl->a[1].fPhysMask = X86_PDPE_PG_MASK;
    735735            pPgLvl->a[1].fPtrMask  = X86_PD_PAE_MASK;
    736736            pPgLvl->a[1].fPtrShift = X86_PD_PAE_SHIFT;
    … …  
    762762            pPgLvl->a[1].fResMask  = X86_PDPE_P | X86_PDPE_RW;
    763763
    764             pPgLvl->a[2].fPhysMask = X86_PDPE_PG_MASK_FULL;
     764            pPgLvl->a[2].fPhysMask = X86_PDPE_PG_MASK;
    765765            pPgLvl->a[2].fPtrShift = X86_PD_PAE_SHIFT;
    766766            pPgLvl->a[2].fPtrMask  = X86_PD_PAE_MASK;
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