VirtualBox

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


Ignore:
Timestamp:
Nov 10, 2007 2:10:41 PM (17 years ago)
Author:
vboxsync
Message:

Initial changes for guest PAE support

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

Legend:

Unmodified
Added
Removed

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

    r5630 r5662  
    24412441    pVM->pgm.s.pfnR3GstMapCR3               = pModeData->pfnR3GstMapCR3;
    24422442    pVM->pgm.s.pfnR3GstUnmapCR3             = pModeData->pfnR3GstUnmapCR3;
    2443     pVM->pgm.s.pfnHCGstWriteHandlerCR3      = pModeData->pfnHCGstWriteHandlerCR3;
    2444     pVM->pgm.s.pszHCGstWriteHandlerCR3      = pModeData->pszHCGstWriteHandlerCR3;
     2443    pVM->pgm.s.pfnR3GstWriteHandlerCR3      = pModeData->pfnR3GstWriteHandlerCR3;
     2444    pVM->pgm.s.pszR3GstWriteHandlerCR3      = pModeData->pszR3GstWriteHandlerCR3;
     2445    pVM->pgm.s.pfnR3GstPAEWriteHandlerCR3   = pModeData->pfnR3GstPAEWriteHandlerCR3;
     2446    pVM->pgm.s.pszR3GstPAEWriteHandlerCR3   = pModeData->pszR3GstPAEWriteHandlerCR3;
    24452447
    24462448    pVM->pgm.s.pfnGCGstGetPage              = pModeData->pfnGCGstGetPage;
    … …  
    24522454    pVM->pgm.s.pfnGCGstUnmapCR3             = pModeData->pfnGCGstUnmapCR3;
    24532455    pVM->pgm.s.pfnGCGstWriteHandlerCR3      = pModeData->pfnGCGstWriteHandlerCR3;
     2456    pVM->pgm.s.pfnGCGstPAEWriteHandlerCR3   = pModeData->pfnGCGstPAEWriteHandlerCR3;
    24542457
    24552458    pVM->pgm.s.pfnR0GstGetPage              = pModeData->pfnR0GstGetPage;
    … …  
    24602463    pVM->pgm.s.pfnR0GstMapCR3               = pModeData->pfnR0GstMapCR3;
    24612464    pVM->pgm.s.pfnR0GstUnmapCR3             = pModeData->pfnR0GstUnmapCR3;
    2462     pVM->pgm.s.pfnR0GstWriteHandlerCR3      = pModeData->pfnR0GstWriteHandlerCR3;
    24632465
    24642466

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

    r4071 r5662  
    128128
    129129#if PGM_GST_TYPE == PGM_TYPE_32BIT || PGM_GST_TYPE == PGM_TYPE_PAE
    130     pModeData->pfnHCGstWriteHandlerCR3 = PGM_GST_NAME(WriteHandlerCR3);
    131     pModeData->pszHCGstWriteHandlerCR3 = "Guest CR3 Write access handler";
     130    pModeData->pfnR3GstWriteHandlerCR3    = PGM_GST_NAME(WriteHandlerCR3);
     131    pModeData->pszR3GstWriteHandlerCR3    = "Guest CR3 Write access handler";
     132    pModeData->pfnR3GstPAEWriteHandlerCR3 = PGM_GST_NAME(WriteHandlerCR3);
     133    pModeData->pszR3GstPAEWriteHandlerCR3 = "Guest CR3 Write access handler (PAE)";
    132134#else
    133     pModeData->pfnHCGstWriteHandlerCR3 = NULL;
    134     pModeData->pszHCGstWriteHandlerCR3 = NULL;
    135     pModeData->pfnGCGstWriteHandlerCR3 = 0;
     135    pModeData->pfnR3GstWriteHandlerCR3    = NULL;
     136    pModeData->pszR3GstWriteHandlerCR3    = NULL;
     137    pModeData->pfnR3GstPAEWriteHandlerCR3 = NULL;
     138    pModeData->pszR3GstPAEWriteHandlerCR3 = NULL;
    136139#endif
    137140
    … …  
    158161        rc = PDMR3GetSymbolGC(pVM, NULL, PGM_GST_NAME_GC_STR(WriteHandlerCR3),  &pModeData->pfnGCGstWriteHandlerCR3);
    159162        AssertMsgRCReturn(rc, ("%s -> rc=%Vrc\n", PGM_GST_NAME_GC_STR(WriteHandlerCR3), rc), rc);
     163        rc = PDMR3GetSymbolGC(pVM, NULL, PGM_GST_NAME_GC_STR(WriteHandlerCR3),  &pModeData->pfnGCGstPAEWriteHandlerCR3);
     164        AssertMsgRCReturn(rc, ("%s -> rc=%Vrc\n", PGM_GST_NAME_GC_STR(PAEWriteHandlerCR3), rc), rc);
    160165#endif
    161166

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

    r5661 r5662  
    14051405    DECLR3CALLBACKMEMBER(int,  pfnR3GstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    14061406    DECLR3CALLBACKMEMBER(int,  pfnR3GstUnmapCR3,(PVM pVM));
    1407     R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnHCGstWriteHandlerCR3;
    1408     R3PTRTYPE(const char *)         pszHCGstWriteHandlerCR3;
     1407    R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnR3GstWriteHandlerCR3;
     1408    R3PTRTYPE(const char *)         pszR3GstWriteHandlerCR3;
     1409    R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnR3GstPAEWriteHandlerCR3;
     1410    R3PTRTYPE(const char *)         pszR3GstPAEWriteHandlerCR3;
    14091411
    14101412    DECLGCCALLBACKMEMBER(int,  pfnGCGstGetPage,(PVM pVM, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys));
    … …  
    14161418    DECLGCCALLBACKMEMBER(int,  pfnGCGstUnmapCR3,(PVM pVM));
    14171419    GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
     1420    GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
    14181421
    14191422    DECLR0CALLBACKMEMBER(int,  pfnR0GstGetPage,(PVM pVM, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys));
    … …  
    14241427    DECLR0CALLBACKMEMBER(int,  pfnR0GstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    14251428    DECLR0CALLBACKMEMBER(int,  pfnR0GstUnmapCR3,(PVM pVM));
    1426     R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnR0GstWriteHandlerCR3;
    14271429    /** @} */
    14281430
    … …  
    16271629    DECLR3CALLBACKMEMBER(int,  pfnR3GstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    16281630    DECLR3CALLBACKMEMBER(int,  pfnR3GstUnmapCR3,(PVM pVM));
    1629     R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnHCGstWriteHandlerCR3;
    1630     R3PTRTYPE(const char *)         pszHCGstWriteHandlerCR3;
     1631    R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnR3GstWriteHandlerCR3;
     1632    R3PTRTYPE(const char *)         pszR3GstWriteHandlerCR3;
     1633    R3PTRTYPE(PFNPGMR3PHYSHANDLER)  pfnR3GstPAEWriteHandlerCR3;
     1634    R3PTRTYPE(const char *)         pszR3GstPAEWriteHandlerCR3;
    16311635
    16321636    DECLGCCALLBACKMEMBER(int,  pfnGCGstGetPage,(PVM pVM, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys));
    … …  
    16381642    DECLGCCALLBACKMEMBER(int,  pfnGCGstUnmapCR3,(PVM pVM));
    16391643    GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstWriteHandlerCR3;
     1644    GCPTRTYPE(PFNPGMGCPHYSHANDLER)  pfnGCGstPAEWriteHandlerCR3;
    16401645
    16411646    DECLR0CALLBACKMEMBER(int,  pfnR0GstGetPage,(PVM pVM, RTGCUINTPTR GCPtr, uint64_t *pfFlags, PRTGCPHYS pGCPhys));
    … …  
    16461651    DECLR0CALLBACKMEMBER(int,  pfnR0GstMapCR3,(PVM pVM, RTGCPHYS GCPhysCR3));
    16471652    DECLR0CALLBACKMEMBER(int,  pfnR0GstUnmapCR3,(PVM pVM));
    1648     R0PTRTYPE(PFNPGMR0PHYSHANDLER)  pfnR0GstWriteHandlerCR3;
    16491653    /** @} */
    16501654
    … …  
    27652769            return pPD;
    27662770        AssertMsgFailed(("Impossible! rc=%d PDPE=%#llx\n", rc, CTXSUFF(pPGM->pGstPaePDPTR)->a[iPdPtr].u));
    2767         /* returning NIL_RTGCPHYS is ok if we assume it's just an invalid page of some kind emualted as all 0s. */
     2771        /* returning NIL_RTGCPHYS is ok if we assume it's just an invalid page of some kind emulated as all 0s. */
    27682772    }
    27692773    return NULL;
    … …  
    28582862        }
    28592863        AssertMsgFailed(("Impossible! rc=%d PDPE=%#llx\n", rc, CTXSUFF(pPGM->pGstPaePDPTR)->a[iPdPtr].u));
    2860         /* returning NIL_RTGCPHYS is ok if we assume it's just an invalid page of some kind emualted as all 0s. */
     2864        /* returning NIL_RTGCPHYS is ok if we assume it's just an invalid page of some kind emulated as all 0s. */
    28612865    }
    28622866    return NULL;

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

    r5629 r5662  
    2424PGM_BTH_DECL(int, Trap0eHandler)(PVM pVM, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault);
    2525PGM_BTH_DECL(int, InvalidatePage)(PVM pVM, RTGCUINTPTR GCPtrPage);
    26 PGM_BTH_DECL(int, SyncPage)(PVM pVM, VBOXPDE PdeSrc, RTGCUINTPTR GCPtrPage, unsigned cPages, unsigned uErr);
    27 PGM_BTH_DECL(int, CheckPageFault)(PVM pVM, uint32_t uErr, PSHWPDE pPdeDst, PVBOXPDE pPdeSrc, RTGCUINTPTR GCPtrPage);
    28 PGM_BTH_DECL(int, SyncPT)(PVM pVM, unsigned iPD, PVBOXPD pPDSrc, RTGCUINTPTR GCPtrPage);
     26PGM_BTH_DECL(int, SyncPage)(PVM pVM, GSTPDE PdeSrc, RTGCUINTPTR GCPtrPage, unsigned cPages, unsigned uErr);
     27PGM_BTH_DECL(int, CheckPageFault)(PVM pVM, uint32_t uErr, PSHWPDE pPdeDst, PGSTPDE pPdeSrc, RTGCUINTPTR GCPtrPage);
     28PGM_BTH_DECL(int, SyncPT)(PVM pVM, unsigned iPD, PGSTPD pPDSrc, RTGCUINTPTR GCPtrPage);
    2929PGM_BTH_DECL(int, VerifyAccessSyncPage)(PVM pVM, RTGCUINTPTR Addr, unsigned fPage, unsigned uErr);
    3030PGM_BTH_DECL(int, PrefetchPage)(PVM pVM, RTGCUINTPTR GCPtrPage);
    … …  
    5050PGM_BTH_DECL(int, Trap0eHandler)(PVM pVM, RTGCUINT uErr, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault)
    5151{
    52 #if (PGM_GST_TYPE == PGM_TYPE_32BIT ||  PGM_GST_TYPE == PGM_TYPE_REAL ||  PGM_GST_TYPE == PGM_TYPE_PROT) && PGM_SHW_TYPE != PGM_TYPE_AMD64
     52#if (PGM_GST_TYPE == PGM_TYPE_32BIT ||  PGM_GST_TYPE == PGM_TYPE_REAL ||  PGM_GST_TYPE == PGM_TYPE_PROT || PGM_GST_TYPE == PGM_TYPE_PAE) && PGM_SHW_TYPE != PGM_TYPE_AMD64
    5353
    5454# if PGM_SHW_TYPE != PGM_TYPE_32BIT && PGM_SHW_TYPE != PGM_TYPE_PAE
    … …  
    5656# endif
    5757
    58 # if PGM_SHW_TYPE == PGM_TYPE_PAE
     58# if PGM_SHW_TYPE == PGM_TYPE_PAE && PGM_GST_TYPE != PGM_TYPE_PAE
    5959    /*
    6060     * Hide the instruction fetch trap indicator for now.
    … …  
    7171     * Get PDs.
    7272     */
    73     int             rc;
     73    int       rc;
    7474# if PGM_WITH_PAGING(PGM_GST_TYPE)
    75     PVBOXPD         pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     75#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    7676    const unsigned  iPDSrc = (RTGCUINTPTR)pvFault >> GST_PD_SHIFT;
     77    PGSTPD          pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     78#  else /* PAE */
     79    unsigned        iPDSrc;
     80    PGSTPD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, (RTGCUINTPTR)pvFault, &iPDSrc);
     81#  endif
    7782# else
    78     PVBOXPD         pPDSrc = NULL;
     83    PGSTPD          pPDSrc = NULL;
    7984    const unsigned  iPDSrc = 0;
    8085# endif
    … …  
    124129     */
    125130# if PGM_WITH_PAGING(PGM_GST_TYPE)
    126     VBOXPDE PdeSrc = pPDSrc->a[iPDSrc];
     131    GSTPDE PdeSrc = pPDSrc->a[iPDSrc];
    127132# else
    128     VBOXPDE PdeSrc;
     133    GSTPDE PdeSrc;
    129134    PdeSrc.au32[0]      = 0; /* faked so we don't have to #ifdef everything */
    130135    PdeSrc.n.u1Present  = 1;
    … …  
    272277        if (    PdeSrc.b.u1Size
    273278            &&  (cr4 & X86_CR4_PSE))
    274             GCPhys = (PdeSrc.u & X86_PDE4M_PG_MASK)
    275                     | ((RTGCPHYS)pvFault & (X86_PAGE_4M_OFFSET_MASK ^ PAGE_OFFSET_MASK));
     279            GCPhys = (PdeSrc.u & GST_PDE4M_PG_MASK)
     280                    | ((RTGCPHYS)pvFault & (GST_BIG_PAGE_OFFSET_MASK ^ PAGE_OFFSET_MASK));
    276281        else
    277282        {
    278283            PVBOXPT pPTSrc;
    279284#  ifdef IN_GC
    280             rc = PGMGCDynMapGCPage(pVM, PdeSrc.u & X86_PDE_PG_MASK, (void **)&pPTSrc);
     285            rc = PGMGCDynMapGCPage(pVM, PdeSrc.u & GST_PDE_PG_MASK, (void **)&pPTSrc);
    281286#  else
    282             pPTSrc = (PVBOXPT)MMPhysGCPhys2HCVirt(pVM, PdeSrc.u & X86_PDE_PG_MASK, sizeof(*pPTSrc));
     287            pPTSrc = (PVBOXPT)MMPhysGCPhys2HCVirt(pVM, PdeSrc.u & GST_PDE_PG_MASK, sizeof(*pPTSrc));
    283288            if (pPTSrc == 0)
    284289                rc = VERR_PGM_INVALID_GC_PHYSICAL_ADDRESS;
    … …  
    286291            if (VBOX_SUCCESS(rc))
    287292            {
    288                 unsigned iPTESrc = ((RTGCUINTPTR)pvFault >> PAGE_SHIFT) & X86_PT_MASK;
     293                unsigned iPTESrc = ((RTGCUINTPTR)pvFault >> PAGE_SHIFT) & GST_PT_MASK;
    289294                if (pPTSrc->a[iPTESrc].n.u1Present)
    290                     GCPhys = pPTSrc->a[iPTESrc].u & X86_PTE_PG_MASK;
     295                    GCPhys = pPTSrc->a[iPTESrc].u & GST_PTE_PG_MASK;
    291296            }
    292297        }
    … …  
    847852     * Get the guest PD entry and calc big page.
    848853     */
    849     PVBOXPD         pPDSrc      = CTXSUFF(pVM->pgm.s.pGuestPD);
     854#  if PGM_GST_TYPE == PGM_TYPE_32BIT
     855    PX86PD          pPDSrc      = CTXSUFF(pVM->pgm.s.pGuestPD);
    850856    const unsigned  iPDSrc      = GCPtrPage >> GST_PD_SHIFT;
    851     VBOXPDE         PdeSrc      = pPDSrc->a[iPDSrc];
     857    GSTPDE          PdeSrc      = pPDSrc->a[iPDSrc];
     858#  else /* PAE */
     859    unsigned        iPDSrc;
     860    PX86PD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, GCPtrPage, &iPDSrc);
     861
     862    GSTPDE          PdeSrc;;
     863    PdeSrc.u      = pgmGstGetPaePDE(&pVM->pgm.s, GCPtrPage);
     864#  endif
     865
    852866    const uint32_t  cr4         = CPUMGetGuestCR4(pVM);
    853867    const bool      fIsBigPage  = PdeSrc.b.u1Size && (cr4 & X86_CR4_PSE);
    … …  
    967981            /* Before freeing the page, check if anything really changed. */
    968982            PPGMPOOLPAGE    pShwPage = pgmPoolGetPageByHCPhys(pVM, PdeDst.u & SHW_PDE_PG_MASK);
    969             RTGCPHYS        GCPhys = PdeSrc.u & X86_PDE4M_PG_MASK;
     983            RTGCPHYS        GCPhys = PdeSrc.u & GST_PDE4M_PG_MASK;
    970984#  if PGM_SHW_TYPE != PGM_TYPE_32BIT
    971985            GCPhys |= GCPtrPage & (1 << X86_PD_PAE_SHIFT);
    … …  
    11661180 * @remark  Not used for 2/4MB pages!
    11671181 */
    1168 DECLINLINE(void) PGM_BTH_NAME(SyncPageWorker)(PVM pVM, PSHWPTE pPteDst, VBOXPDE PdeSrc, VBOXPTE PteSrc, PPGMPOOLPAGE pShwPage, unsigned iPTDst)
     1182DECLINLINE(void) PGM_BTH_NAME(SyncPageWorker)(PVM pVM, PSHWPTE pPteDst, GSTPDE PdeSrc, VBOXPTE PteSrc, PPGMPOOLPAGE pShwPage, unsigned iPTDst)
    11691183{
    11701184    if (PteSrc.n.u1Present)
    … …  
    11741188         */
    11751189        PPGMPAGE pPage;
    1176         int rc = pgmPhysGetPageEx(&pVM->pgm.s, PteSrc.u & X86_PTE_PG_MASK, &pPage);
     1190        int rc = pgmPhysGetPageEx(&pVM->pgm.s, PteSrc.u & GST_PTE_PG_MASK, &pPage);
    11771191        if (VBOX_SUCCESS(rc))
    11781192        {
    … …  
    12981312 * @param   uErr        Fault error (X86_TRAP_PF_*).
    12991313 */
    1300 PGM_BTH_DECL(int, SyncPage)(PVM pVM, VBOXPDE PdeSrc, RTGCUINTPTR GCPtrPage, unsigned cPages, unsigned uErr)
     1314PGM_BTH_DECL(int, SyncPage)(PVM pVM, GSTPDE PdeSrc, RTGCUINTPTR GCPtrPage, unsigned cPages, unsigned uErr)
    13011315{
    13021316    LogFlow(("SyncPage: GCPtrPage=%VGv cPages=%d uErr=%#x\n", GCPtrPage, cPages, uErr));
    … …  
    13141328    Assert(GCPtrPage < _4G); //???
    13151329# endif
    1316     STAM_COUNTER_INC(&pVM->pgm.s.StatGCSyncPagePD[(GCPtrPage >> X86_PD_SHIFT) & X86_PD_MASK]);
     1330    STAM_COUNTER_INC(&pVM->pgm.s.StatGCSyncPagePD[(GCPtrPage >> X86_PD_SHIFT) & GST_PD_MASK]);
    13171331    Assert(PdeSrc.n.u1Present);
    13181332    Assert(cPages);
    … …  
    13711385                 */
    13721386                PVBOXPT pPTSrc;
    1373                 int rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & X86_PDE_PG_MASK, &pPTSrc);
     1387                int rc = PGM_GCPHYS_2_PTR(pVM, PdeSrc.u & GST_PDE_PG_MASK, &pPTSrc);
    13741388                if (VBOX_SUCCESS(rc))
    13751389                {
    … …  
    14011415                            {
    14021416                                VBOXPTE PteSrc = pPTSrc->a[offPTSrc + iPTDst];
    1403                                 RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(X86_PT_MASK << X86_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
     1417                                RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(GST_PT_MASK << GST_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
    14041418                                NOREF(GCPtrCurPage);
    14051419#ifndef IN_RING0
    … …  
    14301444# endif /* PGM_SYNC_N_PAGES */
    14311445                    {
    1432                         const unsigned iPTSrc = (GCPtrPage >> X86_PT_SHIFT) & X86_PT_MASK;
     1446                        const unsigned iPTSrc = (GCPtrPage >> GST_PT_SHIFT) & GST_PT_MASK;
    14331447                        VBOXPTE PteSrc = pPTSrc->a[iPTSrc];
    14341448                        const unsigned iPTDst = (GCPtrPage >> SHW_PT_SHIFT) & SHW_PT_MASK;
    … …  
    14551469                 */
    14561470                /* Calculate the GC physical address of this 4KB shadow page. */
    1457                 RTGCPHYS GCPhys = (PdeSrc.u & X86_PDE4M_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtrPage & X86_PAGE_4M_OFFSET_MASK);
     1471                RTGCPHYS GCPhys = (PdeSrc.u & X86_PDE4M_PAE_PG_MASK) | ((RTGCUINTPTR)GCPtrPage & GST_BIG_PAGE_OFFSET_MASK);
    14581472                /* Find ram range. */
    14591473                PPGMPAGE pPage;
    … …  
    15891603                VBOXPTE PteSrc;
    15901604
    1591                 RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(X86_PT_MASK << X86_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
     1605                RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(GST_PT_MASK << GST_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
    15921606
    15931607                /* Fake the page table entry */
    … …  
    16161630        VBOXPTE PteSrc;
    16171631        const unsigned iPTDst = (GCPtrPage >> SHW_PT_SHIFT) & SHW_PT_MASK;
    1618         RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(X86_PT_MASK << X86_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
     1632        RTGCUINTPTR GCPtrCurPage = ((RTGCUINTPTR)GCPtrPage & ~(RTGCUINTPTR)(GST_PT_MASK << GST_PT_SHIFT)) | ((offPTSrc + iPTDst) << PAGE_SHIFT);
    16191633
    16201634        /* Fake the page table entry */
    … …  
    16591673 * @param   GCPtrPage   Guest context page address.
    16601674 */
    1661 PGM_BTH_DECL(int, CheckPageFault)(PVM pVM, uint32_t uErr, PSHWPDE pPdeDst, PVBOXPDE pPdeSrc, RTGCUINTPTR GCPtrPage)
     1675PGM_BTH_DECL(int, CheckPageFault)(PVM pVM, uint32_t uErr, PSHWPDE pPdeDst, PGSTPDE pPdeSrc, RTGCUINTPTR GCPtrPage)
    16621676{
    16631677    STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat, DirtyBitTracking), a);
    … …  
    16691683    if (    (uErr & X86_TRAP_PF_RSVD)
    16701684        ||  !pPdeSrc->n.u1Present
     1685#if PGM_GST_TYPE == PGM_TYPE_PAE
     1686        ||  ((uErr & X86_TRAP_PF_ID) && !pPdeSrc->n.u1NoExecute)
     1687#endif
    16711688        ||  ((uErr & X86_TRAP_PF_RW) && !pPdeSrc->n.u1Write)
    16721689        ||  ((uErr & X86_TRAP_PF_US) && !pPdeSrc->n.u1User) )
    … …  
    16921709                * Map the guest page table.
    16931710                */
    1694                 PVBOXPT pPTSrc;
    1695                 int rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & X86_PDE_PG_MASK, &pPTSrc);
     1711                PGSTPT pPTSrc;
     1712                int rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & GST_PDE_PG_MASK, &pPTSrc);
    16961713                if (VBOX_SUCCESS(rc))
    16971714                {
    1698                     PVBOXPTE        pPteSrc = &pPTSrc->a[(GCPtrPage >> PAGE_SHIFT) & X86_PT_MASK];
    1699                     const VBOXPTE   PteSrc = *pPteSrc;
     1715                    PGSTPTE         pPteSrc = &pPTSrc->a[(GCPtrPage >> PAGE_SHIFT) & GST_PT_MASK];
     1716                    const GSTPTE    PteSrc = *pPteSrc;
    17001717                    if (pPteSrc->n.u1Present)
    17011718                        TRPMSetErrorCode(pVM, uErr | X86_TRAP_PF_P); /* page-level protection violation */
    … …  
    17461763     * Map the guest page table.
    17471764     */
    1748     PVBOXPT pPTSrc;
    1749     int rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & X86_PDE_PG_MASK, &pPTSrc);
     1765    PGSTPT pPTSrc;
     1766    int rc = PGM_GCPHYS_2_PTR(pVM, pPdeSrc->u & GST_PDE_PG_MASK, &pPTSrc);
    17501767    if (VBOX_SUCCESS(rc))
    17511768    {
    … …  
    17531770         * Real page fault?
    17541771         */
    1755         PVBOXPTE        pPteSrc = &pPTSrc->a[(GCPtrPage >> PAGE_SHIFT) & X86_PT_MASK];
    1756         const VBOXPTE   PteSrc = *pPteSrc;
     1772        PGSTPTE        pPteSrc = &pPTSrc->a[(GCPtrPage >> PAGE_SHIFT) & GST_PT_MASK];
     1773        const GSTPTE   PteSrc = *pPteSrc;
    17571774        if (    !PteSrc.n.u1Present
     1775#if PGM_GST_TYPE == PGM_TYPE_PAE
     1776            ||  ((uErr & X86_TRAP_PF_ID) && !PteSrc.n.u1NoExecute)
     1777#endif
    17581778            ||  ((uErr & X86_TRAP_PF_RW) && !PteSrc.n.u1Write)
    17591779            ||  ((uErr & X86_TRAP_PF_US) && !PteSrc.n.u1User)
    … …  
    18221842                        LogFlow(("DIRTY page trap addr=%VGv\n", GCPtrPage));
    18231843#  ifdef VBOX_STRICT
    1824                         PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, pPteSrc->u & X86_PTE_PG_MASK);
     1844                        PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, pPteSrc->u & GST_PTE_PG_MASK);
    18251845                        if (pPage)
    18261846                            AssertMsg(!(pPage->HCPhys & (MM_RAM_FLAGS_PHYSICAL_ALL | MM_RAM_FLAGS_VIRTUAL_ALL | MM_RAM_FLAGS_PHYSICAL_WRITE | MM_RAM_FLAGS_VIRTUAL_WRITE)), /** @todo PAGE FLAGS */
    … …  
    18881908 * @param   GCPtrPage   GC Pointer of the page that caused the fault
    18891909 */
    1890 PGM_BTH_DECL(int, SyncPT)(PVM pVM, unsigned iPDSrc, PVBOXPD pPDSrc, RTGCUINTPTR GCPtrPage)
     1910PGM_BTH_DECL(int, SyncPT)(PVM pVM, unsigned iPDSrc, PGSTPD pPDSrc, RTGCUINTPTR GCPtrPage)
    18911911{
    18921912    STAM_PROFILE_START(&pVM->pgm.s.CTXMID(Stat,SyncPT), a);
    … …  
    22622282    Assert(!PdeDst.n.u1Present); /* We're only supposed to call SyncPT on PDE!P and conflicts.*/
    22632283
    2264     VBOXPDE PdeSrc;
     2284    GSTPDE PdeSrc;
    22652285    PdeSrc.au32[0]      = 0; /* faked so we don't have to #ifdef everything */
    22662286    PdeSrc.n.u1Present  = 1;
    … …  
    23292349    int             rc      = VINF_SUCCESS;
    23302350# if PGM_WITH_PAGING(PGM_GST_TYPE)
    2331     PVBOXPD         pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     2351#  if PGM_GST_TYPE == PGM_TYPE_32BIT
    23322352    const unsigned  iPDSrc = (RTGCUINTPTR)GCPtrPage >> GST_PD_SHIFT;
     2353    PGSTPD          pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     2354#  else /* PAE */
     2355    unsigned        iPDSrc
     2356    PGSTPD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, GCPtrPage, &iPDSrc);
     2357#  endif
    23332358# else
    2334     PVBOXPD         pPDSrc = NULL;
     2359    PGSTPD          pPDSrc = NULL;
    23352360    const unsigned  iPDSrc = 0;
    23362361# endif
    23372362
    23382363# if PGM_WITH_PAGING(PGM_GST_TYPE)
    2339     const VBOXPDE PdeSrc = pPDSrc->a[iPDSrc];
     2364    const GSTPDE PdeSrc = pPDSrc->a[iPDSrc];
    23402365# else
    2341     VBOXPDE PdeSrc;
     2366    GSTPDE PdeSrc;
    23422367    PdeSrc.au32[0]      = 0; /* faked so we don't have to #ifdef everything */
    23432368    PdeSrc.n.u1Present  = 1;
    … …  
    23542379    {
    23552380# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    2356         const X86PDE    PdeDst = pVM->pgm.s.CTXMID(p,32BitPD)->a[GCPtrPage >> X86_PD_SHIFT];
     2381        const X86PDE    PdeDst = pVM->pgm.s.CTXMID(p,32BitPD)->a[GCPtrPage >> SHW_PD_SHIFT];
    23572382# else
    2358         const X86PDEPAE PdeDst = pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[GCPtrPage >> X86_PD_PAE_SHIFT];
     2383        const X86PDEPAE PdeDst = pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[GCPtrPage >> SHW_PD_SHIFT];
    23592384# endif
    23602385        if (!(PdeDst.u & PGM_PDFLAGS_MAPPING))
    … …  
    23992424    LogFlow(("VerifyAccessSyncPage: GCPtrPage=%VGv fPage=%#x uErr=%#x\n", GCPtrPage, fPage, uErr));
    24002425
    2401 #if (PGM_GST_TYPE == PGM_TYPE_32BIT ||  PGM_GST_TYPE == PGM_TYPE_REAL ||  PGM_GST_TYPE == PGM_TYPE_PROT) && PGM_SHW_TYPE != PGM_TYPE_AMD64
     2426#if (PGM_GST_TYPE == PGM_TYPE_32BIT ||  PGM_GST_TYPE == PGM_TYPE_REAL ||  PGM_GST_TYPE == PGM_TYPE_PROT || PGM_GST_TYPE == PGM_TYPE_PAE) && PGM_SHW_TYPE != PGM_TYPE_AMD64
    24022427
    24032428# if PGM_SHW_TYPE != PGM_TYPE_32BIT && PGM_SHW_TYPE != PGM_TYPE_PAE
    … …  
    24192444     * Get guest PD and index.
    24202445     */
    2421     unsigned    iPDSrc = GCPtrPage >> GST_PD_SHIFT;
    2422     PVBOXPD     pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     2446
     2447# if PGM_WITH_PAGING(PGM_GST_TYPE)
     2448#  if PGM_GST_TYPE == PGM_TYPE_32BIT
     2449    const unsigned  iPDSrc = (RTGCUINTPTR)GCPtrPage >> GST_PD_SHIFT;
     2450    PGSTPD          pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     2451#  else /* PAE */
     2452    unsigned        iPDSrc;
     2453    PGSTPD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, GCPtrPage, &iPDSrc);
     2454#  endif
     2455# else
     2456    PGSTPD          pPDSrc = NULL;
     2457    const unsigned  iPDSrc = 0;
     2458# endif
    24232459    int         rc = VINF_SUCCESS;
    24242460
    … …  
    24272463     */
    24282464# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    2429     PX86PDE     pPdeDst = &pVM->pgm.s.CTXMID(p,32BitPD)->a[GCPtrPage >> X86_PD_SHIFT];
     2465    PX86PDE     pPdeDst = &pVM->pgm.s.CTXMID(p,32BitPD)->a[GCPtrPage >> SHW_PD_SHIFT];
    24302466# else
    2431     PX86PDEPAE  pPdeDst = &pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[GCPtrPage >> X86_PD_PAE_SHIFT];
     2467    PX86PDEPAE  pPdeDst = &pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[GCPtrPage >> SHW_PD_SHIFT];
    24322468# endif
    24332469    if (!pPdeDst->n.u1Present)
    … …  
    24462482    else
    24472483    {
    2448         VBOXPDE PdeSrc = pPDSrc->a[iPDSrc];
     2484        GSTPDE PdeSrc = pPDSrc->a[iPDSrc];
    24492485#else
    24502486    {
    2451         VBOXPDE PdeSrc;
     2487        GSTPDE PdeSrc;
    24522488        PdeSrc.au32[0]      = 0; /* faked so we don't have to #ifdef everything */
    24532489        PdeSrc.n.u1Present  = 1;
    … …  
    24952531 * @param   cr4         The current guest cr4 value.
    24962532 */
    2497 DECLINLINE(PGMPOOLKIND) PGM_BTH_NAME(CalcPageKind)(const VBOXPDE *pPdeSrc, uint32_t cr4)
     2533DECLINLINE(PGMPOOLKIND) PGM_BTH_NAME(CalcPageKind)(const GSTPDE *pPdeSrc, uint32_t cr4)
    24982534{
    24992535    if (!pPdeSrc->n.u1Size || !(cr4 & X86_CR4_PSE))
    … …  
    25952631    PX86PDEPAE  pPDEDst = &pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[0];
    25962632#  endif
    2597     PVBOXPD     pPDSrc = pVM->pgm.s.CTXSUFF(pGuestPD);
     2633
     2634# if PGM_GST_TYPE == PGM_TYPE_32BIT
     2635    PGSTPD          pPDSrc = CTXSUFF(pVM->pgm.s.pGuestPD);
     2636# else /* PAE */
     2637    PGSTPD          pPDSrc = pgmGstGetPaePDPtr(&pVM->pgm.s, 0);
     2638# endif
    25982639
    25992640    Assert(pPDSrc);
    … …  
    26142655    {
    26152656        pMapping      = pVM->pgm.s.CTXALLSUFF(pMappings);
    2616         iPdNoMapping  = (pMapping) ? pMapping->GCPtr >> X86_PD_SHIFT : ~0U;
     2657        iPdNoMapping  = (pMapping) ? pMapping->GCPtr >> X86_PD_SHIFT : ~0U;     /** PAE todo */
    26172658    }
    26182659    else
    … …  
    26292670        Assert(&pVM->pgm.s.CTXMID(ap,PaePDs)[iPD * 2 / 512]->a[iPD * 2 % 512] == pPDEDst);
    26302671#  endif
    2631         register VBOXPDE PdeSrc = pPDSrc->a[iPD];
     2672        register GSTPDE PdeSrc = pPDSrc->a[iPD];
    26322673        if (    PdeSrc.n.u1Present
    26332674            &&  (PdeSrc.n.u1User || fRawR0Enabled))

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

    r4977 r5662  
    427427    pVM->pgm.s.pGstPaePDPTRHC = 0;
    428428    pVM->pgm.s.pGstPaePDPTRGC = 0;
     429    /** PAE todo: pVM->pgm.s.apGstPaePDsHC? -> unmap?? */
     430    AssertFailed();
    429431
    430432#elif PGM_GST_TYPE == PGM_TYPE_AMD64
    … …  
    495497
    496498#if PGM_GST_TYPE == PGM_TYPE_PAE
    497     AssertFatalFailed();
    498 # if 0 /* later */
    499499    /*
    500500     * Do the 4 PDs.
    … …  
    502502    for (unsigned i = 0; i < 4; i++)
    503503    {
    504         if (pVM->pgm.s.pGstPaePDPTRHC->a[i].n.u1Present)
     504        if (CTXSUFF(pVM->pgm.s.pGstPaePDPTR)->a[i].n.u1Present)
    505505        {
    506             RTGCPHYS GCPhys = pVM->pgm.s.pGstPaePDPTRHC->a[i].u & X86_PDPE_PG_MASK;
     506            RTGCPHYS GCPhys = CTXSUFF(pVM->pgm.s.pGstPaePDPTR)->a[i].u & X86_PDPE_PG_MASK;
     507# ifndef PGMPOOL_WITH_MIXED_PT_CR3
    507508            if (pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] != GCPhys)
    508509            {
    … …  
    510511                    rc = PGMHandlerPhysicalModify(pVM, pVM->pgm.s.aGCPhysGstPaePDsMonitored[i], GCPhys, GCPhys + PAGE_SIZE - 1);
    511512                else
    512                     rc = PGMR3HandlerPhysicalRegister(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE, GCPhys, GCPhys + PAGE_SIZE - 1,
    513                                                       pgmR3GstPaePDWriteHandler, NULL,
    514                                                       NULL, "pgmGCGstPaePDWriteHandler", 0,
    515                                                       "Guest PD write access handler");
     513                    rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE, GCPhys, GCPhys + PAGE_SIZE - 1,
     514                                                      pVM->pgm.s.pfnR3GstPAEWriteHandlerCR3, 0,
     515                                                      0, 0,
     516                                                      pVM->pgm.s.pfnGCGstPAEWriteHandlerCR3, 0,
     517                                                      pVM->pgm.s.pszR3GstPAEWriteHandlerCR3);
    516518                if (VBOX_SUCCESS(rc))
    517519                    pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] = GCPhys;
    518520            }
     521# else  /* PGMPOOL_WITH_MIXED_PT_CR3 */
     522            /** PAE todo */
     523            AssertFailed();
     524            rc = pgmPoolMonitorMonitorCR3(pVM->pgm.s.CTXSUFF(pPool),
     525                                             pVM->pgm.s.enmShadowMode == PGMMODE_PAE
     526                                          || pVM->pgm.s.enmShadowMode == PGMMODE_PAE_NX
     527                                          ? PGMPOOL_IDX_PAE_PD
     528                                          : PGMPOOL_IDX_PD,
     529                                          GCPhys);
     530# endif /* PGMPOOL_WITH_MIXED_PT_CR3 */
     531            if (VBOX_FAILURE(rc))
     532            {
     533                AssertMsgFailed(("PGMHandlerPhysicalModify/PGMR3HandlerPhysicalRegister failed, rc=%Rrc GCPhysGstCR3Monitored=%RGp GCPhysCR3=%RGp\n",
     534                                 rc, pVM->pgm.s.aGCPhysGstPaePDsMonitored[i], GCPhys));
     535                return rc;
     536            }
     537            pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] = GCPhys;
    519538        }
    520539        else if (pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] != NIL_RTGCPHYS)
    … …  
    525544        }
    526545    }
    527 # endif
    528546#endif /* PGM_GST_TYPE == PGM_TYPE_PAE */
    529547
    … …  
    576594        if (pVM->pgm.s.aGCPhysGstPaePDsMonitored[i] != NIL_RTGCPHYS)
    577595        {
     596# ifndef PGMPOOL_WITH_MIXED_PT_CR3
    578597            int rc2 = PGMHandlerPhysicalDeregister(pVM, pVM->pgm.s.aGCPhysGstPaePDsMonitored[i]);
     598# else /* PGMPOOL_WITH_MIXED_PT_CR3 */
     599            /** PAE todo */
     600            AssertFailed();
     601            int rc2 = pgmPoolMonitorUnmonitorCR3(pVM->pgm.s.CTXSUFF(pPool),
     602                                                    pVM->pgm.s.enmShadowMode == PGMMODE_PAE
     603                                                 || pVM->pgm.s.enmShadowMode == PGMMODE_PAE_NX
     604                                                 ? PGMPOOL_IDX_PAE_PD
     605                                                 : PGMPOOL_IDX_PD);
     606# endif /* PGMPOOL_WITH_MIXED_PT_CR3 */
    579607            AssertRC(rc2);
    580608            if (VBOX_FAILURE(rc2))
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