VirtualBox

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


Ignore:
Timestamp:
May 19, 2009 9:23:34 AM (16 years ago)
Author:
vboxsync
Message:

Invalidate is per VCPU.

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

Legend:

Unmodified
Added
Removed

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

    r19780 r19808  
    332332 */
    333333#ifdef IN_RC
    334 # define PGM_INVL_PG(GCVirt)            ASMInvalidatePage((void *)(GCVirt))
     334# define PGM_INVL_PG(pVCpu, GCVirt)             ASMInvalidatePage((void *)(GCVirt))
    335335#elif defined(IN_RING0)
    336 # define PGM_INVL_PG(GCVirt)            HWACCMInvalidatePage(pVM, (RTGCPTR)(GCVirt))
     336# define PGM_INVL_PG(pVCpu, GCVirt)             HWACCMInvalidatePage(pVCpu, (RTGCPTR)(GCVirt))
    337337#else
    338 # define PGM_INVL_PG(GCVirt)            HWACCMInvalidatePage(pVM, (RTGCPTR)(GCVirt))
     338# define PGM_INVL_PG(pVCpu, GCVirt)             HWACCMInvalidatePage(pVCpu, (RTGCPTR)(GCVirt))
    339339#endif
    340340
    … …  
    345345 */
    346346#ifdef IN_RC
    347 # define PGM_INVL_BIG_PG(GCVirt)        ASMReloadCR3()
     347# define PGM_INVL_BIG_PG(pVCpu, GCVirt)         ASMReloadCR3()
    348348#elif defined(IN_RING0)
    349 # define PGM_INVL_BIG_PG(GCVirt)        HWACCMFlushTLB(pVM)
     349# define PGM_INVL_BIG_PG(pVCpu, GCVirt)         HWACCMFlushTLB(pVCpu)
    350350#else
    351 # define PGM_INVL_BIG_PG(GCVirt)        HWACCMFlushTLB(pVM)
     351# define PGM_INVL_BIG_PG(pVCpu, GCVirt)         HWACCMFlushTLB(pVCpu)
    352352#endif
    353353
    … …  
    356356 */
    357357#ifdef IN_RC
    358 # define PGM_INVL_GUEST_TLBS()          ASMReloadCR3()
     358# define PGM_INVL_GUEST_TLBS(pVCpu)             ASMReloadCR3()
    359359#elif defined(IN_RING0)
    360 # define PGM_INVL_GUEST_TLBS()          HWACCMFlushTLB(pVM)
     360# define PGM_INVL_GUEST_TLBS(pVCpu)             HWACCMFlushTLB(pVCpu)
    361361#else
    362 # define PGM_INVL_GUEST_TLBS()          HWACCMFlushTLB(pVM)
     362# define PGM_INVL_GUEST_TLBS(pVCpu)             HWACCMFlushTLB(pVCpu)
    363363#endif
    364364

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

    r19807 r19808  
    26202620     * Process the request.
    26212621     */
     2622    pgmLock(pVM);
    26222623    int  rc = VINF_SUCCESS;
    26232624    bool fFlushTLB = false;
    26242625    for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     2626    {
    26252627        if (    GCPhys     <= pRom->GCPhysLast
    26262628            &&  GCPhysLast >= pRom->GCPhys
    … …  
    26662668            {
    26672669                int rc = PGMHandlerPhysicalReset(pVM, pRom->GCPhys);
    2668                 AssertRCReturn(rc, rc);
     2670                if (RT_FAILURE(rc))
     2671                {
     2672                    pgmUnlock(pVM);
     2673                    AssertRC(rc);
     2674                    return rc;
     2675                }
    26692676            }
    26702677
    … …  
    26722679            GCPhys = pRom->GCPhys + (cPages << PAGE_SHIFT);
    26732680        }
    2674 
     2681    }
     2682    pgmUnlock(pVM);
    26752683    if (fFlushTLB)
    2676         PGM_INVL_GUEST_TLBS();
     2684        PGM_INVL_GUEST_TLBS(VMMGetCpu(pVM));
     2685
    26772686    return rc;
    26782687}

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

    r19725 r19808  
    30113011        /* AMD64 Architecture Programmer's Manual: 15.15 TLB Control; flush the TLB if MSR_K6_EFER_NXE, MSR_K6_EFER_LME or MSR_K6_EFER_LMA are changed. */
    30123012        if ((oldval & (MSR_K6_EFER_NXE|MSR_K6_EFER_LME|MSR_K6_EFER_LMA)) != (pCtx->msrEFER & (MSR_K6_EFER_NXE|MSR_K6_EFER_LME|MSR_K6_EFER_LMA)))
    3013             HWACCMFlushTLB(pVM);
     3013            HWACCMFlushTLB(pVCpu);
    30143014
    30153015        break;

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

    r19227 r19808  
    4848 *
    4949 * @returns VBox status code.
    50  * @param   pVM         The VM to operate on.
     50 * @param   pVCpu       The VMCPU to operate on.
    5151 * @param   GCVirt      Page to invalidate
    5252 */
    53 VMMDECL(int) HWACCMInvalidatePage(PVM pVM, RTGCPTR GCVirt)
     53VMMDECL(int) HWACCMInvalidatePage(PVMCPU pVCpu, RTGCPTR GCVirt)
    5454{
    5555#ifdef IN_RING0
    56     PVMCPU pVCpu = VMMGetCpu(pVM);
     56    PVM pVM = pVCpu->CTX_SUFF(pVM);
    5757    if (pVM->hwaccm.s.vmx.fSupported)
    5858        return VMXR0InvalidatePage(pVM, pVCpu, GCVirt);
    … …  
    6969 *
    7070 * @returns VBox status code.
    71  * @param   pVM         The VM to operate on.
     71 * @param   pVCpu       The VMCPU to operate on.
    7272 */
    73 VMMDECL(int) HWACCMFlushTLB(PVM pVM)
     73VMMDECL(int) HWACCMFlushTLB(PVMCPU pVCpu)
    7474{
    75     PVMCPU pVCpu = VMMGetCpu(pVM);
    76 
    7775    LogFlow(("HWACCMFlushTLB\n"));
    7876
    … …  
    115113 *
    116114 * @returns VBox status code.
    117  * @param   pVM         The VM to operate on.
     115 * @param   pVCpu       The VMCPU to operate on.
    118116 * @param   GCPhys      Page to invalidate
    119117 */
    120 VMMDECL(int) HWACCMInvalidatePhysPage(PVM pVM, RTGCPHYS GCPhys)
     118VMMDECL(int) HWACCMInvalidatePhysPage(PVMCPU pVCpu, RTGCPHYS GCPhys)
    121119{
     120    PVM pVM = pVCpu->CTX_SUFF(pVM);
     121
    122122    if (!HWACCMIsNestedPagingActive(pVM))
    123123        return VINF_SUCCESS;
    124124
    125125#ifdef IN_RING0
    126     PVMCPU pVCpu = VMMGetCpu(pVM);
    127126    if (pVM->hwaccm.s.vmx.fSupported)
    128127        return VMXR0InvalidatePhysPage(pVM, pVCpu, GCPhys);
    … …  
    131130    SVMR0InvalidatePhysPage(pVM, pVCpu, GCPhys);
    132131#else
    133     HWACCMFlushTLB(pVM);
     132    HWACCMFlushTLB(pVCpu);
    134133#endif
    135134    return VINF_SUCCESS;

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

    r19790 r19808  
    18671867     */
    18681868    if (rc == VINF_SUCCESS)
    1869         PGM_INVL_GUEST_TLBS();
     1869        PGM_INVL_GUEST_TLBS(pVCpu);
    18701870    return rc;
    18711871}
    … …  
    19241924
    19251925    /* Flush the TLB */
    1926     PGM_INVL_GUEST_TLBS();
     1926    PGM_INVL_GUEST_TLBS(pVCpu);
    19271927
    19281928#ifdef IN_RING3

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

    r19791 r19808  
    989989        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    990990        if (!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3))
    991             PGM_INVL_GUEST_TLBS();
     991            PGM_INVL_GUEST_TLBS(pVCpu);
    992992        return VINF_SUCCESS;
    993993    }
    … …  
    10011001        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePageSkipped));
    10021002        if (!VMCPU_FF_ISSET(pVCpu, VMCPU_FF_PGM_SYNC_CR3))
    1003             PGM_INVL_GUEST_TLBS();
     1003            PGM_INVL_GUEST_TLBS(pVCpu);
    10041004        return VINF_SUCCESS;
    10051005    }
    … …  
    10921092        ASMAtomicWriteSize(pPml4eDst, 0);
    10931093        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    1094         PGM_INVL_GUEST_TLBS();
     1094        PGM_INVL_GUEST_TLBS(pVCpu);
    10951095        return VINF_SUCCESS;
    10961096    }
    … …  
    11061106        ASMAtomicWriteSize(pPml4eDst, 0);
    11071107        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    1108         PGM_INVL_GUEST_TLBS();
     1108        PGM_INVL_GUEST_TLBS(pVCpu);
    11091109    }
    11101110    else if (!pPml4eSrc->n.u1Accessed)
    … …  
    11181118        ASMAtomicWriteSize(pPml4eDst, 0);
    11191119        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    1120         PGM_INVL_GUEST_TLBS();
     1120        PGM_INVL_GUEST_TLBS(pVCpu);
    11211121    }
    11221122
    … …  
    11321132        ASMAtomicWriteSize(pPdpeDst, 0);
    11331133        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    1134         PGM_INVL_GUEST_TLBS();
     1134        PGM_INVL_GUEST_TLBS(pVCpu);
    11351135        return VINF_SUCCESS;
    11361136    }
    … …  
    11461146        ASMAtomicWriteSize(pPdpeDst, 0);
    11471147        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    1148         PGM_INVL_GUEST_TLBS();
     1148        PGM_INVL_GUEST_TLBS(pVCpu);
    11491149    }
    11501150    else if (!PdpeSrc.lm.u1Accessed)
    … …  
    11581158        ASMAtomicWriteSize(pPdpeDst, 0);
    11591159        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    1160         PGM_INVL_GUEST_TLBS();
     1160        PGM_INVL_GUEST_TLBS(pVCpu);
    11611161    }
    11621162# endif /* PGM_GST_TYPE == PGM_TYPE_AMD64 */
    … …  
    11901190            ASMAtomicWriteSize(pPdeDst, 0);
    11911191            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    1192             PGM_INVL_GUEST_TLBS();
     1192            PGM_INVL_GUEST_TLBS(pVCpu);
    11931193        }
    11941194        else if (!PdeSrc.n.u1Accessed)
    … …  
    12021202            ASMAtomicWriteSize(pPdeDst, 0);
    12031203            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNAs));
    1204             PGM_INVL_GUEST_TLBS();
     1204            PGM_INVL_GUEST_TLBS(pVCpu);
    12051205        }
    12061206        else if (!fIsBigPage)
    … …  
    12341234# endif
    12351235                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePage4KBPages));
    1236                 PGM_INVL_PG(GCPtrPage);
     1236                PGM_INVL_PG(pVCpu, GCPtrPage);
    12371237            }
    12381238            else
    … …  
    12461246                ASMAtomicWriteSize(pPdeDst, 0);
    12471247                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDOutOfSync));
    1248                 PGM_INVL_GUEST_TLBS();
     1248                PGM_INVL_GUEST_TLBS(pVCpu);
    12491249            }
    12501250        }
    … …  
    12921292            ASMAtomicWriteSize(pPdeDst, 0);
    12931293            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePage4MBPages));
    1294             PGM_INVL_BIG_PG(GCPtrPage);
     1294            PGM_INVL_BIG_PG(pVCpu, GCPtrPage);
    12951295        }
    12961296    }
    … …  
    13051305            ASMAtomicWriteSize(pPdeDst, 0);
    13061306            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,InvalidatePagePDNPs));
    1307             PGM_INVL_PG(GCPtrPage);
     1307            PGM_INVL_PG(pVCpu, GCPtrPage);
    13081308        }
    13091309        else
    … …  
    19201920    PGMDynUnlockHCPage(pVM, (uint8_t *)pPdeDst);
    19211921# endif
    1922     PGM_INVL_GUEST_TLBS();
     1922    PGM_INVL_GUEST_TLBS(pVCpu);
    19231923    return VINF_PGM_SYNCPAGE_MODIFIED_PDE;
    19241924
    … …  
    21812181                    pPdeDst->n.u1Accessed   = 1;
    21822182                    pPdeDst->au32[0]       &= ~PGM_PDFLAGS_TRACK_DIRTY;
    2183                     PGM_INVL_BIG_PG(GCPtrPage);
     2183                    PGM_INVL_BIG_PG(pVCpu, GCPtrPage);
    21842184                    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    21852185                    return VINF_PGM_HANDLED_DIRTY_BIT_FAULT;
    … …  
    22022202                            /* Stale TLB entry. */
    22032203                            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyPageStale));
    2204                             PGM_INVL_PG(GCPtrPage);
     2204                            PGM_INVL_PG(pVCpu, GCPtrPage);
    22052205
    22062206                            STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    … …  
    23202320                            pPteDst->n.u1Accessed = 1;
    23212321                            pPteDst->au32[0]     &= ~PGM_PTFLAGS_TRACK_DIRTY;
    2322                             PGM_INVL_PG(GCPtrPage);
     2322                            PGM_INVL_PG(pVCpu, GCPtrPage);
    23232323
    23242324                            STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    … …  
    23342334                            /* Stale TLB entry. */
    23352335                            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyPageStale));
    2336                             PGM_INVL_PG(GCPtrPage);
     2336                            PGM_INVL_PG(pVCpu, GCPtrPage);
    23372337
    23382338                            STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,DirtyBitTracking), a);
    … …  
    33893389     */
    33903390    /** @todo check if this is really necessary; the call does it as well... */
    3391     HWACCMFlushTLB(pVM);
     3391    HWACCMFlushTLB(pVCpu);
    33923392    return VINF_SUCCESS;
    33933393
    … …  
    42464246        {
    42474247# ifdef IN_RC
    4248             PGM_INVL_PG(pVM->pgm.s.GCPtrCR3Mapping);
     4248            PGM_INVL_PG(pVCpu, pVM->pgm.s.GCPtrCR3Mapping);
    42494249# endif
    42504250# if PGM_GST_TYPE == PGM_TYPE_32BIT
    … …  
    42994299                        pVCpu->pgm.s.aGCPhysGstPaePDs[i]  = GCPhys;
    43004300#  ifdef IN_RC
    4301                         PGM_INVL_PG(GCPtr);
     4301                        PGM_INVL_PG(pVCpu, GCPtr);
    43024302#  endif
    43034303                        continue;
    … …  
    43134313                pVCpu->pgm.s.aGCPhysGstPaePDs[i]  = NIL_RTGCPHYS;
    43144314#  ifdef IN_RC
    4315                 PGM_INVL_PG(GCPtr); /** @todo this shouldn't be necessary? */
     4315                PGM_INVL_PG(pVCpu, GCPtr); /** @todo this shouldn't be necessary? */
    43164316#  endif
    43174317            }

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

    r19807 r19808  
    169169        pVM->pgm.s.fPhysCacheFlushPending = true;
    170170        pgmUnlock(pVM);
    171         HWACCMFlushTLB(pVM);
     171        HWACCMFlushTLB(VMMGetCpu(pVM));
    172172#ifndef IN_RING3
    173173        REMNotifyHandlerPhysicalRegister(pVM, enmType, GCPhys, GCPhysLast - GCPhys + 1, !!pfnHandlerR3);
    … …  
    237237    if (fFlushTLBs && rc == VINF_SUCCESS)
    238238    {
    239         PGM_INVL_GUEST_TLBS();
     239        PGM_INVL_GUEST_TLBS(VMMGetCpu(pVM));
    240240        Log(("pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs: flushing guest TLBs\n"));
    241241    }
    … …  
    271271        pgmHandlerPhysicalDeregisterNotifyREM(pVM, pCur);
    272272        pgmUnlock(pVM);
    273         HWACCMFlushTLB(pVM);
     273        HWACCMFlushTLB(VMMGetCpu(pVM));
    274274        MMHyperFree(pVM, pCur);
    275275        return VINF_SUCCESS;
    … …  
    415415# ifdef IN_RC
    416416    if (fFlushTLBs && rc != VINF_PGM_SYNC_CR3)
    417         PGM_INVL_GUEST_TLBS();
     417        PGM_INVL_GUEST_TLBS(VMMGetCpu0(pVM));
    418418# else
    419     HWACCMFlushTLB(pVM);
     419    HWACCMFlushTLB(VMMGetCpu(pVM));
    420420# endif
    421421    pVM->pgm.s.fPhysCacheFlushPending = true;
    … …  
    553553#endif
    554554                    pgmUnlock(pVM);
    555                     HWACCMFlushTLB(pVM);
     555                    HWACCMFlushTLB(VMMGetCpu(pVM));
    556556                    Log(("PGMHandlerPhysicalModify: GCPhysCurrent=%RGp -> GCPhys=%RGp GCPhysLast=%RGp\n",
    557557                         GCPhysCurrent, GCPhys, GCPhysLast));
    … …  
    848848                    rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
    849849                    pVM->pgm.s.fPhysCacheFlushPending = true;
    850                     HWACCMFlushTLB(pVM);
     850                    HWACCMFlushTLB(VMMGetCpu(pVM));
    851851                }
    852852
    … …  
    920920            PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
    921921#ifndef IN_RC
    922             HWACCMInvalidatePhysPage(pVM, GCPhysPage);
     922            HWACCMInvalidatePhysPage(VMMGetCpu(pVM), GCPhysPage);
    923923#endif
    924924            return VINF_SUCCESS;
    … …  
    10371037
    10381038#ifndef IN_RC
    1039             HWACCMInvalidatePhysPage(pVM, GCPhysPage);
     1039            HWACCMInvalidatePhysPage(VMMGetCpu(pVM), GCPhysPage);
    10401040#endif
    10411041            return VINF_SUCCESS;

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

    r19690 r19808  
    189189
    190190                    /* invalidate tls */
    191                     PGM_INVL_PG((RTGCUINTPTR)pCur->GCPtr + off);
     191                    PGM_INVL_PG(VMMGetCpu(pVM), (RTGCUINTPTR)pCur->GCPtr + off);
    192192
    193193                    /* next */

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

    r19586 r19808  
    344344int pgmPhysAllocPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys)
    345345{
     346    PVMCPU pVCpu = VMMGetCpu(pVM);
    346347    LogFlow(("pgmPhysAllocPage: %R[pgmpage] %RGp\n", pPage, GCPhys));
    347348
    … …  
    369370    {
    370371        if (fFlushTLBs)
    371             PGM_INVL_GUEST_TLBS();
     372            PGM_INVL_GUEST_TLBS(pVCpu);
    372373        Assert(rc2 == VERR_EM_NO_MEMORY);
    373374        return rc2;
    … …  
    424425    if (    fFlushTLBs
    425426        &&  rc != VINF_PGM_GCPHYS_ALIASED)
    426         PGM_INVL_GUEST_TLBS();
     427        PGM_INVL_GUEST_TLBS(pVCpu);
    427428    return rc;
    428429}

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

    r19795 r19808  
    938938
    939939    /* See use in pgmPoolAccessHandlerSimple(). */
    940     PGM_INVL_GUEST_TLBS();
     940    PGM_INVL_GUEST_TLBS(pVCpu);
    941941
    942942    LogFlow(("pgmPoolAccessHandlerPT: returns %Rrc (flushed)\n", rc));
    … …  
    10031003#ifdef IN_RC
    10041004    /* See use in pgmPoolAccessHandlerSimple(). */
    1005     PGM_INVL_GUEST_TLBS();
     1005    PGM_INVL_GUEST_TLBS(pVCpu);
    10061006#endif
    10071007
    … …  
    10741074     * because we need the stale TLBs in some cases (XP boot). This MUST be fixed properly!
    10751075     */
    1076     PGM_INVL_GUEST_TLBS();
     1076    PGM_INVL_GUEST_TLBS(pVCpu);
    10771077#endif
    10781078
    … …  
    12981298    int rc = pgmPoolFlushPage(pPool, pPage);
    12991299    if (rc == VINF_SUCCESS)
    1300         PGM_INVL_GUEST_TLBS(); /* see PT handler. */
     1300        PGM_INVL_GUEST_TLBS(VMMGetCpu(pVM)); /* see PT handler. */
    13011301    return rc;
    13021302}
    … …  
    14671467                    STAM_COUNTER_INC(&pPool->StatCacheKindMismatches);
    14681468                    pgmPoolFlushPage(pPool, pPage);
    1469                     PGM_INVL_GUEST_TLBS(); /* see PT handler. */
     1469                    PGM_INVL_GUEST_TLBS(VMMGetCpu(pVM)); /* see PT handler. */
    14701470                    break;
    14711471                }
    … …  
    20642064    pPool->cPresent = 0;
    20652065    pgmUnlock(pVM);
    2066     PGM_INVL_GUEST_TLBS();
     2066    PGM_INVL_GUEST_TLBS(VMMGetCpu(pVM));
    20672067    STAM_PROFILE_STOP(&pPool->StatClearAll, c);
    20682068    return VINF_SUCCESS;

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

    r18992 r19808  
    359359                Assert(pPT->a[iPTE].n.u1Present);
    360360# if PGM_SHW_TYPE == PGM_TYPE_EPT
    361                 HWACCMInvalidatePhysPage(pVM, (RTGCPHYS)GCPtr);
     361                HWACCMInvalidatePhysPage(pVCpu, (RTGCPHYS)GCPtr);
    362362# else
    363                 PGM_INVL_PG(GCPtr);
     363                PGM_INVL_PG(pVCpu, GCPtr);
    364364# endif
    365365            }
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