VirtualBox

Ignore:
Timestamp:
Jan 26, 2017 7:00:23 PM (8 years ago)
Author:
vboxsync
Message:

PGM: Guest page table walking optimizations (incomplete) and statistics.

  • Optimizing guest page table walking (predictions, eff flags). More to do here, esp. with IEM TLB.
  • Added a bunch of page pools access handler stats, doing some cleanup while there.
  • Used bit 9 in PDEs for remembering whether it's from a large or 4KB page. Only for statistics for now.
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r62606 r65466  
    7474 * @param   pWalk       Where to return the walk result. This is always set.
    7575 */
    76 static int PGM_GST_NAME(Walk)(PVMCPU pVCpu, RTGCPTR GCPtr, PGSTPTWALK pWalk)
     76DECLINLINE(int) PGM_GST_NAME(Walk)(PVMCPU pVCpu, RTGCPTR GCPtr, PGSTPTWALK pWalk)
    7777{
    7878    int rc;
    … …  
    9393# endif
    9494
     95    uint32_t register fEffective = X86_PTE_RW | X86_PTE_US | X86_PTE_PWT | X86_PTE_PCD | X86_PTE_A | 1;
    9596    {
    9697# if PGM_GST_TYPE == PGM_TYPE_AMD64
    … …  
    99100         */
    100101        rc = pgmGstGetLongModePML4PtrEx(pVCpu, &pWalk->pPml4);
    101         if (RT_FAILURE(rc))
    102             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 4, rc);
    103 
    104         PX86PML4  register  pPml4 = pWalk->pPml4;
     102        if (RT_SUCCESS(rc)) { /* probable */ }
     103        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 4, rc);
     104
     105        PX86PML4E register  pPml4e;
     106        pWalk->pPml4e  = pPml4e  = &pWalk->pPml4->a[(GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK];
    105107        X86PML4E  register  Pml4e;
    106         PX86PML4E register  pPml4e;
    107 
    108         pWalk->pPml4e  = pPml4e  = &pPml4->a[(GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK];
    109108        pWalk->Pml4e.u = Pml4e.u = pPml4e->u;
    110         if (!Pml4e.n.u1Present)
    111             return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 4);
    112         if (RT_UNLIKELY(!GST_IS_PML4E_VALID(pVCpu, Pml4e)))
    113             return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 4);
     109
     110        if (Pml4e.n.u1Present) { /* probable */ }
     111        else return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 4);
     112
     113        if (RT_LIKELY(GST_IS_PML4E_VALID(pVCpu, Pml4e))) { /* likely */ }
     114        else return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 4);
     115
     116        pWalk->Core.fEffective = fEffective = ((uint32_t)Pml4e.u & (X86_PML4E_RW  | X86_PML4E_US | X86_PML4E_PWT | X86_PML4E_PCD | X86_PML4E_A))
     117                                            | ((uint32_t)(Pml4e.u >> 63) ^ 1) /*NX */;
    114118
    115119        /*
    … …  
    117121         */
    118122        rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pml4e.u & X86_PML4E_PG_MASK, &pWalk->pPdpt);
    119         if (RT_FAILURE(rc))
    120             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 3, rc);
     123        if (RT_SUCCESS(rc)) { /* probable */ }
     124        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 3, rc);
    121125
    122126# elif PGM_GST_TYPE == PGM_TYPE_PAE
    123127        rc = pgmGstGetPaePDPTPtrEx(pVCpu, &pWalk->pPdpt);
    124         if (RT_FAILURE(rc))
    125             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 8, rc);
     128        if (RT_SUCCESS(rc)) { /* probable */ }
     129        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 8, rc);
    126130# endif
    127131    }
    128132    {
    129133# if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
    130         PX86PDPT register   pPdpt = pWalk->pPdpt;
    131134        PX86PDPE register   pPdpe;
     135        pWalk->pPdpe  = pPdpe  = &pWalk->pPdpt->a[(GCPtr >> GST_PDPT_SHIFT) & GST_PDPT_MASK];
    132136        X86PDPE  register   Pdpe;
    133 
    134         pWalk->pPdpe  = pPdpe  = &pPdpt->a[(GCPtr >> GST_PDPT_SHIFT) & GST_PDPT_MASK];
    135137        pWalk->Pdpe.u = Pdpe.u = pPdpe->u;
    136         if (!Pdpe.n.u1Present)
    137             return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 3);
    138         if (RT_UNLIKELY(!GST_IS_PDPE_VALID(pVCpu, Pdpe)))
    139             return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 3);
     138
     139        if (Pdpe.n.u1Present) { /* probable */ }
     140        else return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 3);
     141
     142        if (RT_LIKELY(GST_IS_PDPE_VALID(pVCpu, Pdpe))) { /* likely */ }
     143        else return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 3);
     144
     145# if PGM_GST_TYPE == PGM_TYPE_AMD64
     146        pWalk->Core.fEffective = fEffective &= ((uint32_t)Pdpe.u & (X86_PDPE_RW  | X86_PDPE_US | X86_PDPE_PWT | X86_PDPE_PCD | X86_PDPE_A))
     147                                             | ((uint32_t)(Pdpe.u >> 63) ^ 1) /*NX */;
     148# else
     149        pWalk->Core.fEffective = fEffective  = X86_PDPE_RW  | X86_PDPE_US | X86_PDPE_A
     150                                             | ((uint32_t)Pdpe.u & (X86_PDPE_PWT | X86_PDPE_PCD))
     151                                             | ((uint32_t)(Pdpe.u >> 63) ^ 1) /*NX */;
     152# endif
    140153
    141154        /*
    … …  
    143156         */
    144157        rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, Pdpe.u & X86_PDPE_PG_MASK, &pWalk->pPd);
    145         if (RT_FAILURE(rc))
    146             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 2, rc);
     158        if (RT_SUCCESS(rc)) { /* probable */ }
     159        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 2, rc);
    147160# elif PGM_GST_TYPE == PGM_TYPE_32BIT
    148161        rc = pgmGstGet32bitPDPtrEx(pVCpu, &pWalk->pPd);
    149         if (RT_FAILURE(rc))
    150             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 8, rc);
     162        if (RT_SUCCESS(rc)) { /* probable */ }
     163        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 8, rc);
    151164# endif
    152165    }
    153166    {
    154         PGSTPD  register    pPd = pWalk->pPd;
    155167        PGSTPDE register    pPde;
     168        pWalk->pPde  = pPde  = &pWalk->pPd->a[(GCPtr >> GST_PD_SHIFT) & GST_PD_MASK];
    156169        GSTPDE              Pde;
    157 
    158         pWalk->pPde  = pPde  = &pPd->a[(GCPtr >> GST_PD_SHIFT) & GST_PD_MASK];
    159170        pWalk->Pde.u = Pde.u = pPde->u;
    160         if (!Pde.n.u1Present)
    161             return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 2);
     171        if (Pde.n.u1Present) { /* probable */ }
     172        else return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 2);
    162173        if (Pde.n.u1Size && GST_IS_PSE_ACTIVE(pVCpu))
    163174        {
    164             if (RT_UNLIKELY(!GST_IS_BIG_PDE_VALID(pVCpu, Pde)))
    165                 return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 2);
     175            if (RT_LIKELY(GST_IS_BIG_PDE_VALID(pVCpu, Pde))) { /* likely */ }
     176            else return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 2);
     177
     178            /*
     179             * We're done.
     180             */
     181# if PGM_GST_TYPE == PGM_TYPE_32BIT
     182            fEffective &= Pde.u & (X86_PDE4M_RW  | X86_PDE4M_US | X86_PDE4M_PWT | X86_PDE4M_PCD | X86_PDE4M_A);
     183# else
     184            fEffective &= ((uint32_t)Pde.u & (X86_PDE4M_RW  | X86_PDE4M_US | X86_PDE4M_PWT | X86_PDE4M_PCD | X86_PDE4M_A))
     185                        | ((uint32_t)(Pde.u >> 63) ^ 1) /*NX */;
     186# endif
     187            fEffective |= (uint32_t)Pde.u & (X86_PDE4M_D | X86_PDE4M_G);
     188            fEffective |= (uint32_t)(Pde.u & X86_PDE4M_PAT) >> X86_PDE4M_PAT_SHIFT;
     189            pWalk->Core.fEffective = fEffective;
     190
     191            pWalk->Core.fEffectiveRW = !!(fEffective & X86_PTE_RW);
     192            pWalk->Core.fEffectiveUS = !!(fEffective & X86_PTE_US);
     193# if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
     194            pWalk->Core.fEffectiveNX = !(fEffective & 1) && GST_IS_NX_ACTIVE(pVCpu);
     195# else
     196            pWalk->Core.fEffectiveNX = false;
     197# endif
     198            pWalk->Core.fBigPage     = true;
     199            pWalk->Core.fSucceeded   = true;
    166200
    167201            pWalk->Core.GCPhys       = GST_GET_BIG_PDE_GCPHYS(pVCpu->CTX_SUFF(pVM), Pde)
    168202                                     | (GCPtr & GST_BIG_PAGE_OFFSET_MASK);
    169203            PGM_A20_APPLY_TO_VAR(pVCpu, pWalk->Core.GCPhys);
    170             uint8_t fEffectiveXX     = (uint8_t)pWalk->Pde.u
    171 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    172                                      & (uint8_t)pWalk->Pdpe.u
    173                                      & (uint8_t)pWalk->Pml4e.u
    174 #  endif
    175                                      ;
    176             pWalk->Core.fEffectiveRW = !!(fEffectiveXX & X86_PTE_RW);
    177             pWalk->Core.fEffectiveUS = !!(fEffectiveXX & X86_PTE_US);
    178 # if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
    179             pWalk->Core.fEffectiveNX = (   pWalk->Pde.n.u1NoExecute
    180 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    181                                         || pWalk->Pdpe.lm.u1NoExecute
    182                                         || pWalk->Pml4e.n.u1NoExecute
    183 #  endif
    184                                        ) && GST_IS_NX_ACTIVE(pVCpu);
    185 # else
    186             pWalk->Core.fEffectiveNX = false;
    187 # endif
    188             pWalk->Core.fBigPage     = true;
    189             pWalk->Core.fSucceeded   = true;
    190204            return VINF_SUCCESS;
    191205        }
    … …  
    193207        if (RT_UNLIKELY(!GST_IS_PDE_VALID(pVCpu, Pde)))
    194208            return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 2);
     209# if PGM_GST_TYPE == PGM_TYPE_32BIT
     210        pWalk->Core.fEffective = fEffective &= Pde.u & (X86_PDE_RW  | X86_PDE_US | X86_PDE_PWT | X86_PDE_PCD | X86_PDE_A);
     211# else
     212        pWalk->Core.fEffective = fEffective &= ((uint32_t)Pde.u & (X86_PDE_RW  | X86_PDE_US | X86_PDE_PWT | X86_PDE_PCD | X86_PDE_A))
     213                                             | ((uint32_t)(Pde.u >> 63) ^ 1) /*NX */;
     214# endif
    195215
    196216        /*
    … …  
    198218         */
    199219        rc = PGM_GCPHYS_2_PTR_BY_VMCPU(pVCpu, GST_GET_PDE_GCPHYS(Pde), &pWalk->pPt);
    200         if (RT_FAILURE(rc))
    201             return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 1, rc);
     220        if (RT_SUCCESS(rc)) { /* probable */ }
     221        else return PGM_GST_NAME(WalkReturnBadPhysAddr)(pVCpu, pWalk, 1, rc);
    202222    }
    203223    {
    204         PGSTPT  register    pPt = pWalk->pPt;
    205224        PGSTPTE register    pPte;
     225        pWalk->pPte  = pPte  = &pWalk->pPt->a[(GCPtr >> GST_PT_SHIFT) & GST_PT_MASK];
    206226        GSTPTE  register    Pte;
    207 
    208         pWalk->pPte  = pPte  = &pPt->a[(GCPtr >> GST_PT_SHIFT) & GST_PT_MASK];
    209227        pWalk->Pte.u = Pte.u = pPte->u;
    210         if (!Pte.n.u1Present)
    211             return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 1);
    212         if (RT_UNLIKELY(!GST_IS_PTE_VALID(pVCpu, Pte)))
    213             return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 1);
     228
     229        if (Pte.n.u1Present) { /* probable */ }
     230        else return PGM_GST_NAME(WalkReturnNotPresent)(pVCpu, pWalk, 1);
     231
     232        if (RT_LIKELY(GST_IS_PTE_VALID(pVCpu, Pte))) { /* likely */ }
     233        else return PGM_GST_NAME(WalkReturnRsvdError)(pVCpu, pWalk, 1);
    214234
    215235        /*
    216236         * We're done.
    217237         */
     238# if PGM_GST_TYPE == PGM_TYPE_32BIT
     239        fEffective &= Pte.u & (X86_PTE_RW  | X86_PTE_US | X86_PTE_PWT | X86_PTE_PCD | X86_PTE_A);
     240# else
     241        fEffective &= ((uint32_t)Pte.u & (X86_PTE_RW  | X86_PTE_US | X86_PTE_PWT | X86_PTE_PCD | X86_PTE_A))
     242                    | ((uint32_t)(Pte.u >> 63) ^ 1) /*NX */;
     243# endif
     244        fEffective |= (uint32_t)Pte.u & (X86_PTE_D | X86_PTE_PAT | X86_PTE_G);
     245        pWalk->Core.fEffective = fEffective;
     246
     247        pWalk->Core.fEffectiveRW = !!(fEffective & X86_PTE_RW);
     248        pWalk->Core.fEffectiveUS = !!(fEffective & X86_PTE_US);
     249# if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
     250        pWalk->Core.fEffectiveNX = !(fEffective & 1) && GST_IS_NX_ACTIVE(pVCpu);
     251# else
     252        pWalk->Core.fEffectiveNX = false;
     253# endif
     254        pWalk->Core.fSucceeded   = true;
     255
    218256        pWalk->Core.GCPhys       = GST_GET_PDE_GCPHYS(Pte)
    219257                                 | (GCPtr & PAGE_OFFSET_MASK);
    220         uint8_t fEffectiveXX     = (uint8_t)pWalk->Pte.u
    221                                  & (uint8_t)pWalk->Pde.u
    222 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    223                                  & (uint8_t)pWalk->Pdpe.u
    224                                  & (uint8_t)pWalk->Pml4e.u
    225 #  endif
    226                                  ;
    227         pWalk->Core.fEffectiveRW = !!(fEffectiveXX & X86_PTE_RW);
    228         pWalk->Core.fEffectiveUS = !!(fEffectiveXX & X86_PTE_US);
    229 # if PGM_GST_TYPE == PGM_TYPE_AMD64 || PGM_GST_TYPE == PGM_TYPE_PAE
    230         pWalk->Core.fEffectiveNX = (   pWalk->Pte.n.u1NoExecute
    231                                     || pWalk->Pde.n.u1NoExecute
    232 #  if PGM_GST_TYPE == PGM_TYPE_AMD64
    233                                     || pWalk->Pdpe.lm.u1NoExecute
    234                                     || pWalk->Pml4e.n.u1NoExecute
    235 #  endif
    236                                    ) && GST_IS_NX_ACTIVE(pVCpu);
    237 # else
    238         pWalk->Core.fEffectiveNX = false;
    239 # endif
    240         pWalk->Core.fSucceeded   = true;
    241258        return VINF_SUCCESS;
    242259    }
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