VirtualBox

Changeset 41391 in vbox for trunk/src/VBox/VMM


Ignore:
Timestamp:
May 22, 2012 2:06:53 PM (13 years ago)
Author:
vboxsync
Message:

PGM: A quick stab at correct A20 gate masking (new code is disabled).

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

Legend:

Unmodified
Added
Removed

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

    r41386 r41391  
    18471847            break;
    18481848    }
     1849    PGM_A20_APPLY_TO_VAR(pVCpu, GCPhysCR3);
    18491850
    18501851    if (pVCpu->pgm.s.GCPhysCR3 != GCPhysCR3)
    … …  
    19491950            break;
    19501951    }
     1952    PGM_A20_APPLY_TO_VAR(pVCpu, GCPhysCR3);
     1953
    19511954    if (pVCpu->pgm.s.GCPhysCR3 != GCPhysCR3)
    19521955    {
    … …  
    20342037                break;
    20352038        }
     2039        PGM_A20_APPLY_TO_VAR(pVCpu, GCPhysCR3);
    20362040
    20372041        if (pVCpu->pgm.s.GCPhysCR3 != GCPhysCR3)

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

    r40449 r41391  
    173173        const RTGCPHYS  GCPhysFault = pGstWalk->Core.GCPhys;
    174174# else
    175         const RTGCPHYS  GCPhysFault = (RTGCPHYS)pvFault;
     175        const RTGCPHYS  GCPhysFault = PGM_A20_APPLY(pVCpu, (RTGCPHYS)pvFault);
    176176# endif
    177177        PPGMPHYSHANDLER pCur = pgmHandlerPhysicalLookup(pVM, GCPhysFault);
    … …  
    561561        rc = PGM_BTH_NAME(SyncPage)(pVCpu, GstWalk.Pde, pvFault, 1, uErr);
    562562#   else
    563         rc = pgmPhysGetPageEx(pVM, (RTGCPHYS)pvFault, &pPage);
     563        rc = pgmPhysGetPageEx(pVM, PGM_A20_APPLY(pVCpu, (RTGCPHYS)pvFault), &pPage);
    564564        if (RT_SUCCESS(rc) && PGM_PAGE_HAS_ACTIVE_ALL_HANDLERS(pPage))
    565565            return VBOXSTRICTRC_TODO(PGM_BTH_NAME(Trap0eHandlerDoAccessHandlers)(pVCpu, uErr, pRegFrame, pvFault, pPage,
    … …  
    753753    RTGCPHYS GCPhys = GstWalk.Core.GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK;
    754754#  else
    755     RTGCPHYS GCPhys = (RTGCPHYS)pvFault & ~(RTGCPHYS)PAGE_OFFSET_MASK;
     755    RTGCPHYS GCPhys = PGM_A20_APPLY(pVCpu, (RTGCPHYS)pvFault & ~(RTGCPHYS)PAGE_OFFSET_MASK);
    756756#  endif /* PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
    757757    PPGMPAGE pPage;
    … …  
    12831283# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    12841284            /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    1285             GCPhys |= (iPDDst & 1) * (PAGE_SIZE/2);
     1285            GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | ((iPDDst & 1) * (PAGE_SIZE / 2)));
    12861286# endif
    12871287            if (pShwPage->GCPhys == GCPhys)
    … …  
    13321332# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    13331333            /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    1334             GCPhys |= GCPtrPage & (1 << X86_PD_PAE_SHIFT);
     1334            GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | (GCPtrPage & (1 << X86_PD_PAE_SHIFT)));
    13351335# endif
    13361336            if (    pShwPage->GCPhys == GCPhys
    … …  
    19091909# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    19101910        /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    1911         GCPhys |= (iPDDst & 1) * (PAGE_SIZE / 2);
     1911        GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | ((iPDDst & 1) * (PAGE_SIZE / 2)));
    19121912# endif
    19131913    }
    … …  
    19171917# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    19181918        /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    1919         GCPhys |= GCPtrPage & (1 << X86_PD_PAE_SHIFT);
     1919        GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | (GCPtrPage & (1 << X86_PD_PAE_SHIFT)));
    19201920# endif
    19211921    }
    … …  
    20372037                 */
    20382038                /* Calculate the GC physical address of this 4KB shadow page. */
    2039                 GCPhys = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc) | (GCPtrPage & GST_BIG_PAGE_OFFSET_MASK);
     2039                GCPhys = PGM_A20_APPLY(pVCpu, GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc) | (GCPtrPage & GST_BIG_PAGE_OFFSET_MASK));
    20402040                /* Find ram range. */
    20412041                PPGMPAGE pPage;
    … …  
    26732673# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    26742674            /* Select the right PDE as we're emulating a 4kb page table with 2 shadow page tables. */
    2675             GCPhys |= (iPDDst & 1) * (PAGE_SIZE / 2);
     2675            GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | ((iPDDst & 1) * (PAGE_SIZE / 2)));
    26762676# endif
    26772677            rc = pgmPoolAlloc(pVM, GCPhys, BTH_PGMPOOLKIND_PT_FOR_PT, pShwPde->idx, iPDDst, &pShwPage);
    … …  
    26892689# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    26902690            /* Select the right PDE as we're emulating a 4MB page directory with two 2 MB shadow PDEs.*/
    2691             GCPhys |= GCPtrPage & (1 << X86_PD_PAE_SHIFT);
     2691            GCPhys = PGM_A20_APPLY(pVCpu, GCPhys | (GCPtrPage & (1 << X86_PD_PAE_SHIFT)));
    26922692# endif
    26932693            /* Determine the right kind of large page to avoid incorrect cached entry reuse. */
    … …  
    29092909                if (pRam && GCPhys >= pRam->GCPhys)
    29102910                {
     2911# ifndef PGM_WITH_A20
    29112912                    unsigned iHCPage = (GCPhys - pRam->GCPhys) >> PAGE_SHIFT;
     2913# endif
    29122914                    do
    29132915                    {
    29142916                        /* Make shadow PTE. */
     2917# ifdef PGM_WITH_A20
     2918                        PPGMPAGE    pPage = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
     2919# else
    29152920                        PPGMPAGE    pPage = &pRam->aPages[iHCPage];
     2921# endif
    29162922                        SHWPTE      PteDst;
    29172923
    … …  
    29772983                        /* advance */
    29782984                        GCPhys += PAGE_SIZE;
     2985                        PGM_A20_APPLY_TO_VAR(pVCpu, GCPhys);
     2986# ifndef PGM_WITH_A20
    29792987                        iHCPage++;
     2988# endif
    29802989                        iPTDst++;
    29812990                    } while (   iPTDst < RT_ELEMENTS(pPTDst->a)
    … …  
    29963005                    } while (   iPTDst < RT_ELEMENTS(pPTDst->a)
    29973006                             && GCPhys < pRam->GCPhys);
     3007                    PGM_A20_APPLY_TO_VAR(pVCpu,GCPhys);
    29983008                }
    29993009                else
    … …  
    30923102        /* Check if we allocated a big page before for this 2 MB range. */
    30933103        PPGMPAGE pPage;
    3094         rc = pgmPhysGetPageEx(pVM, GCPtrPage & X86_PDE2M_PAE_PG_MASK, &pPage);
     3104        rc = pgmPhysGetPageEx(pVM, PGM_A20_APPLY(pVCpu, GCPtrPage & X86_PDE2M_PAE_PG_MASK), &pPage);
    30953105        if (RT_SUCCESS(rc))
    30963106        {
    … …  
    30983108            if (PGM_PAGE_GET_PDE_TYPE(pPage) == PGM_PAGE_PDE_TYPE_PDE)
    30993109            {
    3100                 STAM_REL_COUNTER_INC(&pVM->pgm.s.StatLargePageReused);
    3101                 AssertRelease(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
    3102                 HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
     3110                if (PGM_A20_IS_ENABLED(pVCpu))
     3111                {
     3112                    STAM_REL_COUNTER_INC(&pVM->pgm.s.StatLargePageReused);
     3113                    AssertRelease(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
     3114                    HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
     3115                }
     3116                else
     3117                {
     3118                    PGM_PAGE_SET_PDE_TYPE(pVM, pPage, PGM_PAGE_PDE_TYPE_PDE_DISABLED);
     3119                    pVM->pgm.s.cLargePagesDisabled++;
     3120                }
    31033121            }
    3104             else if (PGM_PAGE_GET_PDE_TYPE(pPage) == PGM_PAGE_PDE_TYPE_PDE_DISABLED)
     3122            else if (   PGM_PAGE_GET_PDE_TYPE(pPage) == PGM_PAGE_PDE_TYPE_PDE_DISABLED
     3123                     && PGM_A20_IS_ENABLED(pVCpu))
    31053124            {
    31063125                /* Recheck the entire 2 MB range to see if we can use it again as a large page. */
    … …  
    31133132                }
    31143133            }
    3115             else if (PGMIsUsingLargePages(pVM))
     3134            else if (   PGMIsUsingLargePages(pVM)
     3135                     && PGM_A20_IS_ENABLED(pVCpu))
    31163136            {
    31173137                rc = pgmPhysAllocLargePage(pVM, GCPtrPage);
    … …  
    31613181
    31623182    /* Virtual address = physical address */
    3163     GCPhys = GCPtrPage & X86_PAGE_4K_BASE_MASK;
     3183    GCPhys = PGM_A20_APPLY(pVCpu, GCPtrPage & X86_PAGE_4K_BASE_MASK);
    31643184    rc = pgmPoolAlloc(pVM, GCPhys & ~(RT_BIT_64(SHW_PD_SHIFT) - 1), BTH_PGMPOOLKIND_PT_FOR_PT, pShwPde->idx, iPDDst, &pShwPage);
    31653185
    … …  
    31833203        for (unsigned iPTDst = 0; iPTDst < RT_ELEMENTS(pPTDst->a); iPTDst++)
    31843204        {
    3185             RTGCPTR GCPtrCurPage = (GCPtrPage & ~(RTGCPTR)(SHW_PT_MASK << SHW_PT_SHIFT)) | (iPTDst << PAGE_SHIFT);
     3205            RTGCPTR GCPtrCurPage = PGM_A20_APPLY(pVCpu, (GCPtrPage & ~(RTGCPTR)(SHW_PT_MASK << SHW_PT_SHIFT))
     3206                                                      | (iPTDst << PAGE_SHIFT));
    31863207
    31873208            PGM_BTH_NAME(SyncPageWorker)(pVCpu, &pPTDst->a[iPTDst], GCPtrCurPage, pShwPage, iPTDst);
    … …  
    35633584 * @returns VBox status code, no specials.
    35643585 * @param   pVCpu       The VMCPU handle.
    3565  * @param   cr0         Guest context CR0 register
    3566  * @param   cr3         Guest context CR3 register
    3567  * @param   cr4         Guest context CR4 register
     3586 * @param   cr0         Guest context CR0 register.
     3587 * @param   cr3         Guest context CR3 register. Not subjected to the A20
     3588 *                      mask.
     3589 * @param   cr4         Guest context CR4 register.
    35683590 * @param   fGlobal     Including global page directories or not
    35693591 */
    … …  
    36903712     * Check that the Guest CR3 and all its mappings are correct.
    36913713     */
    3692     AssertMsgReturn(pPGM->GCPhysCR3 == (cr3 & GST_CR3_PAGE_MASK),
     3714    AssertMsgReturn(pPGM->GCPhysCR3 == PGM_A20_APPLY(pVCpu, cr3 & GST_CR3_PAGE_MASK),
    36933715                    ("Invalid GCPhysCR3=%RGp cr3=%RGp\n", pPGM->GCPhysCR3, (RTGCPHYS)cr3),
    36943716                    false);
    … …  
    37013723    AssertRCReturn(rc, 1);
    37023724    HCPhys = NIL_RTHCPHYS;
    3703     rc = pgmRamGCPhys2HCPhys(pVM, cr3 & GST_CR3_PAGE_MASK, &HCPhys);
     3725    rc = pgmRamGCPhys2HCPhys(pVM, PGM_A20_APPLY(pVCpu, cr3 & GST_CR3_PAGE_MASK), &HCPhys);
    37043726    AssertMsgReturn(HCPhys == HCPhysShw, ("HCPhys=%RHp HCPhyswShw=%RHp (cr3)\n", HCPhys, HCPhysShw), false);
    37053727#   if PGM_GST_TYPE == PGM_TYPE_32BIT && defined(IN_RING3)
    … …  
    37083730    rc = PGMR3DbgR3Ptr2GCPhys(pVM, pPGM->pGst32BitPdR3, &GCPhys);
    37093731    AssertRCReturn(rc, 1);
    3710     AssertMsgReturn((cr3 & GST_CR3_PAGE_MASK) == GCPhys, ("GCPhys=%RGp cr3=%RGp\n", GCPhys, (RTGCPHYS)cr3), false);
     3732    AssertMsgReturn(PGM_A20_APPLY(pVCpu, cr3 & GST_CR3_PAGE_MASK) == GCPhys, ("GCPhys=%RGp cr3=%RGp\n", GCPhys, (RTGCPHYS)cr3), false);
    37113733#   endif
    37123734#  endif /* !IN_RING0 */
    … …  
    37553777
    37563778        pShwPdpt = pgmPoolGetPage(pPool, pPml4eDst->u & X86_PML4E_PG_MASK);
    3757         GCPhysPdptSrc = pPml4eSrc->u & X86_PML4E_PG_MASK;
     3779        GCPhysPdptSrc = PGM_A20_APPLY(pVCpu, pPml4eSrc->u & X86_PML4E_PG_MASK);
    37583780
    37593781        if (pPml4eSrc->n.u1Present != pPml4eDst->n.u1Present)
    … …  
    38293851
    38303852            pShwPde      = pgmPoolGetPage(pPool, pPdpeDst->u & X86_PDPE_PG_MASK);
    3831             GCPhysPdeSrc = PdpeSrc.u & X86_PDPE_PG_MASK;
     3853            GCPhysPdeSrc = PGM_A20_APPLY(pVCpu, PdpeSrc.u & X86_PDPE_PG_MASK);
    38323854
    38333855            if (pPdpeDst->n.u1Present != PdpeSrc.n.u1Present)
    … …  
    39403962                        GCPhysGst = GST_GET_PDE_GCPHYS(PdeSrc);
    39413963#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    3942                         GCPhysGst |= (iPDDst & 1) * (PAGE_SIZE / 2);
     3964                        GCPhysGst = PGM_A20_APPLY(pVCpu, GCPhysGst | ((iPDDst & 1) * (PAGE_SIZE / 2)));
    39433965#  endif
    39443966                    }
    … …  
    39563978                        GCPhysGst = GST_GET_BIG_PDE_GCPHYS(pVM, PdeSrc);
    39573979#  if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE == PGM_TYPE_32BIT
    3958                         GCPhysGst |= GCPtr & RT_BIT(X86_PAGE_2M_SHIFT);
     3980                        GCPhysGst = PGM_A20_APPLY(pVCpu, GCPhysGst | (GCPtr & RT_BIT(X86_PAGE_2M_SHIFT)));
    39593981#  endif
    39603982                    }
    … …  
    39924014                        */
    39934015                        const GSTPT *pPTSrc;
    3994                         rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, GCPhysGst & ~(RTGCPHYS)(PAGE_SIZE - 1), &pPTSrc);
     4016                        rc = PGM_GCPHYS_2_PTR_V2(pVM, pVCpu, PGM_A20_APPLY(pVCpu, GCPhysGst & ~(RTGCPHYS)(PAGE_SIZE - 1)),
     4017                                                 &pPTSrc);
    39954018                        if (RT_FAILURE(rc))
    39964019                        {
    … …  
    40474070                                AssertMsgFailed(("Out of sync (!P) PTE at %RGv! PteSrc=%#RX64 PteDst=%#RX64 pPTSrc=%RGv iPTSrc=%x PdeSrc=%x physpte=%RGp\n",
    40484071                                                GCPtr + off, (uint64_t)PteSrc.u, SHW_PTE_LOG64(PteDst), pPTSrc, iPT + offPTSrc, PdeSrc.au32[0],
    4049                                                 (uint64_t)GST_GET_PDE_GCPHYS(PdeSrc) + (iPT + offPTSrc)*sizeof(PteSrc)));
     4072                                                (uint64_t)GST_GET_PDE_GCPHYS(PdeSrc) + (iPT + offPTSrc) * sizeof(PteSrc)));
    40504073                                cErrors++;
    40514074                                continue;
    … …  
    42754298                        for (unsigned iPT = 0, off = 0;
    42764299                            iPT < RT_ELEMENTS(pPTDst->a);
    4277                             iPT++, off += PAGE_SIZE, GCPhysGst += PAGE_SIZE)
     4300                            iPT++, off += PAGE_SIZE, GCPhysGst = PGM_A20_APPLY(pVCpu, GCPhysGst + PAGE_SIZE))
    42784301                        {
    42794302                            const SHWPTE PteDst = pPTDst->a[iPT];
    … …  
    44144437 * @retval  VINF_SUCCESS.
    44154438 *
    4416  * @param   pVCpu       The VMCPU handle.
    4417  * @param   GCPhysCR3       The physical address in the CR3 register.
     4439 * @param   pVCpu           The VMCPU handle.
     4440 * @param   GCPhysCR3       The physical address in the CR3 register.  (A20
     4441 *                          mask already applied.)
    44184442 */
    44194443PGM_BTH_DECL(int, MapCR3)(PVMCPU pVCpu, RTGCPHYS GCPhysCR3)
    … …  
    44814505                    RTHCPTR     HCPtr;
    44824506                    RTHCPHYS    HCPhys;
    4483                     RTGCPHYS    GCPhys = pGuestPDPT->a[i].u & X86_PDPE_PG_MASK;
     4507                    RTGCPHYS    GCPhys = PGM_A20_APPLY(pVCpu, pGuestPDPT->a[i].u & X86_PDPE_PG_MASK);
    44844508                    pgmLock(pVM);
    44854509                    PPGMPAGE    pPage  = pgmPhysGetPage(pVM, GCPhys);

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

    r39078 r41391  
    167167            pWalk->Core.GCPhys       = GST_GET_BIG_PDE_GCPHYS(pVCpu->CTX_SUFF(pVM), Pde)
    168168                                     | (GCPtr & GST_BIG_PAGE_OFFSET_MASK);
     169            PGM_A20_APPLY_TO_VAR(pVCpu, pWalk->Core.GCPhys);
    169170            uint8_t fEffectiveXX     = (uint8_t)pWalk->Pde.u
    170171#  if PGM_GST_TYPE == PGM_TYPE_AMD64
    … …  
    515516                        RTGCPHYS    GCPhysNew;
    516517                        if (Pte.n.u1Present)
    517                             GCPhysNew = (RTGCPHYS)(pPT->a[iPTE].u & GST_PTE_PG_MASK) + offPage;
     518                            GCPhysNew = PGM_A20_APPLY(pVCpu, (RTGCPHYS)(pPT->a[iPTE].u & GST_PTE_PG_MASK) + offPage);
    518519                        else
    519520                            GCPhysNew = NIL_RTGCPHYS;
    … …  
    567568                     i4KB++, iPage++, GCPtr += PAGE_SIZE, offPage = 0)
    568569                {
    569                     RTGCPHYS GCPhysNew = GCPhys + (i4KB << PAGE_SHIFT) + offPage;
     570                    RTGCPHYS GCPhysNew = PGM_A20_APPLY(pVCpu, GCPhys + (i4KB << PAGE_SHIFT) + offPage);
    570571                    if (pCur->aPhysToVirt[iPage].Core.Key != GCPhysNew)
    571572                    {

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

    r36891 r41391  
    107107#  endif
    108108# endif
    109 # define GST_GET_PTE_GCPHYS(Pte)                ((Pte).u & GST_PTE_PG_MASK)
     109# define GST_GET_PTE_GCPHYS(Pte)                PGM_A20_APPLY(pVCpu, ((Pte).u & GST_PTE_PG_MASK))
    110110# define GST_GET_PDE_GCPHYS(Pde)                (true && This_should_perhaps_not_be_used_in_this_context) //??
    111111# define GST_GET_BIG_PDE_GCPHYS(Pde)            (true && This_should_perhaps_not_be_used_in_this_context) //??
    … …  
    138138# define GST_PDE_PG_MASK                        X86_PDE_PG_MASK
    139139# define GST_PDE_BIG_PG_MASK                    X86_PDE4M_PG_MASK
    140 # define GST_GET_PTE_GCPHYS(Pte)                ((Pte).u & GST_PDE_PG_MASK)
    141 # define GST_GET_PDE_GCPHYS(Pde)                ((Pde).u & GST_PDE_PG_MASK)
    142 # define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       pgmGstGet4MBPhysPage((pVM), Pde)
     140# define GST_GET_PTE_GCPHYS(Pte)                PGM_A20_APPLY(pVCpu, ((Pte).u & GST_PDE_PG_MASK))
     141# define GST_GET_PDE_GCPHYS(Pde)                PGM_A20_APPLY(pVCpu, ((Pde).u & GST_PDE_PG_MASK))
     142# define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       PGM_A20_APPLY(pVCpu, pgmGstGet4MBPhysPage((pVM), Pde))
    143143# define GST_GET_PDE_SHW_FLAGS(pVCpu, Pde)      ((Pde).u & (X86_PDE_P | X86_PDE_RW | X86_PDE_US | X86_PDE_A))
    144144# define GST_GET_BIG_PDE_SHW_FLAGS(pVCpu, Pde) \
    … …  
    178178# define GST_PDE_PG_MASK                        X86_PDE_PAE_PG_MASK
    179179# define GST_PDE_BIG_PG_MASK                    X86_PDE2M_PAE_PG_MASK
    180 # define GST_GET_PTE_GCPHYS(Pte)                ((Pte).u & GST_PTE_PG_MASK)
    181 # define GST_GET_PDE_GCPHYS(Pde)                ((Pde).u & GST_PDE_PG_MASK)
    182 # define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       ((Pde).u & GST_PDE_BIG_PG_MASK)
     180# define GST_GET_PTE_GCPHYS(Pte)                PGM_A20_APPLY(pVCpu, ((Pte).u & GST_PTE_PG_MASK))
     181# define GST_GET_PDE_GCPHYS(Pde)                PGM_A20_APPLY(pVCpu, ((Pde).u & GST_PDE_PG_MASK))
     182# define GST_GET_BIG_PDE_GCPHYS(pVM, Pde)       PGM_A20_APPLY(pVCpu, ((Pde).u & GST_PDE_BIG_PG_MASK))
    183183# define GST_GET_PTE_SHW_FLAGS(pVCpu, Pte)      ((Pte).u & (pVCpu)->pgm.s.fGst64ShadowedPteMask )
    184184# define GST_GET_PDE_SHW_FLAGS(pVCpu, Pde)      ((Pde).u & (pVCpu)->pgm.s.fGst64ShadowedPdeMask )

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

    r40054 r41391  
    25202520
    25212521
     2522
     2523/** @name A20 gate macros
     2524 * @{ */
     2525/*#define PGM_WITH_A20*/
     2526#ifdef PGM_WITH_A20
     2527# define PGM_A20_IS_ENABLED(a_pVCpu)                        ((a_pVCpu)->pgm.s.fA20Enabled)
     2528# define PGM_A20_APPLY(a_pVCpu, a_GCPhys)                   ((a_pVCpu)->pgm.s.GCPhysA20Mask & (a_GCPhys))
     2529# define PGM_A20_APPLY_TO_VAR(a_pVCpu, a_GCPhysVar)         \
     2530    do { a_GCPhysVar = (a_pVCpu)->pgm.s.GCPhysA20Mask & a_GCPhysVar; } while (0)
     2531#else
     2532# define PGM_A20_IS_ENABLED(a_pVCpu)                        (true)
     2533# define PGM_A20_APPLY(a_pVCpu, a_GCPhys)                   (a_GCPhys)
     2534# define PGM_A20_APPLY_TO_VAR(a_pVCpu, a_GCPhysVar)         do { } while (0)
     2535#endif
     2536/** @} */
     2537
     2538
    25222539/**
    25232540 * Trees are using self relative offsets as pointers.
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