VirtualBox

Changeset 17460 in vbox for trunk


Ignore:
Timestamp:
Mar 6, 2009 12:32:59 PM (16 years ago)
Author:
vboxsync
Message:

Again deal with dynamic mappings in RC.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r17458 r17460  
    9090}
    9191
     92/** @def PGMPOOL_PAGE_2_LOCKED_PTR
     93 * Maps a pool page pool into the current context and lock it (RC only).
     94 *
     95 * @returns VBox status code.
     96 * @param   pVM     The VM handle.
     97 * @param   pPage   The pool page.
     98 *
     99 * @remark  In RC this uses PGMGCDynMapHCPage(), so it will consume of the
     100 *          small page window employeed by that function. Be careful.
     101 * @remark  There is no need to assert on the result.
     102 */
     103#if defined(IN_RC)
     104DECLINLINE(void *) PGMPOOL_PAGE_2_LOCKED_PTR(PVM pVM, PPGMPOOLPAGE pPage)
     105{
     106    void *pv = pgmPoolMapPageInlined(&pVM->pgm.s, pPage);
     107
     108    /* Make sure the dynamic mapping will not be reused. */
     109    if (pv)
     110        PGMDynLockHCPage(pVM, (uint8_t *)pv);
     111
     112    return pv;
     113}
     114#else
     115# define PGMPOOL_PAGE_2_LOCKED_PTR(pPGM, pPage)  PGMPOOL_PAGE_2_PTR(pVM, pPage)
     116#endif
     117
     118/** @def PGMPOOL_UNLOCK_PTR
     119 * Unlock a previously locked dynamic caching (RC only).
     120 *
     121 * @returns VBox status code.
     122 * @param   pVM     The VM handle.
     123 * @param   pPage   The pool page.
     124 *
     125 * @remark  In RC this uses PGMGCDynMapHCPage(), so it will consume of the
     126 *          small page window employeed by that function. Be careful.
     127 * @remark  There is no need to assert on the result.
     128 */
     129#if defined(IN_RC)
     130DECLINLINE(void) PGMPOOL_UNLOCK_PTR(PVM pVM, void *pvPage)
     131{
     132    if (pvPage)
     133        PGMDynLockHCPage(pVM, (uint8_t *)pvPage);
     134}
     135#else
     136# define PGMPOOL_UNLOCK_PTR(pPGM, pPage)  do {} while (0)
     137#endif
    92138
    93139#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    … …  
    294340    const unsigned off     = GCPhysFault & PAGE_OFFSET_MASK;
    295341    const unsigned cbWrite = (pCpu) ? pgmPoolDisasWriteSize(pCpu) : 0;
     342    PVM pVM = pPool->CTX_SUFF(pVM);
    296343
    297344    LogFlow(("pgmPoolMonitorChainChanging: %RGv phys=%RGp kind=%s cbWrite=%d\n", (RTGCPTR)pvAddress, GCPhysFault, pgmPoolPoolKindToStr(pPage->enmKind), cbWrite));
    … …  
    309356        } uShw;
    310357
     358        uShw.pv = NULL;
    311359        switch (pPage->enmKind)
    312360        {
    313361            case PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT:
    314362            {
    315                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     363                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    316364                const unsigned iShw = off / sizeof(X86PTE);
    317365                LogFlow(("PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT iShw=%x\n", iShw));
    … …  
    321369                    X86PTE GstPte;
    322370
    323                     int rc = pgmPoolPhysSimpleReadGCPhys(pPool->CTX_SUFF(pVM), &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
     371                    int rc = pgmPoolPhysSimpleReadGCPhys(pVM, &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
    324372                    AssertRC(rc);
    325373                    Log4(("pgmPoolMonitorChainChanging 32_32: deref %016RX64 GCPhys %08RX32\n", uShw.pPT->a[iShw].u & X86_PTE_PAE_PG_MASK, GstPte.u & X86_PTE_PG_MASK));
    … …  
    336384            case PGMPOOLKIND_PAE_PT_FOR_32BIT_PT:
    337385            {
    338                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     386                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    339387                if (!((off ^ pPage->GCPhys) & (PAGE_SIZE / 2)))
    340388                {
    … …  
    345393#  ifdef PGMPOOL_WITH_GCPHYS_TRACKING
    346394                        X86PTE GstPte;
    347                         int rc = pgmPoolPhysSimpleReadGCPhys(pPool->CTX_SUFF(pVM), &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
     395                        int rc = pgmPoolPhysSimpleReadGCPhys(pVM, &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
    348396                        AssertRC(rc);
    349397
    … …  
    368416                unsigned iShwPdpt = iGst / 256;
    369417                unsigned iShw     = (iGst % 256) * 2;
    370                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     418                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    371419
    372420                LogFlow(("pgmPoolMonitorChainChanging PAE for 32 bits: iGst=%x iShw=%x idx = %d page idx=%d\n", iGst, iShw, iShwPdpt, pPage->enmKind - PGMPOOLKIND_PAE_PD0_FOR_32BIT_PD));
    … …  
    378426                        if ((uShw.pPDPae->a[iShw + i].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
    379427                        {
    380                             Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    381                             VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     428                            Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     429                            VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    382430                            LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShwPdpt=%#x iShw=%#x!\n", iShwPdpt, iShw+i));
    383431                            break;
    … …  
    388436                        {
    389437                            LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw+i, uShw.pPDPae->a[iShw+i].u));
    390                             pgmPoolFree(pPool->CTX_SUFF(pVM),
     438                            pgmPoolFree(pVM,
    391439                                        uShw.pPDPae->a[iShw+i].u & X86_PDE_PAE_PG_MASK,
    392440                                        pPage->idx,
    … …  
    406454                                if ((uShw.pPDPae->a[iShw2].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
    407455                                {
    408                                     Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    409                                     VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     456                                    Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     457                                    VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    410458                                    LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShwPdpt=%#x iShw2=%#x!\n", iShwPdpt, iShw2));
    411459                                    break;
    … …  
    416464                                {
    417465                                    LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPae->a[iShw2].u));
    418                                     pgmPoolFree(pPool->CTX_SUFF(pVM),
     466                                    pgmPoolFree(pVM,
    419467                                                uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK,
    420468                                                pPage->idx,
    … …  
    433481            case PGMPOOLKIND_PAE_PT_FOR_PAE_PT:
    434482            {
    435                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     483                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    436484                const unsigned iShw = off / sizeof(X86PTEPAE);
    437485                if (uShw.pPTPae->a[iShw].n.u1Present)
    … …  
    439487#  ifdef PGMPOOL_WITH_GCPHYS_TRACKING
    440488                    X86PTEPAE GstPte;
    441                     int rc = pgmPoolPhysSimpleReadGCPhys(pPool->CTX_SUFF(pVM), &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
     489                    int rc = pgmPoolPhysSimpleReadGCPhys(pVM, &GstPte, pvAddress, GCPhysFault, sizeof(GstPte));
    442490                    AssertRC(rc);
    443491
    … …  
    456504                {
    457505                    const unsigned iShw2 = (off + cbWrite - 1) / sizeof(X86PTEPAE);
    458                     AssertReturnVoid(iShw2 < RT_ELEMENTS(uShw.pPTPae->a));
     506                    AssertBreak(iShw2 < RT_ELEMENTS(uShw.pPTPae->a));
    459507
    460508                    if (uShw.pPTPae->a[iShw2].n.u1Present)
    … …  
    463511                        X86PTEPAE GstPte;
    464512#   ifdef IN_RING3
    465                         int rc = pgmPoolPhysSimpleReadGCPhys(pPool->CTX_SUFF(pVM), &GstPte, (RTHCPTR)((RTHCUINTPTR)pvAddress + sizeof(GstPte)), GCPhysFault + sizeof(GstPte), sizeof(GstPte));
     513                        int rc = pgmPoolPhysSimpleReadGCPhys(pVM, &GstPte, (RTHCPTR)((RTHCUINTPTR)pvAddress + sizeof(GstPte)), GCPhysFault + sizeof(GstPte), sizeof(GstPte));
    466514#   else
    467                         int rc = pgmPoolPhysSimpleReadGCPhys(pPool->CTX_SUFF(pVM), &GstPte, pvAddress + sizeof(GstPte), GCPhysFault + sizeof(GstPte), sizeof(GstPte));
     515                        int rc = pgmPoolPhysSimpleReadGCPhys(pVM, &GstPte, pvAddress + sizeof(GstPte), GCPhysFault + sizeof(GstPte), sizeof(GstPte));
    468516#   endif
    469517                        AssertRC(rc);
    … …  
    485533#  endif
    486534            {
    487                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     535                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    488536                const unsigned iShw = off / sizeof(X86PTE);         // ASSUMING 32-bit guest paging!
    489537
    … …  
    494542                if (uShw.pPD->a[iShw].u & PGM_PDFLAGS_MAPPING)
    495543                {
    496                     Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    497                     VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
    498                     STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
     544                    Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     545                    VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
     546                    STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
    499547                    LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw=%#x!\n", iShw));
    500548                    break;
    … …  
    509557                    {
    510558                        LogFlow(("pgmPoolMonitorChainChanging: 32 bit pd iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPD->a[iShw].u));
    511                         pgmPoolFree(pPool->CTX_SUFF(pVM),
     559                        pgmPoolFree(pVM,
    512560                                    uShw.pPD->a[iShw].u & X86_PDE_PAE_PG_MASK,
    513561                                    pPage->idx,
    … …  
    529577                        if (uShw.pPD->a[iShw2].u & PGM_PDFLAGS_MAPPING)
    530578                        {
    531                             Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    532                             STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
    533                             VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     579                            Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     580                            STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
     581                            VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    534582                            LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw2=%#x!\n", iShw2));
    535583                        }
    … …  
    543591                            {
    544592                                LogFlow(("pgmPoolMonitorChainChanging: 32 bit pd iShw=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPD->a[iShw2].u));
    545                                 pgmPoolFree(pPool->CTX_SUFF(pVM),
     593                                pgmPoolFree(pVM,
    546594                                            uShw.pPD->a[iShw2].u & X86_PDE_PAE_PG_MASK,
    547595                                            pPage->idx,
    … …  
    555603#if 0 /* useful when running PGMAssertCR3(), a bit too troublesome for general use (TLBs). */
    556604                if (    uShw.pPD->a[iShw].n.u1Present
    557                     &&  !VM_FF_ISSET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3))
     605                    &&  !VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    558606                {
    559607                    LogFlow(("pgmPoolMonitorChainChanging: iShw=%#x: %RX32 -> freeing it!\n", iShw, uShw.pPD->a[iShw].u));
    … …  
    561609                    ASMProbeReadByte(pvAddress);
    562610# endif
    563                     pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPD->a[iShw].u & X86_PDE_PG_MASK, pPage->idx, iShw);
     611                    pgmPoolFree(pVM, uShw.pPD->a[iShw].u & X86_PDE_PG_MASK, pPage->idx, iShw);
    564612                    uShw.pPD->a[iShw].u = 0;
    565613                }
    … …  
    577625                PPGMPOOLPAGE pPage2 = pPage + 1 + iShwPdpt;
    578626                Assert(pPage2->idx == PGMPOOL_IDX_PAE_PD_0 + iShwPdpt);
    579                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage2);
     627                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage2);
    580628                for (unsigned i = 0; i < 2; i++, iShw++)
    581629                {
    582630                    if ((uShw.pPDPae->a[iShw].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
    583631                    {
    584                         Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    585                         VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     632                        Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     633                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    586634                        LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShwPdpt=%#x iShw=%#x!\n", iShwPdpt, iShw));
    587635                    }
    … …  
    595643                            &&  (uShw.pPDPae->a[iShw2].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
    596644                        {
    597                             Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    598                             VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     645                            Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     646                            VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    599647                            LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShwPdpt=%#x iShw2=%#x!\n", iShwPdpt, iShw2));
    600648                        }
    … …  
    602650#if 0 /* useful when running PGMAssertCR3(), a bit too troublesome for general use (TLBs). */
    603651                    if (    uShw.pPDPae->a[iShw].n.u1Present
    604                         &&  !VM_FF_ISSET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3))
     652                        &&  !VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    605653                    {
    606654                        LogFlow(("pgmPoolMonitorChainChanging: iShwPdpt=%#x iShw=%#x: %RX64 -> freeing it!\n", iShwPdpt, iShw, uShw.pPDPae->a[iShw].u));
    … …  
    608656                        ASMProbeReadByte(pvAddress);
    609657# endif
    610                         pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, pPage->idx, iShw + iShwPdpt * X86_PG_PAE_ENTRIES);
     658                        pgmPoolFree(pVM, uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, pPage->idx, iShw + iShwPdpt * X86_PG_PAE_ENTRIES);
    611659                        uShw.pPDPae->a[iShw].u = 0;
    612660                    }
    … …  
    619667            case PGMPOOLKIND_PAE_PD_FOR_PAE_PD:
    620668            {
    621                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     669                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    622670                const unsigned iShw = off / sizeof(X86PDEPAE);
    623671#ifndef IN_RING0
    624672                if (uShw.pPDPae->a[iShw].u & PGM_PDFLAGS_MAPPING)
    625673                {
    626                     Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    627                     VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
    628                     STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
     674                    Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     675                    VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
     676                    STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
    629677                    LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw=%#x!\n", iShw));
    630678                    break;
    … …  
    644692                    {
    645693                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPae->a[iShw].u));
    646                         pgmPoolFree(pPool->CTX_SUFF(pVM),
     694                        pgmPoolFree(pVM,
    647695                                    uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK,
    648696# ifdef VBOX_WITH_PGMPOOL_PAGING_ONLY
    … …  
    664712                {
    665713                    const unsigned iShw2 = (off + cbWrite - 1) / sizeof(X86PDEPAE);
    666                     AssertReturnVoid(iShw2 < RT_ELEMENTS(uShw.pPDPae->a));
     714                    AssertBreak(iShw2 < RT_ELEMENTS(uShw.pPDPae->a));
    667715
    668716#ifndef IN_RING0
    … …  
    670718                        &&  uShw.pPDPae->a[iShw2].u & PGM_PDFLAGS_MAPPING)
    671719                    {
    672                         Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    673                         VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
    674                         STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
     720                        Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     721                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
     722                        STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
    675723                        LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw2=%#x!\n", iShw2));
    676724                    }
    … …  
    683731                    {
    684732                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPae->a[iShw2].u));
    685                         pgmPoolFree(pPool->CTX_SUFF(pVM),
     733                        pgmPoolFree(pVM,
    686734                                    uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK,
    687735# ifdef VBOX_WITH_PGMPOOL_PAGING_ONLY
    … …  
    717765                const unsigned offPdpt = off;
    718766# endif
    719                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     767                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    720768                const unsigned iShw = offPdpt / sizeof(X86PDPE);
    721769                if (iShw < X86_PG_PAE_PDPE_ENTRIES)          /* don't use RT_ELEMENTS(uShw.pPDPT->a), because that's for long mode only */
    … …  
    724772                    if (uShw.pPDPT->a[iShw].u & PGM_PLXFLAGS_MAPPING)
    725773                    {
    726                         Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    727                         STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
    728                         VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     774                        Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     775                        STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
     776                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    729777                        LogFlow(("pgmPoolMonitorChainChanging: Detected pdpt conflict at iShw=%#x!\n", iShw));
    730778                        break;
    … …  
    738786                    {
    739787                        LogFlow(("pgmPoolMonitorChainChanging: pae pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPT->a[iShw].u));
    740                         pgmPoolFree(pPool->CTX_SUFF(pVM),
     788                        pgmPoolFree(pVM,
    741789                                    uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK,
    742790                                    pPage->idx,
    … …  
    758806                            if (uShw.pPDPT->a[iShw2].u & PGM_PLXFLAGS_MAPPING)
    759807                            {
    760                                 Assert(pgmMapAreMappingsEnabled(&pPool->CTX_SUFF(pVM)->pgm.s));
    761                                 STAM_COUNTER_INC(&(pPool->CTX_SUFF(pVM)->pgm.s.StatRZGuestCR3WriteConflict));
    762                                 VM_FF_SET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3);
     808                                Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
     809                                STAM_COUNTER_INC(&(pVM->pgm.s.StatRZGuestCR3WriteConflict));
     810                                VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
    763811                                LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw2=%#x!\n", iShw2));
    764812                            }
    … …  
    771819                            {
    772820                                LogFlow(("pgmPoolMonitorChainChanging: pae pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPT->a[iShw2].u));
    773                                 pgmPoolFree(pPool->CTX_SUFF(pVM),
     821                                pgmPoolFree(pVM,
    774822                                            uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK,
    775823                                            pPage->idx,
    … …  
    787835            case PGMPOOLKIND_64BIT_PD_FOR_64BIT_PD:
    788836            {
    789                 uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     837                uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    790838                const unsigned iShw = off / sizeof(X86PDEPAE);
    791839                Assert(!(uShw.pPDPae->a[iShw].u & PGM_PDFLAGS_MAPPING));
    … …  
    793841                {
    794842                    LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPae->a[iShw].u));
    795                     pgmPoolFree(pPool->CTX_SUFF(pVM),
     843                    pgmPoolFree(pVM,
    796844                                uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK,
    797845                                pPage->idx,
    … …  
    805853                {
    806854                    const unsigned iShw2 = (off + cbWrite - 1) / sizeof(X86PDEPAE);
    807                     AssertReturnVoid(iShw2 < RT_ELEMENTS(uShw.pPDPae->a));
     855                    AssertBreak(iShw2 < RT_ELEMENTS(uShw.pPDPae->a));
    808856
    809857                    Assert(!(uShw.pPDPae->a[iShw2].u & PGM_PDFLAGS_MAPPING));
    … …  
    811859                    {
    812860                        LogFlow(("pgmPoolMonitorChainChanging: pae pd iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPae->a[iShw2].u));
    813                         pgmPoolFree(pPool->CTX_SUFF(pVM),
     861                        pgmPoolFree(pVM,
    814862                                    uShw.pPDPae->a[iShw2].u & X86_PDE_PAE_PG_MASK,
    815863                                    pPage->idx,
    … …  
    828876                 */
    829877# ifdef VBOX_WITH_PGMPOOL_PAGING_ONLY
    830                 if (!VM_FF_ISSET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3))
     878                if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    831879# endif
    832880                {
    833                     uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     881                    uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    834882                    const unsigned iShw = off / sizeof(X86PDPE);
    835883                    if (uShw.pPDPT->a[iShw].n.u1Present)
    836884                    {
    837885                        LogFlow(("pgmPoolMonitorChainChanging: pdpt iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPT->a[iShw].u));
    838                         pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK, pPage->idx, iShw);
     886                        pgmPoolFree(pVM, uShw.pPDPT->a[iShw].u & X86_PDPE_PG_MASK, pPage->idx, iShw);
    839887                        uShw.pPDPT->a[iShw].u = 0;
    840888                    }
    … …  
    848896                        {
    849897                            LogFlow(("pgmPoolMonitorChainChanging: pdpt iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPDPT->a[iShw2].u));
    850                             pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK, pPage->idx, iShw2);
     898                            pgmPoolFree(pVM, uShw.pPDPT->a[iShw2].u & X86_PDPE_PG_MASK, pPage->idx, iShw2);
    851899                            uShw.pPDPT->a[iShw2].u = 0;
    852900                        }
    … …  
    863911                 */
    864912# ifdef VBOX_WITH_PGMPOOL_PAGING_ONLY
    865                 if (!VM_FF_ISSET(pPool->CTX_SUFF(pVM), VM_FF_PGM_SYNC_CR3))
     913                if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
    866914# endif
    867915                {
    868                     uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     916                    uShw.pv = PGMPOOL_PAGE_2_LOCKED_PTR(pVM, pPage);
    869917                    const unsigned iShw = off / sizeof(X86PDPE);
    870918                    if (uShw.pPML4->a[iShw].n.u1Present)
    871919                    {
    872920                        LogFlow(("pgmPoolMonitorChainChanging: pml4 iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPML4->a[iShw].u));
    873                         pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPML4->a[iShw].u & X86_PML4E_PG_MASK, pPage->idx, iShw);
     921                        pgmPoolFree(pVM, uShw.pPML4->a[iShw].u & X86_PML4E_PG_MASK, pPage->idx, iShw);
    874922                        uShw.pPML4->a[iShw].u = 0;
    875923                    }
    … …  
    883931                        {
    884932                            LogFlow(("pgmPoolMonitorChainChanging: pml4 iShw2=%#x: %RX64 -> freeing it!\n", iShw2, uShw.pPML4->a[iShw2].u));
    885                             pgmPoolFree(pPool->CTX_SUFF(pVM), uShw.pPML4->a[iShw2].u & X86_PML4E_PG_MASK, pPage->idx, iShw2);
     933                            pgmPoolFree(pVM, uShw.pPML4->a[iShw2].u & X86_PML4E_PG_MASK, pPage->idx, iShw2);
    886934                            uShw.pPML4->a[iShw2].u = 0;
    887935                        }
    … …  
    895943                AssertFatalMsgFailed(("enmKind=%d\n", pPage->enmKind));
    896944        }
     945        PGMPOOL_UNLOCK_PTR(pVM, uShw.pv);
    897946
    898947        /* next */
    … …  
    39163965     * Map the shadow page and take action according to the page kind.
    39173966     */
    3918     void *pvShw = PGMPOOL_PAGE_2_PTR(pPool->CTX_SUFF(pVM), pPage);
     3967    void *pvShw = PGMPOOL_PAGE_2_LOCKED_PTR(pPool->CTX_SUFF(pVM), pPage);
    39193968    switch (pPage->enmKind)
    39203969    {
    … …  
    40324081    STAM_PROFILE_STOP(&pPool->StatZeroPage, z);
    40334082    pPage->fZeroed = true;
     4083    PGMPOOL_UNLOCK_PTR(pPool->CTX_SUFF(pVM), pvShw);
    40344084}
    40354085
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