VirtualBox

Changeset 31167 in vbox


Ignore:
Timestamp:
Jul 28, 2010 2:38:43 PM (14 years ago)
Author:
vboxsync
Message:

PGM: Pass pVCpu instead of pPGM (PPGMCPU) and eliminate PGMPOOL_PAGE_2_PTR_BY_PGM and PGMPOOL_PAGE_2_PTR_BY_PGMCPU.

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

Legend:

Unmodified
Added
Removed

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

    r31136 r31167  
    994994 *
    995995 * @returns Pointer to the shadow 32-bit PD.
    996  * @param   pPGM        Pointer to the PGM instance data.
    997  */
    998 DECLINLINE(PX86PD) pgmShwGet32BitPDPtr(PPGMCPU pPGM)
    999 {
    1000     return (PX86PD)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPGM->CTX_SUFF(pShwPageCR3));
     996 * @param   pVCpu       The current CPU.
     997 */
     998DECLINLINE(PX86PD) pgmShwGet32BitPDPtr(PVMCPU pVCpu)
     999{
     1000    return (PX86PD)PGMPOOL_PAGE_2_PTR(pVCpu->CTX_SUFF(pVM), pVCpu->pgm.s.CTX_SUFF(pShwPageCR3));
    10011001}
    10021002
    … …  
    10061006 *
    10071007 * @returns Shadow 32-bit PDE.
    1008  * @param   pPGM        Pointer to the PGM instance data.
     1008 * @param   pVCpu       The current CPU.
    10091009 * @param   GCPtr       The address.
    10101010 */
    1011 DECLINLINE(X86PDE) pgmShwGet32BitPDE(PPGMCPU pPGM, RTGCPTR GCPtr)
     1011DECLINLINE(X86PDE) pgmShwGet32BitPDE(PVMCPU pVCpu, RTGCPTR GCPtr)
    10121012{
    10131013    const unsigned iPd = (GCPtr >> X86_PD_SHIFT) & X86_PD_MASK;
    10141014
    1015     PX86PD pShwPde = pgmShwGet32BitPDPtr(pPGM);
     1015    PX86PD pShwPde = pgmShwGet32BitPDPtr(pVCpu);
    10161016    if (!pShwPde)
    10171017    {
    … …  
    10281028 *
    10291029 * @returns Pointer to the shadow 32-bit PDE.
    1030  * @param   pPGM        Pointer to the PGM instance data.
     1030 * @param   pVCpu       The current CPU.
    10311031 * @param   GCPtr       The address.
    10321032 */
    1033 DECLINLINE(PX86PDE) pgmShwGet32BitPDEPtr(PPGMCPU pPGM, RTGCPTR GCPtr)
     1033DECLINLINE(PX86PDE) pgmShwGet32BitPDEPtr(PVMCPU pVCpu, RTGCPTR GCPtr)
    10341034{
    10351035    const unsigned iPd = (GCPtr >> X86_PD_SHIFT) & X86_PD_MASK;
    10361036
    1037     PX86PD pPde = pgmShwGet32BitPDPtr(pPGM);
     1037    PX86PD pPde = pgmShwGet32BitPDPtr(pVCpu);
    10381038    AssertReturn(pPde, NULL);
    10391039    return &pPde->a[iPd];
    … …  
    10451045 *
    10461046 * @returns Pointer to the shadow PAE PDPT.
    1047  * @param   pPGM        Pointer to the PGM instance data.
    1048  */
    1049 DECLINLINE(PX86PDPT) pgmShwGetPaePDPTPtr(PPGMCPU pPGM)
    1050 {
    1051     return (PX86PDPT)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPGM->CTX_SUFF(pShwPageCR3));
     1047 * @param   pVCpu       The current CPU.
     1048 */
     1049DECLINLINE(PX86PDPT) pgmShwGetPaePDPTPtr(PVMCPU pVCpu)
     1050{
     1051    return (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVCpu->CTX_SUFF(pVM), pVCpu->pgm.s.CTX_SUFF(pShwPageCR3));
    10521052}
    10531053
    … …  
    10571057 *
    10581058 * @returns Pointer to the shadow PD.
    1059  * @param   pPGM        Pointer to the PGM instance data.
     1059 * @param   pVCpu       The current CPU.
    10601060 * @param   GCPtr       The address.
    10611061 */
    1062 DECLINLINE(PX86PDPAE) pgmShwGetPaePDPtr(PPGMCPU pPGM, RTGCPTR GCPtr)
     1062DECLINLINE(PX86PDPAE) pgmShwGetPaePDPtr(PVMCPU pVCpu, RTGCPTR GCPtr)
    10631063{
    10641064    const unsigned  iPdpt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
    1065     PX86PDPT        pPdpt = pgmShwGetPaePDPTPtr(pPGM);
     1065    PX86PDPT        pPdpt = pgmShwGetPaePDPTPtr(pVCpu);
    10661066
    10671067    if (!pPdpt->a[iPdpt].n.u1Present)
    … …  
    10691069
    10701070    /* Fetch the pgm pool shadow descriptor. */
    1071     PPGMPOOLPAGE pShwPde = pgmPoolGetPage(PGMCPU2PGM(pPGM)->CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
     1071    PVM pVM = pVCpu->CTX_SUFF(pVM);
     1072    PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    10721073    AssertReturn(pShwPde, NULL);
    10731074
    1074     return (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pShwPde);
     1075    return (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    10751076}
    10761077
    … …  
    10801081 *
    10811082 * @returns Pointer to the shadow PD.
    1082  * @param   pPGM        Pointer to the PGM instance data.
     1083 * @param   pVCpu       The current CPU.
    10831084 * @param   GCPtr       The address.
    10841085 */
    1085 DECLINLINE(PX86PDPAE) pgmShwGetPaePDPtr(PPGMCPU pPGM, PX86PDPT pPdpt, RTGCPTR GCPtr)
     1086DECLINLINE(PX86PDPAE) pgmShwGetPaePDPtr(PVMCPU pVCpu, PX86PDPT pPdpt, RTGCPTR GCPtr)
    10861087{
    10871088    const unsigned  iPdpt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
    … …  
    10911092
    10921093    /* Fetch the pgm pool shadow descriptor. */
    1093     PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(PGMCPU2PGM(pPGM)->CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
     1094    PVM             pVM     = pVCpu->CTX_SUFF(pVM);
     1095    PPGMPOOLPAGE    pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdpt].u & X86_PDPE_PG_MASK);
    10941096    AssertReturn(pShwPde, NULL);
    10951097
    1096     return (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pShwPde);
     1098    return (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    10971099}
    10981100
    … …  
    11021104 *
    11031105 * @returns PDE.
    1104  * @param   pPGM        Pointer to the PGM instance data.
     1106 * @param   pVCpu       The current CPU.
    11051107 * @param   GCPtr       The address.
    11061108 */
    1107 DECLINLINE(X86PDEPAE) pgmShwGetPaePDE(PPGMCPU pPGM, RTGCPTR GCPtr)
    1108 {
    1109     const unsigned  iPd  = (GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
    1110 
    1111     PX86PDPAE pShwPde = pgmShwGetPaePDPtr(pPGM, GCPtr);
     1109DECLINLINE(X86PDEPAE) pgmShwGetPaePDE(PVMCPU pVCpu, RTGCPTR GCPtr)
     1110{
     1111    const unsigned iPd = (GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
     1112
     1113    PX86PDPAE pShwPde = pgmShwGetPaePDPtr(pVCpu, GCPtr);
    11121114    if (!pShwPde)
    11131115    {
    … …  
    11231125 *
    11241126 * @returns Pointer to the PDE.
    1125  * @param   pPGM        Pointer to the PGM instance data.
     1127 * @param   pVCpu       The current CPU.
    11261128 * @param   GCPtr       The address.
    1127  */
    1128 DECLINLINE(PX86PDEPAE) pgmShwGetPaePDEPtr(PPGMCPU pPGM, RTGCPTR GCPtr)
    1129 {
    1130     const unsigned  iPd   = (GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
    1131 
    1132     PX86PDPAE pPde = pgmShwGetPaePDPtr(pPGM, GCPtr);
     1129 * @remarks Only used by AssertCR3.
     1130 */
     1131DECLINLINE(PX86PDEPAE) pgmShwGetPaePDEPtr(PVMCPU pVCpu, RTGCPTR GCPtr)
     1132{
     1133    const unsigned iPd = (GCPtr >> X86_PD_PAE_SHIFT) & X86_PD_PAE_MASK;
     1134
     1135    PX86PDPAE pPde = pgmShwGetPaePDPtr(pVCpu, GCPtr);
    11331136    AssertReturn(pPde, NULL);
    11341137    return &pPde->a[iPd];
    … …  
    11411144 *
    11421145 * @returns Pointer to the shadow PML4.
    1143  * @param   pPGM        Pointer to the PGM instance data.
    1144  */
    1145 DECLINLINE(PX86PML4) pgmShwGetLongModePML4Ptr(PPGMCPU pPGM)
    1146 {
    1147     return (PX86PML4)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPGM->CTX_SUFF(pShwPageCR3));
     1146 * @param   pVCpu       The current CPU.
     1147 */
     1148DECLINLINE(PX86PML4) pgmShwGetLongModePML4Ptr(PVMCPU pVCpu)
     1149{
     1150    return (PX86PML4)PGMPOOL_PAGE_2_PTR(pVCpu->CTX_SUFF(pVM), pVCpu->pgm.s.CTX_SUFF(pShwPageCR3));
    11481151}
    11491152
    … …  
    11531156 *
    11541157 * @returns The entry.
    1155  * @param   pPGM        Pointer to the PGM instance data.
     1158 * @param   pVCpu       The current CPU.
    11561159 * @param   GCPtr       The address.
    11571160 */
    1158 DECLINLINE(X86PML4E) pgmShwGetLongModePML4E(PPGMCPU pPGM, RTGCPTR GCPtr)
     1161DECLINLINE(X86PML4E) pgmShwGetLongModePML4E(PVMCPU pVCpu, RTGCPTR GCPtr)
    11591162{
    11601163    const unsigned  iPml4 = ((RTGCUINTPTR64)GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
    1161     PX86PML4        pShwPml4 = pgmShwGetLongModePML4Ptr(pPGM);
     1164    PX86PML4        pShwPml4 = pgmShwGetLongModePML4Ptr(pVCpu);
    11621165
    11631166    if (!pShwPml4)
    … …  
    11741177 *
    11751178 * @returns The entry.
    1176  * @param   pPGM        Pointer to the PGM instance data.
     1179 * @param   pVCpu       The current CPU.
    11771180 * @param   iPml4       The PML4 index.
    11781181 */
    1179 DECLINLINE(PX86PML4E) pgmShwGetLongModePML4EPtr(PPGMCPU pPGM, unsigned int iPml4)
    1180 {
    1181     PX86PML4 pShwPml4 = pgmShwGetLongModePML4Ptr(pPGM);
     1182DECLINLINE(PX86PML4E) pgmShwGetLongModePML4EPtr(PVMCPU pVCpu, unsigned int iPml4)
     1183{
     1184    PX86PML4 pShwPml4 = pgmShwGetLongModePML4Ptr(pVCpu);
    11821185    if (!pShwPml4)
    11831186        return NULL;

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

    r31141 r31167  
    21742174#endif
    21752175
    2176 /** @def PGMPOOL_PAGE_2_PTR_BY_PGM
    2177  * Maps a pool page pool into the current context.
    2178  *
    2179  * @returns VBox status code.
    2180  * @param   pPGM    Pointer to the PGM instance data.
    2181  * @param   pPage   The pool page.
    2182  *
    2183  * @remark  In RC this uses PGMGCDynMapHCPage(), so it will consume of the
    2184  *          small page window employeed by that function. Be careful.
    2185  * @remark  There is no need to assert on the result.
    2186  */
    2187 #if defined(IN_RC)
    2188 # define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  pgmPoolMapPageInlined(pPGM, (pPage))
    2189 #elif defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2190 # define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  pgmPoolMapPageInlined(pPGM, (pPage))
    2191 #else
    2192 # define PGMPOOL_PAGE_2_PTR_BY_PGM(pPGM, pPage)  PGMPOOL_PAGE_2_PTR(PGM2VM(pPGM), pPage)
    2193 #endif
    2194 
    2195 /** @def PGMPOOL_PAGE_2_PTR_BY_PGMCPU
    2196  * Maps a pool page pool into the current context.
    2197  *
    2198  * @returns VBox status code.
    2199  * @param   pPGM    Pointer to the PGMCPU instance data.
    2200  * @param   pPage   The pool page.
    2201  *
    2202  * @remark  In RC this uses PGMGCDynMapHCPage(), so it will consume of the
    2203  *          small page window employeed by that function. Be careful.
    2204  * @remark  There is no need to assert on the result.
    2205  */
    2206 #if defined(IN_RC)
    2207 # define PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPage)  pgmPoolMapPageInlined(PGMCPU2PGM(pPGM), (pPage))
    2208 #elif defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2209 # define PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPage)  pgmPoolMapPageInlined(PGMCPU2PGM(pPGM), (pPage))
    2210 #else
    2211 # define PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPage)  PGMPOOL_PAGE_2_PTR(PGMCPU2VM(pPGM), pPage)
    2212 #endif
    2213 
    22142176
    22152177/** @name Per guest page tracking data.

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

    r31123 r31167  
    6969*******************************************************************************/
    7070DECLINLINE(int) pgmShwGetLongModePDPtr(PVMCPU pVCpu, RTGCPTR64 GCPtr, PX86PML4E *ppPml4e, PX86PDPT *ppPdpt, PX86PDPAE *ppPD);
    71 DECLINLINE(int) pgmShwGetPaePoolPagePD(PPGMCPU pPGM, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde);
     71DECLINLINE(int) pgmShwGetPaePoolPagePD(PVMCPU pVCpu, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde);
    7272#ifndef IN_RC
    7373static int pgmShwSyncLongModePDPtr(PVMCPU pVCpu, RTGCPTR64 GCPtr, X86PGPAEUINT uGstPml4e, X86PGPAEUINT uGstPdpe, PX86PDPAE *ppPD);
    … …  
    920920{
    921921    const unsigned iPdPt    = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
    922     PX86PDPT       pPdpt    = pgmShwGetPaePDPTPtr(&pVCpu->pgm.s);
     922    PX86PDPT       pPdpt    = pgmShwGetPaePDPTPtr(pVCpu);
    923923    PX86PDPE       pPdpe    = &pPdpt->a[iPdPt];
    924924    PVM            pVM      = pVCpu->CTX_SUFF(pVM);
    … …  
    10101010 *
    10111011 * @returns Pointer to the PDE.
    1012  * @param   pPGM        Pointer to the PGMCPU instance data.
     1012 * @param   pVCpu       The current CPU.
    10131013 * @param   GCPtr       The address.
    10141014 * @param   ppShwPde    Receives the address of the pgm pool page for the shadow page directory
    10151015 */
    1016 DECLINLINE(int) pgmShwGetPaePoolPagePD(PPGMCPU pPGM, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde)
     1016DECLINLINE(int) pgmShwGetPaePoolPagePD(PVMCPU pVCpu, RTGCPTR GCPtr, PPGMPOOLPAGE *ppShwPde)
    10171017{
    10181018    const unsigned  iPdPt = (GCPtr >> X86_PDPT_SHIFT) & X86_PDPT_MASK_PAE;
    1019     PX86PDPT        pPdpt = pgmShwGetPaePDPTPtr(pPGM);
    1020 
    1021     Assert(PGMIsLockOwner(PGMCPU2VM(pPGM)));
     1019    PX86PDPT        pPdpt = pgmShwGetPaePDPTPtr(pVCpu);
     1020    PVM             pVM   = pVCpu->CTX_SUFF(pVM);
     1021
     1022    Assert(PGMIsLockOwner(pVM));
    10221023
    10231024    AssertReturn(pPdpt, VERR_PAGE_DIRECTORY_PTR_NOT_PRESENT);    /* can't happen */
    … …  
    10301031
    10311032    /* Fetch the pgm pool shadow descriptor. */
    1032     PPGMPOOLPAGE pShwPde = pgmPoolGetPage(PGMCPU2PGM(pPGM)->CTX_SUFF(pPool), pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
     1033    PPGMPOOLPAGE pShwPde = pgmPoolGetPage(pVM->pgm.s.CTX_SUFF(pPool), pPdpt->a[iPdPt].u & X86_PDPE_PG_MASK);
    10331034    AssertReturn(pShwPde, VERR_INTERNAL_ERROR);
    10341035
    … …  
    10601061    PPGMPOOL       pPool         = pVM->pgm.s.CTX_SUFF(pPool);
    10611062    const unsigned iPml4         = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
    1062     PX86PML4E      pPml4e        = pgmShwGetLongModePML4EPtr(pPGM, iPml4);
     1063    PX86PML4E      pPml4e        = pgmShwGetLongModePML4EPtr(pVCpu, iPml4);
    10631064    bool           fNestedPagingOrNoGstPaging = pVM->pgm.s.fNestedPaging || !CPUMIsGuestPagingEnabled(pVCpu);
    10641065    PPGMPOOLPAGE   pShwPage;
    … …  
    11591160    PPGMCPU         pPGM = &pVCpu->pgm.s;
    11601161    const unsigned  iPml4 = (GCPtr >> X86_PML4_SHIFT) & X86_PML4_MASK;
    1161     PCX86PML4E      pPml4e = pgmShwGetLongModePML4EPtr(pPGM, iPml4);
     1162    PCX86PML4E      pPml4e = pgmShwGetLongModePML4EPtr(pVCpu, iPml4);
    11621163
    11631164    Assert(PGMIsLockOwner(PGMCPU2VM(pPGM)));
    … …  
    12021203static int pgmShwGetEPTPDPtr(PVMCPU pVCpu, RTGCPTR64 GCPtr, PEPTPDPT *ppPdpt, PEPTPD *ppPD)
    12031204{
    1204     PPGMCPU        pPGM  = &pVCpu->pgm.s;
    12051205    PVM            pVM   = pVCpu->CTX_SUFF(pVM);
    12061206    const unsigned iPml4 = (GCPtr >> EPT_PML4_SHIFT) & EPT_PML4_MASK;
    … …  
    12141214    Assert(PGMIsLockOwner(pVM));
    12151215
    1216     pPml4 = (PEPTPML4)PGMPOOL_PAGE_2_PTR_BY_PGMCPU(pPGM, pPGM->CTX_SUFF(pShwPageCR3));
     1216    pPml4 = (PEPTPML4)PGMPOOL_PAGE_2_PTR(pVM, pVCpu->pgm.s.CTX_SUFF(pShwPageCR3));
    12171217    Assert(pPml4);
    12181218

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

    r31141 r31167  
    511511#  if PGM_SHW_TYPE == PGM_TYPE_32BIT
    512512    const unsigned  iPDDst = pvFault >> SHW_PD_SHIFT;
    513     PX86PD          pPDDst = pgmShwGet32BitPDPtr(&pVCpu->pgm.s);
     513    PX86PD          pPDDst = pgmShwGet32BitPDPtr(pVCpu);
    514514
    515515#  elif PGM_SHW_TYPE == PGM_TYPE_PAE
    … …  
    10681068# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    10691069    const unsigned  iPDDst    = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
    1070     PX86PDE         pPdeDst   = pgmShwGet32BitPDEPtr(&pVCpu->pgm.s, GCPtrPage);
     1070    PX86PDE         pPdeDst   = pgmShwGet32BitPDEPtr(pVCpu, GCPtrPage);
    10711071
    10721072    /* Fetch the pgm pool shadow descriptor. */
    … …  
    10761076# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    10771077    const unsigned  iPdpt     = (GCPtrPage >> X86_PDPT_SHIFT);
    1078     PX86PDPT        pPdptDst  = pgmShwGetPaePDPTPtr(&pVCpu->pgm.s);
     1078    PX86PDPT        pPdptDst  = pgmShwGetPaePDPTPtr(pVCpu);
    10791079
    10801080    /* If the shadow PDPE isn't present, then skip the invalidate. */
    … …  
    10911091
    10921092    /* Fetch the pgm pool shadow descriptor. */
    1093     rc = pgmShwGetPaePoolPagePD(&pVCpu->pgm.s, GCPtrPage, &pShwPde);
     1093    rc = pgmShwGetPaePoolPagePD(pVCpu, GCPtrPage, &pShwPde);
    10941094    AssertRCSuccessReturn(rc, rc);
    10951095    Assert(pShwPde);
    10961096
    1097     pPDDst             = (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPde);
     1097    pPDDst             = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    10981098    PX86PDEPAE pPdeDst = &pPDDst->a[iPDDst];
    10991099
    … …  
    17271727# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    17281728    const unsigned  iPDDst   = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
    1729     PX86PDE         pPdeDst  = pgmShwGet32BitPDEPtr(&pVCpu->pgm.s, GCPtrPage);
     1729    PX86PDE         pPdeDst  = pgmShwGet32BitPDEPtr(pVCpu, GCPtrPage);
    17301730
    17311731    /* Fetch the pgm pool shadow descriptor. */
    … …  
    17391739
    17401740    /* Fetch the pgm pool shadow descriptor. */
    1741     int rc2 = pgmShwGetPaePoolPagePD(&pVCpu->pgm.s, GCPtrPage, &pShwPde);
     1741    int rc2 = pgmShwGetPaePoolPagePD(pVCpu, GCPtrPage, &pShwPde);
    17421742    AssertRCSuccessReturn(rc2, rc2);
    17431743    Assert(pShwPde);
    17441744
    1745     pPDDst             = (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPde);
     1745    pPDDst             = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    17461746    PX86PDEPAE pPdeDst = &pPDDst->a[iPDDst];
    17471747
    … …  
    20572057     */
    20582058#  if PGM_SHW_TYPE == PGM_TYPE_32BIT
    2059     X86PDE          PdeDst = pgmShwGet32BitPDE(&pVCpu->pgm.s, GCPtrPage);
     2059    X86PDE          PdeDst = pgmShwGet32BitPDE(pVCpu, GCPtrPage);
    20602060
    20612061#  elif PGM_SHW_TYPE == PGM_TYPE_PAE
    2062     X86PDEPAE       PdeDst = pgmShwGetPaePDE(&pVCpu->pgm.s, GCPtrPage);
     2062    X86PDEPAE       PdeDst = pgmShwGetPaePDE(pVCpu, GCPtrPage);
    20632063
    20642064#  elif PGM_SHW_TYPE == PGM_TYPE_AMD64
    … …  
    24802480# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    24812481    const unsigned  iPDDst   = GCPtrPage >> SHW_PD_SHIFT;
    2482     PSHWPDE         pPdeDst  = pgmShwGet32BitPDEPtr(&pVCpu->pgm.s, GCPtrPage);
     2482    PSHWPDE         pPdeDst  = pgmShwGet32BitPDEPtr(pVCpu, GCPtrPage);
    24832483
    24842484    /* Fetch the pgm pool shadow descriptor. */
    … …  
    24932493
    24942494    /* Fetch the pgm pool shadow descriptor. */
    2495     rc = pgmShwGetPaePoolPagePD(&pVCpu->pgm.s, GCPtrPage, &pShwPde);
     2495    rc = pgmShwGetPaePoolPagePD(pVCpu, GCPtrPage, &pShwPde);
    24962496    AssertRCSuccessReturn(rc, rc);
    24972497    Assert(pShwPde);
    24982498
    2499     pPDDst  = (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPde);
     2499    pPDDst  = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    25002500    pPdeDst = &pPDDst->a[iPDDst];
    25012501
    … …  
    29342934# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    29352935    const unsigned  iPDDst  = (GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK;
    2936     PSHWPDE         pPdeDst = pgmShwGet32BitPDEPtr(&pVCpu->pgm.s, GCPtrPage);
     2936    PSHWPDE         pPdeDst = pgmShwGet32BitPDEPtr(pVCpu, GCPtrPage);
    29372937
    29382938    /* Fetch the pgm pool shadow descriptor. */
    … …  
    29472947
    29482948    /* Fetch the pgm pool shadow descriptor. */
    2949     rc = pgmShwGetPaePoolPagePD(&pVCpu->pgm.s, GCPtrPage, &pShwPde);
     2949    rc = pgmShwGetPaePoolPagePD(pVCpu, GCPtrPage, &pShwPde);
    29502950    AssertRCSuccessReturn(rc, rc);
    29512951    Assert(pShwPde);
    29522952
    2953     pPDDst  = (PX86PDPAE)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPde);
     2953    pPDDst  = (PX86PDPAE)PGMPOOL_PAGE_2_PTR(pVM, pShwPde);
    29542954    pPdeDst = &pPDDst->a[iPDDst];
    29552955
    … …  
    31723172
    31733173# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    3174         const X86PDE    PdeDst = pgmShwGet32BitPDE(&pVCpu->pgm.s, GCPtrPage);
     3174        const X86PDE    PdeDst = pgmShwGet32BitPDE(pVCpu, GCPtrPage);
    31753175# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    31763176        const unsigned  iPDDst = ((GCPtrPage >> SHW_PD_SHIFT) & SHW_PD_MASK);
    … …  
    33343334     */
    33353335# if PGM_SHW_TYPE == PGM_TYPE_32BIT
    3336     PX86PDE         pPdeDst = pgmShwGet32BitPDEPtr(&pVCpu->pgm.s, GCPtrPage);
     3336    PX86PDE         pPdeDst = pgmShwGet32BitPDEPtr(pVCpu, GCPtrPage);
    33373337
    33383338# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    … …  
    36563656
    36573657        pPml4eSrc     = pgmGstGetLongModePML4EPtr(pVCpu, iPml4);
    3658         pPml4eDst     = pgmShwGetLongModePML4EPtr(&pVCpu->pgm.s, iPml4);
     3658        pPml4eDst     = pgmShwGetLongModePML4EPtr(pVCpu, iPml4);
    36593659
    36603660        /* Fetch the pgm pool shadow descriptor if the shadow pml4e is present. */
    … …  
    37123712            X86PDPE         PdpeSrc;
    37133713            PGSTPD          pPDSrc    = pgmGstGetPaePDPtr(pVCpu, GCPtr, &iPDSrc, &PdpeSrc);
    3714             PX86PDPT        pPdptDst  = pgmShwGetPaePDPTPtr(&pVCpu->pgm.s);
     3714            PX86PDPT        pPdptDst  = pgmShwGetPaePDPTPtr(pVCpu);
    37153715#  else
    37163716            PX86PML4E       pPml4eSrcIgn;
    … …  
    37803780            GSTPD const    *pPDSrc = pgmGstGet32bitPDPtr(pVCpu);
    37813781#  if PGM_SHW_TYPE == PGM_TYPE_32BIT
    3782             PCX86PD         pPDDst = pgmShwGet32BitPDPtr(&pVCpu->pgm.s);
     3782            PCX86PD         pPDDst = pgmShwGet32BitPDPtr(pVCpu);
    37833783#  endif
    37843784# endif /* PGM_GST_TYPE == PGM_TYPE_32BIT */
    … …  
    37943794            {
    37953795# if PGM_SHW_TYPE == PGM_TYPE_PAE
    3796                 const SHWPDE PdeDst = *pgmShwGetPaePDEPtr(pPGM, GCPtr);
     3796                const SHWPDE PdeDst = *pgmShwGetPaePDEPtr(pVCpu, GCPtr);
    37973797# else
    37983798                const SHWPDE PdeDst = pPDDst->a[iPDDst];

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

    r31123 r31167  
    245245            case PGMMODE_32_BIT:
    246246            {
    247                 PX86PD pShw32BitPd = pgmShwGet32BitPDPtr(&pVCpu->pgm.s);
     247                PX86PD pShw32BitPd = pgmShwGet32BitPDPtr(pVCpu);
    248248                AssertFatal(pShw32BitPd);
    249249#ifdef IN_RC    /* Lock mapping to prevent it from being reused during pgmPoolFree. */
    … …  
    272272                const uint32_t  iPdPt     = iNewPDE / 256;
    273273                unsigned        iPaePde   = iNewPDE * 2 % 512;
    274                 PX86PDPT        pShwPdpt  = pgmShwGetPaePDPTPtr(&pVCpu->pgm.s);
     274                PX86PDPT        pShwPdpt  = pgmShwGetPaePDPTPtr(pVCpu);
    275275                Assert(pShwPdpt);
    276276#ifdef IN_RC    /* Lock mapping to prevent it from being reused during pgmShwSyncPaePDPtr. */
    … …  
    284284                 *       accessed bit causes invalid VT-x guest state errors.
    285285                 */
    286                 PX86PDPAE pShwPaePd = pgmShwGetPaePDPtr(&pVCpu->pgm.s, iPdPt << X86_PDPT_SHIFT);
     286                PX86PDPAE pShwPaePd = pgmShwGetPaePDPtr(pVCpu, iPdPt << X86_PDPT_SHIFT);
    287287                if (!pShwPaePd)
    288288                {
    … …  
    407407        &&  pShwPageCR3 != pVCpu->pgm.s.CTX_SUFF(pShwPageCR3))
    408408    {
    409         pCurrentShwPdpt = pgmShwGetPaePDPTPtr(&pVCpu->pgm.s);
     409        pCurrentShwPdpt = pgmShwGetPaePDPTPtr(pVCpu);
    410410#ifdef IN_RC    /* Lock mapping to prevent it from being reused (currently not possible). */
    411411        if (pCurrentShwPdpt)
    … …  
    426426            case PGMMODE_32_BIT:
    427427            {
    428                 PX86PD          pShw32BitPd = (PX86PD)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPageCR3);
     428                PX86PD          pShw32BitPd = (PX86PD)PGMPOOL_PAGE_2_PTR(pVM, pShwPageCR3);
    429429                AssertFatal(pShw32BitPd);
    430430
    … …  
    439439                const unsigned  iPdpt     = iOldPDE / 256;      /* iOldPDE * 2 / 512; iOldPDE is in 4 MB pages */
    440440                unsigned        iPaePde   = iOldPDE * 2 % 512;
    441                 PX86PDPT        pShwPdpt  = (PX86PDPT)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPageCR3);
    442                 PX86PDPAE       pShwPaePd = pgmShwGetPaePDPtr(&pVCpu->pgm.s, pShwPdpt, (iPdpt << X86_PDPT_SHIFT));
     441                PX86PDPT        pShwPdpt  = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPageCR3);
     442                PX86PDPAE       pShwPaePd = pgmShwGetPaePDPtr(pVCpu, pShwPdpt, (iPdpt << X86_PDPT_SHIFT));
    443443
    444444                /*
    … …  
    538538            case PGMMODE_32_BIT:
    539539            {
    540                 PCX86PD         pShw32BitPd = (PCX86PD)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPageCR3);
     540                PCX86PD         pShw32BitPd = (PCX86PD)PGMPOOL_PAGE_2_PTR(pVM, pShwPageCR3);
    541541                AssertFatal(pShw32BitPd);
    542542
    … …  
    553553                const unsigned  iPdpt     = iPDE / 256;         /* iPDE * 2 / 512; iPDE is in 4 MB pages */
    554554                unsigned        iPaePDE   = iPDE * 2 % 512;
    555                 PX86PDPT        pShwPdpt  = (PX86PDPT)PGMPOOL_PAGE_2_PTR_BY_PGM(&pVM->pgm.s, pShwPageCR3);
    556                 PCX86PDPAE      pShwPaePd = pgmShwGetPaePDPtr(&pVCpu->pgm.s, pShwPdpt, iPdpt << X86_PDPT_SHIFT);
     555                PX86PDPT        pShwPdpt  = (PX86PDPT)PGMPOOL_PAGE_2_PTR(pVM, pShwPageCR3);
     556                PCX86PDPAE      pShwPaePd = pgmShwGetPaePDPtr(pVCpu, pShwPdpt, iPdpt << X86_PDPT_SHIFT);
    557557                AssertFatal(pShwPaePd);
    558558

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

    r31069 r31167  
    151151
    152152    /* PML4 */
    153     X86PML4E        Pml4e = pgmShwGetLongModePML4E(&pVCpu->pgm.s, GCPtr);
     153    X86PML4E        Pml4e = pgmShwGetLongModePML4E(pVCpu, GCPtr);
    154154    if (!Pml4e.n.u1Present)
    155155        return VERR_PAGE_TABLE_NOT_PRESENT;
    … …  
    180180
    181181# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    182     X86PDEPAE       Pde = pgmShwGetPaePDE(&pVCpu->pgm.s, GCPtr);
     182    X86PDEPAE       Pde = pgmShwGetPaePDE(pVCpu, GCPtr);
    183183
    184184# elif PGM_SHW_TYPE == PGM_TYPE_EPT
    … …  
    197197
    198198# else /* PGM_TYPE_32BIT */
    199     X86PDE          Pde = pgmShwGet32BitPDE(&pVCpu->pgm.s, GCPtr);
     199    X86PDE          Pde = pgmShwGet32BitPDE(pVCpu, GCPtr);
    200200# endif
    201201    if (!Pde.n.u1Present)
    … …  
    317317        X86PDEPAE       Pde;
    318318        /* PML4 */
    319         X86PML4E        Pml4e = pgmShwGetLongModePML4E(&pVCpu->pgm.s, GCPtr);
     319        X86PML4E        Pml4e = pgmShwGetLongModePML4E(pVCpu, GCPtr);
    320320        if (!Pml4e.n.u1Present)
    321321            return VERR_PAGE_TABLE_NOT_PRESENT;
    … …  
    340340
    341341# elif PGM_SHW_TYPE == PGM_TYPE_PAE
    342         X86PDEPAE       Pde = pgmShwGetPaePDE(&pVCpu->pgm.s, GCPtr);
     342        X86PDEPAE       Pde = pgmShwGetPaePDE(pVCpu, GCPtr);
    343343
    344344# elif PGM_SHW_TYPE == PGM_TYPE_EPT
    … …  
    357357
    358358# else /* PGM_TYPE_32BIT */
    359         X86PDE          Pde = pgmShwGet32BitPDE(&pVCpu->pgm.s, GCPtr);
     359        X86PDE          Pde = pgmShwGet32BitPDE(pVCpu, GCPtr);
    360360# endif
    361361        if (!Pde.n.u1Present)
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