VirtualBox

儲存庫 vbox 的更動 9893


忽略:
時間撮記:
2008-6-24 下午03:56:57 (16 年 以前)
作者:
vboxsync
訊息:

Attempt to fix PAE (can't verify now).
AMD64 paging updates.

位置:
trunk/src/VBox/VMM/VMMAll
檔案:
修改 5 筆資料

圖例:

未更動
新增
刪除

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

    r9890 r9893  
    859859        &&  !(pPdpe->u & X86_PDPE_PG_MASK))
    860860    {
    861         PX86PML4E pPml4eGst = &pPGM->pGstPaePML4HC->a[iPml4e];       
     861        PX86PML4E pPml4eGst = &pPGM->pGstPaePML4HC->a[iPml4e];
    862862        PX86PDPT  pPdptGst;
    863863        rc = PGM_GCPHYS_2_PTR(pVM, pPml4eGst->u & X86_PML4E_PG_MASK, &pPdptGst);

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

    r9890 r9893  
    140140#  if PGM_GST_TYPE == PGM_TYPE_PAE
    141141    /* Did we mark the PDPT as not present in SyncCR3? */
    142     unsigned iPDPTE = ((RTGCUINTPTR)pvFault >> SHW_PDPT_SHIFT) & SHW_PDPT_MASK;
    143     if (!pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPDPTE].n.u1Present)
    144         pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPDPTE].n.u1Present = 1;
     142    unsigned iPdpte = ((RTGCUINTPTR)pvFault >> SHW_PDPT_SHIFT) & SHW_PDPT_MASK;
     143    if (!pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].n.u1Present)
     144        pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].n.u1Present = 1;
    145145
    146146#  endif
    … …  
    874874    PX86PDE         pPdeDst   = &pVM->pgm.s.CTXMID(p,32BitPD)->a[iPDDst];
    875875# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    876     const unsigned  iPDDst    = GCPtrPage >> SHW_PD_SHIFT;
    877     const unsigned  iPdPte    = (GCPtrPage >> X86_PDPT_SHIFT);   /* no mask; flat index into the 2048 entry array. */
     876    const unsigned  iPDDst    = GCPtrPage >> SHW_PD_SHIFT;      /* no mask; flat index into the 2048 entry array. */
     877    const unsigned  iPdpte    = (GCPtrPage >> X86_PDPT_SHIFT);
    878878    PX86PDEPAE      pPdeDst   = &pVM->pgm.s.CTXMID(ap,PaePDs[0])->a[iPDDst];
    879879    PX86PDPT        pPdptDst  = pVM->pgm.s.CTXMID(p,PaePDPT);
    … …  
    883883
    884884    const unsigned  iPml4e    = (GCPtrPage >> X86_PML4_SHIFT) & X86_PML4_MASK;
    885     const unsigned  iPdPte    = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
     885    const unsigned  iPdpte    = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
    886886    const unsigned  iPDDst    = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
    887887    PX86PDPAE       pPDDst;
    … …  
    893893        AssertMsg(rc == VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT || rc == VERR_PAGE_MAP_LEVEL4_NOT_PRESENT, ("Unexpected rc=%Vrc\n", rc));
    894894        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     895        if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
     896            PGM_INVL_GUEST_TLBS();
    895897        return VINF_SUCCESS;
    896898    }
    … …  
    898900
    899901    PX86PDEPAE  pPdeDst  = &pPDDst->a[iPDDst];
    900     PX86PDPE    pPdpeDst = &pPdptDst->a[iPdPte];
     902    PX86PDPE    pPdpeDst = &pPdptDst->a[iPdpte];
     903
     904    if (!pPdpeDst->n.u1Present)
     905    {
     906        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePageSkipped));
     907        if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
     908            PGM_INVL_GUEST_TLBS();
     909        return VINF_SUCCESS;
     910    }
     911
    901912# endif
    902913
    … …  
    932943# endif
    933944
    934     const uint32_t  cr4         = CPUMGetGuestCR4(pVM);
    935945# if PGM_GST_TYPE == PGM_TYPE_AMD64
    936946    const bool      fIsBigPage  = PdeSrc.b.u1Size;
    937947# else
    938     const bool      fIsBigPage  = PdeSrc.b.u1Size && (cr4 & X86_CR4_PSE);
     948    const bool      fIsBigPage  = PdeSrc.b.u1Size && (CPUMGetGuestCR4(pVM) & X86_CR4_PSE);
    939949# endif
    940950
    … …  
    950960            && fIsBigPage
    951961            && PdeSrc.b.u1Global
    952             && (cr4 & X86_CR4_PGE)
    953962           )
    954963       )
    … …  
    963972
    964973# if PGM_GST_TYPE == PGM_TYPE_AMD64
     974    PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
     975
    965976    /* Fetch the pgm pool shadow descriptor. */
    966977    PPGMPOOLPAGE pShwPdpt = pgmPoolGetPageByHCPhys(pVM, pPml4eDst->u & X86_PML4E_PG_MASK);
    967978    Assert(pShwPdpt);
    968 # endif
    969 
    970 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    971     PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
    972979
    973980    /* Fetch the pgm pool shadow descriptor. */
    974     PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdPte].u & SHW_PDPE_PG_MASK);
     981    PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdpte].u & SHW_PDPE_PG_MASK);
    975982    Assert(pShwPde);
    976 # endif
    977 
    978 # if PGM_GST_TYPE == PGM_TYPE_AMD64
    979     Assert(pPml4eDst->n.u1Present && pPml4eDst->u & SHW_PDPT_MASK);
    980     if (pPml4eSrc->n.u1Present)
    981     {
    982         if (   pPml4eSrc->n.u1User != pPml4eDst->n.u1User
    983             || (!pPml4eSrc->n.u1Write && pPml4eDst->n.u1Write))
    984         {
    985             /*
    986              * Mark not present so we can resync the PML4E when it's used.
    987              */
    988             LogFlow(("InvalidatePage: Out-of-sync PML4E at %VGv Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
    989                      GCPtrPage, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
    990             pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
    991             pPml4eDst->u = 0;
    992             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
    993             PGM_INVL_GUEST_TLBS();
    994         }
    995         else if (!pPml4eSrc->n.u1Accessed)
    996         {
    997             /*
    998              * Mark not present so we can set the accessed bit.
    999              */
    1000             LogFlow(("InvalidatePage: Out-of-sync PML4E (A) at %VGv Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
    1001                      GCPtrPage, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
    1002             pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
    1003             pPml4eDst->u = 0;
    1004             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
    1005             PGM_INVL_GUEST_TLBS();
    1006         }
    1007     }
    1008     else
    1009     {
    1010         LogFlow(("InvalidatePage: Out-of-sync PML4E (P) at %VGv Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
    1011                     GCPtrPage, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
    1012         pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
    1013         pPml4eDst->u = 0;
    1014         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
    1015         PGM_INVL_PG(GCPtrPage);
    1016         return VINF_SUCCESS;
    1017     }
     983
     984    Assert(pPml4eDst->n.u1Present && (pPml4eDst->u & SHW_PDPT_MASK));
    1018985    RTGCPHYS GCPhysPdpt = pPml4eSrc->u & X86_PML4E_PG_MASK;
    1019986
    1020     /* Check if the PML4 entry has changed. */
    1021     if (pShwPdpt->GCPhys != GCPhysPdpt)
    1022     {
    1023         LogFlow(("InvalidatePage: Out-of-sync PML4E (GCPhys) at %VGv %VGp vs %VGp Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
     987    if (    !pPml4eSrc->n.u1Present
     988        ||  pShwPdpt->GCPhys != GCPhysPdpt)
     989    {
     990        LogFlow(("InvalidatePage: Out-of-sync PML4E (P/GCPhys) at %VGv GCPhys=%VGp vs %VGp Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
    1024991                    GCPtrPage, pShwPdpt->GCPhys, GCPhysPdpt, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
    1025992        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
    1026993        pPml4eDst->u = 0;
    1027994        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
    1028         PGM_INVL_PG(GCPtrPage);
     995        PGM_INVL_GUEST_TLBS();
    1029996        return VINF_SUCCESS;
    1030997    }
    1031 
    1032 
     998    if (   pPml4eSrc->n.u1User != pPml4eDst->n.u1User
     999        || (!pPml4eSrc->n.u1Write && pPml4eDst->n.u1Write))
     1000    {
     1001        /*
     1002         * Mark not present so we can resync the PML4E when it's used.
     1003         */
     1004        LogFlow(("InvalidatePage: Out-of-sync PML4E at %VGv Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
     1005                 GCPtrPage, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
     1006        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
     1007        pPml4eDst->u = 0;
     1008        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1009        PGM_INVL_GUEST_TLBS();
     1010    }
     1011    else if (!pPml4eSrc->n.u1Accessed)
     1012    {
     1013        /*
     1014         * Mark not present so we can set the accessed bit.
     1015         */
     1016        LogFlow(("InvalidatePage: Out-of-sync PML4E (A) at %VGv Pml4eSrc=%RX64 Pml4eDst=%RX64\n",
     1017                 GCPtrPage, (uint64_t)pPml4eSrc->u, (uint64_t)pPml4eDst->u));
     1018        pgmPoolFreeByPage(pPool, pShwPdpt, pVM->pgm.s.pShwAmd64CR3->idx, iPml4e);
     1019        pPml4eDst->u = 0;
     1020        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
     1021        PGM_INVL_GUEST_TLBS();
     1022    }
     1023
     1024    /* Check if the PDPT entry has changed. */
    10331025    Assert(pPdpeDst->n.u1Present && pPdpeDst->u & SHW_PDPT_MASK);
    1034     if (PdpeSrc.n.u1Present)
    1035     {
    1036         if (   PdpeSrc.lm.u1User != pPdpeDst->lm.u1User
    1037             || (!PdpeSrc.lm.u1Write && pPdpeDst->lm.u1Write))
    1038         {
    1039             /*
    1040              * Mark not present so we can resync the PDPTE when it's used.
    1041              */
    1042             LogFlow(("InvalidatePage: Out-of-sync PDPE at %VGv PdpeSrc=%RX64 PdpeDst=%RX64\n",
    1043                      GCPtrPage, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    1044             pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdPte);
    1045             pPdpeDst->u = 0;
    1046             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
    1047             PGM_INVL_GUEST_TLBS();
    1048         }
    1049         else if (!PdpeSrc.lm.u1Accessed)
    1050         {
    1051             /*
    1052              * Mark not present so we can set the accessed bit.
    1053              */
    1054             LogFlow(("InvalidatePage: Out-of-sync PDPE (A) at %VGv PdpeSrc=%RX64 PdpeDst=%RX64\n",
    1055                      GCPtrPage, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    1056             pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdPte);
    1057             pPdpeDst->u = 0;
    1058             STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
    1059             PGM_INVL_GUEST_TLBS();
    1060         }
    1061     }
    1062     else
    1063     {
    1064         LogFlow(("InvalidatePage: Out-of-sync PDPE (P) at %VGv PdpeSrc=%RX64 PdpeDst=%RX64\n",
    1065                     GCPtrPage, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    1066         pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdPte);
     1026    RTGCPHYS GCPhysPd = PdpeSrc.u & GST_PDPE_PG_MASK;
     1027    if (    !PdpeSrc.n.u1Present
     1028        ||  pShwPde->GCPhys != GCPhysPd)
     1029    {
     1030        LogFlow(("InvalidatePage: Out-of-sync PDPE (P/GCPhys) at %VGv GCPhys=%VGp vs %VGp PdpeSrc=%RX64 PdpeDst=%RX64\n",
     1031                    GCPtrPage, pShwPde->GCPhys, GCPhysPd, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
     1032        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
    10671033        pPdpeDst->u = 0;
    10681034        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
    1069         PGM_INVL_PG(GCPtrPage);
     1035        PGM_INVL_GUEST_TLBS();
    10701036        return VINF_SUCCESS;
    10711037    }
    1072     RTGCPHYS GCPhysPd = PdpeSrc.u & GST_PDPE_PG_MASK;
    1073 
    1074     /* Check if the PDPT entry has changed. */
    1075     if (pShwPde->GCPhys != GCPhysPd)
    1076     {
    1077         LogFlow(("InvalidatePage: Out-of-sync PDPE (GCPhys) at %VGv %VGp vs %VGp PdpeSrc=%RX64 PdpeDst=%RX64\n",
    1078                     GCPtrPage, pShwPde->GCPhys, GCPhysPd, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    1079         pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdPte);
     1038    if (   PdpeSrc.lm.u1User != pPdpeDst->lm.u1User
     1039        || (!PdpeSrc.lm.u1Write && pPdpeDst->lm.u1Write))
     1040    {
     1041        /*
     1042         * Mark not present so we can resync the PDPTE when it's used.
     1043         */
     1044        LogFlow(("InvalidatePage: Out-of-sync PDPE at %VGv PdpeSrc=%RX64 PdpeDst=%RX64\n",
     1045                 GCPtrPage, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
     1046        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
    10801047        pPdpeDst->u = 0;
    1081         STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNPs));
    1082         PGM_INVL_PG(GCPtrPage);
    1083         return VINF_SUCCESS;
    1084     }
    1085 # endif
     1048        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDOutOfSync));
     1049        PGM_INVL_GUEST_TLBS();
     1050    }
     1051    else if (!PdpeSrc.lm.u1Accessed)
     1052    {
     1053        /*
     1054         * Mark not present so we can set the accessed bit.
     1055         */
     1056        LogFlow(("InvalidatePage: Out-of-sync PDPE (A) at %VGv PdpeSrc=%RX64 PdpeDst=%RX64\n",
     1057                 GCPtrPage, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
     1058        pgmPoolFreeByPage(pPool, pShwPde, pShwPdpt->idx, iPdpte);
     1059        pPdpeDst->u = 0;
     1060        STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,InvalidatePagePDNAs));
     1061        PGM_INVL_GUEST_TLBS();
     1062    }
     1063# endif /* PGM_GST_TYPE != PGM_TYPE_AMD64 */
     1064
     1065# if PGM_GST_TYPE == PGM_TYPE_PAE
     1066
     1067# endif
     1068
    10861069
    10871070    /*
    … …  
    11081091            LogFlow(("InvalidatePage: Out-of-sync at %VGp PdeSrc=%RX64 PdeDst=%RX64\n",
    11091092                     GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u));
    1110 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1093# if PGM_GST_TYPE == PGM_TYPE_AMD64
    11111094            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    11121095# else
    … …  
    11241107            LogFlow(("InvalidatePage: Out-of-sync (A) at %VGp PdeSrc=%RX64 PdeDst=%RX64\n",
    11251108                     GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u));
    1126 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1109# if PGM_GST_TYPE == PGM_TYPE_AMD64
    11271110            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    11281111# else
    … …  
    11721155                LogFlow(("InvalidatePage: Out-of-sync at %VGp PdeSrc=%RX64 PdeDst=%RX64 ShwGCPhys=%VGp iPDDst=%#x\n",
    11731156                         GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u, pShwPage->GCPhys, iPDDst));
    1174 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1157# if PGM_GST_TYPE == PGM_TYPE_AMD64
    11751158                pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    11761159# else
    … …  
    12181201            LogFlow(("InvalidatePage: Out-of-sync PD at %VGp PdeSrc=%RX64 PdeDst=%RX64\n",
    12191202                     GCPtrPage, (uint64_t)PdeSrc.u, (uint64_t)PdeDst.u));
    1220 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1203# if PGM_GST_TYPE == PGM_TYPE_AMD64
    12211204            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    12221205# else
    … …  
    12351218        if (!(PdeDst.u & PGM_PDFLAGS_MAPPING))
    12361219        {
    1237 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1220# if PGM_GST_TYPE == PGM_TYPE_AMD64
    12381221            pgmPoolFree(pVM, PdeDst.u & SHW_PDE_PG_MASK, pShwPde->idx, iPDDst);
    12391222# else
    … …  
    15261509# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    15271510    const unsigned  iPDDst   = GCPtrPage >> SHW_PD_SHIFT;
    1528     const unsigned  iPdPte   = (GCPtrPage >> X86_PDPT_SHIFT);   /* no mask; flat index into the 2048 entry array. */
     1511    const unsigned  iPdpte   = (GCPtrPage >> X86_PDPT_SHIFT);   /* no mask; flat index into the 2048 entry array. */
    15291512    PX86PDPT        pPdptDst = pVM->pgm.s.CTXMID(p,PaePDPT);
    15301513    X86PDEPAE       PdeDst   = pVM->pgm.s.CTXMID(ap,PaePDs)[0]->a[iPDDst];
    15311514# elif PGM_SHW_TYPE == PGM_TYPE_AMD64
    15321515    const unsigned  iPDDst   = ((GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK);
    1533     const unsigned  iPdPte   = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
     1516    const unsigned  iPdpte   = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
    15341517    PX86PDPAE       pPDDst;
    15351518    X86PDEPAE       PdeDst;
    … …  
    15461529# if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    15471530    /* Fetch the pgm pool shadow descriptor. */
    1548     PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdPte].u & X86_PDPE_PG_MASK);
     1531    PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdpte].u & X86_PDPE_PG_MASK);
    15491532    Assert(pShwPde);
    15501533# endif
    … …  
    17641747     */
    17651748    PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
    1766 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     1749# if PGM_GST_TYPE == PGM_TYPE_AMD64
    17671750    pgmPoolFreeByPage(pPool, pShwPage, pShwPde->idx, iPDDst);
    17681751# else
    … …  
    22322215# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    22332216    const unsigned  iPDDst   = GCPtrPage >> SHW_PD_SHIFT;
    2234     const unsigned  iPdPte   = (GCPtrPage >> X86_PDPT_SHIFT);
     2217    const unsigned  iPdpte   = (GCPtrPage >> X86_PDPT_SHIFT);
    22352218    PX86PDPT        pPdptDst = pVM->pgm.s.CTXMID(p,PaePDPT);
    22362219    PX86PDPAE       pPDDst   = pVM->pgm.s.CTXMID(ap,PaePDs)[0];
    22372220# elif PGM_SHW_TYPE == PGM_TYPE_AMD64
    22382221    const unsigned  iPml4e   = (GCPtrPage >> X86_PML4_SHIFT) & X86_PML4_MASK;
    2239     const unsigned  iPdPte   = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
     2222    const unsigned  iPdpte   = (GCPtrPage >> X86_PDPT_SHIFT) & X86_PDPT_MASK_AMD64;
    22402223    const unsigned  iPDDst   = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
    22412224    PX86PDPAE       pPDDst;
    … …  
    22532236    SHWPDE          PdeDst = *pPdeDst;
    22542237
    2255 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     2238# if PGM_GST_TYPE == PGM_TYPE_AMD64
    22562239    /* Fetch the pgm pool shadow descriptor. */
    2257     PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdPte].u & X86_PDPE_PG_MASK);
     2240    PPGMPOOLPAGE pShwPde = pgmPoolGetPageByHCPhys(pVM, pPdptDst->a[iPdpte].u & X86_PDPE_PG_MASK);
    22582241    Assert(pShwPde);
    22592242# endif
    … …  
    23192302            GCPhys |= (iPDDst & 1) * (PAGE_SIZE / 2);
    23202303# endif
    2321 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     2304# if PGM_GST_TYPE == PGM_TYPE_AMD64
    23222305            rc = pgmPoolAlloc(pVM, GCPhys, BTH_PGMPOOLKIND_PT_FOR_PT, pShwPde->idx,    iPDDst, &pShwPage);
    23232306# else
    … …  
    23322315            GCPhys |= GCPtrPage & (1 << X86_PD_PAE_SHIFT);
    23332316# endif
    2334 # if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     2317# if PGM_GST_TYPE == PGM_TYPE_AMD64
    23352318            rc = pgmPoolAlloc(pVM, GCPhys, BTH_PGMPOOLKIND_PT_FOR_BIG, pShwPde->idx,    iPDDst, &pShwPage);
    23362319# else
    … …  
    31143097#  endif
    31153098#  if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
    3116         for (uint64_t iPDPTE = 0; iPDPTE < GST_PDPE_ENTRIES; iPDPTE++)
     3099        for (uint64_t iPdpte = 0; iPdpte < GST_PDPE_ENTRIES; iPdpte++)
    31173100        {
    31183101            unsigned        iPDSrc;
    3119             PPGMPOOLPAGE    pShwPde = NULL;
    3120             PX86PDPE        pPdpeDst;
    3121             RTGCPHYS        GCPhysPdeSrc;
    31223102#   if PGM_GST_TYPE == PGM_TYPE_PAE
    31233103            PX86PDPAE       pPDPAE    = pVM->pgm.s.CTXMID(ap,PaePDs)[0];
    3124             PX86PDEPAE      pPDEDst   = &pPDPAE->a[iPDPTE * X86_PG_PAE_ENTRIES];
    3125             PGSTPD          pPDSrc    = pgmGstGetPaePDPtr(&pVM->pgm.s, iPDPTE << X86_PDPT_SHIFT, &iPDSrc);
     3104            PX86PDEPAE      pPDEDst   = &pPDPAE->a[iPdpte * X86_PG_PAE_ENTRIES];
     3105            PGSTPD          pPDSrc    = pgmGstGetPaePDPtr(&pVM->pgm.s, iPdpte << X86_PDPT_SHIFT, &iPDSrc);
    31263106            PX86PDPT        pPdptDst  = pVM->pgm.s.CTXMID(p,PaePDPT);
    3127             X86PDPE         PdpeSrc   = CTXSUFF(pVM->pgm.s.pGstPaePDPT)->a[iPDPTE];
    3128 #   else
     3107            X86PDPE         PdpeSrc   = CTXSUFF(pVM->pgm.s.pGstPaePDPT)->a[iPdpte];
     3108
     3109            if (pPDSrc == NULL)
     3110            {
     3111                /* PDPE not present */
     3112                if (pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].n.u1Present)
     3113                {
     3114                        /* for each page directory entry */
     3115                        for (unsigned iPD = 0; iPD < ELEMENTS(pPDSrc->a); iPD++)
     3116                        {
     3117                            if (   pPDEDst[iPD].n.u1Present
     3118                                && !(pPDEDst[iPD].u & PGM_PDFLAGS_MAPPING))
     3119                            {
     3120                            pgmPoolFreeByPage(pPool, pgmPoolGetPage(pPool, pPDEDst[iPD].u & SHW_PDE_PG_MASK), SHW_POOL_ROOT_IDX, iPdpte * X86_PG_PAE_ENTRIES + iPD);
     3121                            pPDEDst[iPD].u = 0;
     3122                            }
     3123                        }
     3124                }
     3125                if (!(pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].u & PGM_PLXFLAGS_MAPPING))
     3126                        pVM->pgm.s.CTXMID(p,PaePDPT)->a[iPdpte].n.u1Present = 0;
     3127                continue;
     3128            }
     3129#   else /* PGM_GST_TYPE != PGM_TYPE_PAE */
     3130            PPGMPOOLPAGE    pShwPde = NULL;
     3131            RTGCPHYS        GCPhysPdeSrc;
     3132            PX86PDPE        pPdpeDst;
    31293133            PX86PML4E       pPml4eSrc;
    31303134            X86PDPE         PdpeSrc;
    … …  
    31323136            PX86PDPAE       pPDDst;
    31333137            PX86PDEPAE      pPDEDst;
    3134             RTGCUINTPTR     GCPtr     = (iPml4e << X86_PML4_SHIFT) || (iPDPTE << X86_PDPT_SHIFT);
     3138            RTGCUINTPTR     GCPtr     = (iPml4e << X86_PML4_SHIFT) || (iPdpte << X86_PDPT_SHIFT);
    31353139            PGSTPD          pPDSrc    = pgmGstGetLongModePDPtr(&pVM->pgm.s, GCPtr, &pPml4eSrc, &PdpeSrc, &iPDSrc);
    31363140
    … …  
    31463150            Assert(pPDDst);
    31473151            pPDEDst = &pPDDst->a[0];
    3148 #   endif
    31493152            Assert(iPDSrc == 0);
    31503153
    3151             pPdpeDst = &pPdptDst->a[iPDPTE];
     3154            pPdpeDst = &pPdptDst->a[iPdpte];
    31523155
    31533156            /* Fetch the pgm pool shadow descriptor if the shadow pdpte is present. */
    … …  
    31633166            {
    31643167                /* Free it. */
    3165 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    31663168                LogFlow(("SyncCR3: Out-of-sync PDPE (GCPhys) GCPtr=%VGv %VGp vs %VGp PdpeSrc=%RX64 PdpeDst=%RX64\n",
    3167                         ((uint64_t)iPml4e << X86_PML4_SHIFT) + ((uint64_t)iPDPTE << X86_PDPT_SHIFT), pShwPde->GCPhys, GCPhysPdeSrc, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    3168 #  else
    3169                 LogFlow(("SyncCR3: Out-of-sync PDPE (GCPhys) GCPtr=%VGv %VGp vs %VGp PdpeSrc=%RX64 PdpeDst=%RX64\n",
    3170                         (uint64_t)iPDPTE << X86_PDPT_SHIFT, pShwPde->GCPhys, GCPhysPdeSrc, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    3171 #  endif
     3169                        ((uint64_t)iPml4e << X86_PML4_SHIFT) + ((uint64_t)iPdpte << X86_PDPT_SHIFT), pShwPde->GCPhys, GCPhysPdeSrc, (uint64_t)PdpeSrc.u, (uint64_t)pPdpeDst->u));
    31723170
    31733171                /* Mark it as not present if there's no hypervisor mapping present. (bit flipped at the top of Trap0eHandler) */
    3174                 if (!(pPdpeDst->u & PGM_PLXFLAGS_MAPPING))
    3175                 {
    3176                     pgmPoolFreeByPage(pPool, pShwPde, pShwPde->idx, iPDPTE);
    3177                     pPdpeDst->u = 0;
    3178                     continue;   /* next guest PDPTE */
    3179                 }
     3172                Assert(!(pPdpeDst->u & PGM_PLXFLAGS_MAPPING));
     3173                pgmPoolFreeByPage(pPool, pShwPde, pShwPde->idx, iPdpte);
     3174                pPdpeDst->u = 0;
     3175                continue;   /* next guest PDPTE */
    31803176            }
    3181 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    31823177            /* Force an attribute sync. */
    31833178            pPdpeDst->lm.u1User      = PdpeSrc.lm.u1User;
    31843179            pPdpeDst->lm.u1Write     = PdpeSrc.lm.u1Write;
    31853180            pPdpeDst->lm.u1NoExecute = PdpeSrc.lm.u1NoExecute;
    3186 #  endif
     3181#   endif /* PGM_GST_TYPE != PGM_TYPE_PAE */
    31873182
    31883183#  else  /* PGM_GST_TYPE != PGM_TYPE_PAE && PGM_GST_TYPE != PGM_TYPE_AMD64 */
    … …  
    32083203                    */
    32093204#   if PGM_GST_TYPE == PGM_TYPE_PAE
    3210                     if (iPD + iPDPTE * X86_PG_PAE_ENTRIES == iPdNoMapping)
     3205                    if (iPD + iPdpte * X86_PG_PAE_ENTRIES == iPdNoMapping)
    32113206#   else
    32123207                    if (iPD == iPdNoMapping)
    … …  
    32273222                        int rc = pgmR3SyncPTResolveConflict(pVM, pMapping, pPDSrc, iPD << GST_PD_SHIFT);
    32283223#    elif PGM_GST_TYPE == PGM_TYPE_PAE
    3229                         int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPDPTE << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
     3224                        int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPdpte << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
    32303225#    endif
    32313226                        if (VBOX_FAILURE(rc))
    … …  
    33303325                            else
    33313326                            {
    3332 #  if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     3327#  if PGM_GST_TYPE == PGM_TYPE_AMD64
    33333328                                pgmPoolFreeByPage(pPool, pShwPage, pShwPde->idx, iPdShw);
    33343329#  else
    … …  
    33453340                }
    33463341#  if PGM_GST_TYPE == PGM_TYPE_PAE
    3347                 else if (iPD + iPDPTE * X86_PG_PAE_ENTRIES != iPdNoMapping)
     3342                else if (iPD + iPdpte * X86_PG_PAE_ENTRIES != iPdNoMapping)
    33483343#  else
    33493344                else if (iPD != iPdNoMapping)
    … …  
    33613356                        if (pPDEDst->n.u1Present)
    33623357                        {
    3363 #  if PGM_GST_TYPE == PGM_TYPE_PAE || PGM_GST_TYPE == PGM_TYPE_AMD64
     3358#  if PGM_GST_TYPE == PGM_TYPE_AMD64
    33643359                            pgmPoolFreeByPage(pPool, pgmPoolGetPage(pPool, pPDEDst->u & SHW_PDE_PG_MASK), pShwPde->idx, iPdShw);
    33653360#  else
    … …  
    34043399                                int rc = pgmR3SyncPTResolveConflict(pVM, pMapping, pPDSrc, iPD << GST_PD_SHIFT);
    34053400#    elif PGM_GST_TYPE == PGM_TYPE_PAE
    3406                                 int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPDPTE << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
     3401                                int rc = pgmR3SyncPTResolveConflictPAE(pVM, pMapping, (iPdpte << GST_PDPT_SHIFT) + (iPD << GST_PD_SHIFT));
    34073402#    endif
    34083403                                if (VBOX_FAILURE(rc))

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

    r9890 r9893  
    530530        PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
    531531        pgmPoolFreeByPage(pPool, pVM->pgm.s.pShwAmd64CR3, PGMPOOL_IDX_AMD64_CR3, pVM->pgm.s.pShwAmd64CR3->GCPhys >> PAGE_SHIFT);
     532        pVM->pgm.s.pShwAmd64CR3 = NULL;
    532533    }
    533534

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

    r9890 r9893  
    318318                    uShw.pPTPae->a[iShw].u = 0;
    319319                }
     320
     321                /* paranoia / a bit assumptive. */
     322                if (   pCpu
     323                    && (off & 7)
     324                    && (off & 7) + pgmPoolDisasWriteSize(pCpu) > sizeof(X86PTEPAE))
     325                {
     326                    AssertFailed();
     327                }
     328
    320329                break;
    321330            }
    … …  
    422431                if (   pCpu
    423432                    && (off & 7)
    424                     && (off & 7) + pgmPoolDisasWriteSize(pCpu) > sizeof(X86PTEPAE))
     433                    && (off & 7) + pgmPoolDisasWriteSize(pCpu) > sizeof(X86PDEPAE))
    425434                {
    426                     const unsigned iShw2 = (off + pgmPoolDisasWriteSize(pCpu) - 1) / sizeof(X86PTEPAE);
     435                    const unsigned iShw2 = (off + pgmPoolDisasWriteSize(pCpu) - 1) / sizeof(X86PDEPAE);
    427436                    if (    iShw2 != iShw
    428437                        &&  iShw2 < ELEMENTS(uShw.pPDPae->a)

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

    r9858 r9893  
    8080# define SHW_PDPE_PG_MASK       X86_PDPE_PG_MASK
    8181# define SHW_TOTAL_PD_ENTRIES   (X86_PG_AMD64_ENTRIES*X86_PG_AMD64_PDPE_ENTRIES)
    82 # define SHW_POOL_ROOT_IDX      PGMPOOL_IDX_PAE_PD
     82# define SHW_POOL_ROOT_IDX      PGMPOOL_IDX_PAE_PD      /* do not use! exception is real mode & protected mode without paging. */
    8383#else /* 32 bits PAE mode */
    8484# define SHW_PDPT_SHIFT         X86_PDPT_SHIFT
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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