VirtualBox

Changeset 18666 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Apr 2, 2009 11:10:12 PM (16 years ago)
Author:
vboxsync
Message:

VMM: Clean out the VBOX_WITH_NEW_PHYS_CODE #ifdefs. (part 2)

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

Legend:

Unmodified
Added
Removed

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

    r18338 r18666  
    318318     */
    319319#endif
    320 #ifdef VBOX_WITH_NEW_PHYS_CODE
    321320    return PGMPhysInterpretedReadNoHandlers(pVM, pCtxCore, pvDst, GCPtrSrc, cb, /*fMayTrap*/ false);
    322 #else
    323     NOREF(pCtxCore);
    324 # ifdef IN_RC
    325     RTGCPHYS GCPhys;
    326     rc = PGMPhysGCPtr2GCPhys(pVM, GCPtrSrc, &GCPhys);
    327     AssertRCReturn(rc, rc);
    328     PGMPhysRead(pVM, GCPhys, pvDst, cb);
    329     return VINF_SUCCESS;
    330 # else
    331     return PGMPhysReadGCPtr(pVM, pvDst, GCPtrSrc, cb);
    332 # endif
    333 #endif
    334321}
    335322
    … …  
    349336     */
    350337#endif
    351 #ifdef VBOX_WITH_NEW_PHYS_CODE
    352338    return PGMPhysInterpretedWriteNoHandlers(pVM, pCtxCore, GCPtrDst, pvSrc, cb, /*fMayTrap*/ false);
    353 #else
    354     NOREF(pCtxCore);
    355 # ifdef IN_RC
    356     uint64_t fFlags;
    357     RTGCPHYS GCPhys;
    358     rc = PGMGstGetPage(pVM, GCPtrDst, &fFlags, &GCPhys);
    359     if (RT_FAILURE(rc))
    360         return rc;
    361     if (    !(fFlags & X86_PTE_RW)
    362         &&  (CPUMGetGuestCR0(pVM) & X86_CR0_WP))
    363         return VERR_ACCESS_DENIED;
    364 
    365     PGMPhysWrite(pVM, GCPhys + ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK), pvSrc, cb);
    366     return VINF_SUCCESS;
    367 # else
    368     return PGMPhysWriteGCPtr(pVM, GCPtrDst, pvSrc, cb);
    369 # endif
    370 #endif
    371339}
    372340
    … …  
    13501318        LogFlow(("emInterpretStosWD dest=%04X:%RGv (%RGv) cbSize=%d\n", pRegFrame->es, GCOffset, GCDest, cbSize));
    13511319
    1352 #ifdef VBOX_WITH_NEW_PHYS_CODE
    13531320        rc = emRamWrite(pVM, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
    1354 #else
    1355         rc = PGMPhysWriteGCPtr(pVM, GCDest, &pRegFrame->rax, cbSize);
    1356 #endif
    13571321        if (RT_FAILURE(rc))
    13581322            return VERR_EM_INTERPRETER;
    … …  
    14111375        while (cTransfers)
    14121376        {
    1413 #ifdef VBOX_WITH_NEW_PHYS_CODE
    14141377            rc = emRamWrite(pVM, pRegFrame, GCDest, &pRegFrame->rax, cbSize);
    1415 #else
    1416             rc = PGMPhysWriteGCPtr(pVM, GCDest, &pRegFrame->rax, cbSize);
    1417 #endif
    14181378            if (RT_FAILURE(rc))
    14191379            {

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

    r18234 r18666  
    297297    return MMGCRamWriteNoTrapHandler((void *)GCPtrDst, pvSrc, cb);
    298298#elif IN_RING0
    299 # ifdef VBOX_WITH_NEW_PHYS_CODE /* PGMPhysWriteGCPtr will fail, make sure we ignore handlers here. */
    300299    return PGMPhysInterpretedWriteNoHandlers(pVM, pCtxCore, GCPtrDst, pvSrc, cb, false /*fRaiseTrap*/);
    301 # else
    302     NOREF(pCtxCore);
    303     return PGMPhysWriteGCPtr(pVM, GCPtrDst, pvSrc, cb);
    304 # endif
    305300#else
    306301    NOREF(pCtxCore);
    … …  
    18131808     * Note: This is a NOP in the EPT case; we'll just let it fault again to resync the page.
    18141809     */
    1815 #ifndef VBOX_WITH_NEW_PHYS_CODE /* The assertion is wrong for the PGM_SYNC_CLEAR_PGM_POOL and VINF_PGM_HANDLER_ALREADY_ALIASED cases. */
     1810#if 0 /* The assertion is wrong for the PGM_SYNC_CLEAR_PGM_POOL and VINF_PGM_HANDLER_ALREADY_ALIASED cases. */
    18161811# ifdef VBOX_STRICT
    18171812    uint64_t fFlags;

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

    r18651 r18666  
    13101310}
    13111311
    1312 #ifdef VBOX_WITH_NEW_PHYS_CODE
    13131312#ifdef IN_RING3
    13141313
    … …  
    14671466#endif /* VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R3 */
    14681467
    1469 #endif /* VBOX_WITH_NEW_PHYS_CODE */
    14701468
    14711469/**

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

    r18617 r18666  
    754754                if (RT_SUCCESS(rc) && (uErr & X86_TRAP_PF_RW))
    755755                {
    756 #   ifdef VBOX_WITH_NEW_PHYS_CODE
    757756                    if (PGM_PAGE_GET_STATE(pPage) != PGM_PAGE_STATE_ALLOCATED)
    758757                    {
    … …  
    769768                    }
    770769                    /// @todo count the above case; else
    771 #   endif /* VBOX_WITH_NEW_PHYS_CODE */
    772770                    if (uErr & X86_TRAP_PF_US)
    773771                        STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PageOutOfSyncUser));
    … …  
    14261424        if (RT_SUCCESS(rc))
    14271425        {
    1428 #ifdef VBOX_WITH_NEW_PHYS_CODE
    1429 # ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
     1426#ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
    14301427            /* Try make the page writable if necessary. */
    14311428            if (    PteSrc.n.u1Write
    … …  
    14361433                AssertRC(rc);
    14371434            }
    1438 # endif
    14391435#endif
    14401436
    … …  
    15121508            }
    15131509
    1514 #ifdef VBOX_WITH_NEW_PHYS_CODE
    15151510            /*
    15161511             * Make sure only allocated pages are mapped writable.
    … …  
    15231518                Log3(("SyncPageWorker: write-protecting %RGp pPage=%R[pgmpage]at iPTDst=%d\n", (RTGCPHYS)(PteSrc.u & X86_PTE_PAE_PG_MASK), pPage, iPTDst));
    15241519            }
    1525 #endif
    15261520
    15271521#ifdef PGMPOOL_WITH_USER_TRACKING
    … …  
    18071801                if (RT_SUCCESS(rc))
    18081802                {
    1809 # ifdef VBOX_WITH_NEW_PHYS_CODE
    1810 #  ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
     1803# ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
    18111804                    /* Try make the page writable if necessary. */
    18121805                    if (    PdeSrc.n.u1Write
    … …  
    18171810                        AssertRC(rc);
    18181811                    }
    1819 #  endif
    18201812# endif
    18211813
    … …  
    18381830                        PGM_BTH_NAME(SyncPageWorkerTrackAddref)(pVM, pShwPage, PGM_PAGE_GET_TRACKING(pPage), pPage, iPTDst);
    18391831# endif
    1840 # ifdef VBOX_WITH_NEW_PHYS_CODE
    18411832                    /* Make sure only allocated pages are mapped writable. */
    18421833                    if (    PteDst.n.u1Write
    … …  
    18471838                        Log3(("SyncPage: write-protecting %RGp pPage=%R[pgmpage] at %RGv\n", GCPhys, pPage, GCPtrPage));
    18481839                    }
    1849 # endif
    18501840
    18511841                    pPTDst->a[iPTDst] = PteDst;
    … …  
    27022692                        SHWPTE      PteDst;
    27032693
    2704 # ifdef VBOX_WITH_NEW_PHYS_CODE
    2705 #  ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
     2694# ifndef VBOX_WITH_NEW_LAZY_PAGE_ALLOC
    27062695                        /* Try make the page writable if necessary. */
    27072696                        if (    PteDstBase.n.u1Write
    … …  
    27142703                                break;
    27152704                        }
    2716 #  endif
    2717 # else  /* !VBOX_WITH_NEW_PHYS_CODE */
    2718                         /* Make sure the RAM has already been allocated. */
    2719                         if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)  /** @todo PAGE FLAGS */
    2720                         {
    2721                             if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(pPage)))
    2722                             {
    2723 #  ifdef IN_RING3
    2724                                 int rc = pgmr3PhysGrowRange(pVM, GCPhys);
    2725 #  else
    2726                                 int rc = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhys);
    2727 #  endif
    2728                                 if (rc != VINF_SUCCESS)
    2729                                     return rc;
    2730                             }
    2731                         }
    2732 # endif /* !VBOX_WITH_NEW_PHYS_CODE */
     2705# endif
    27332706
    27342707                        if (PGM_PAGE_HAS_ACTIVE_HANDLERS(pPage))
    … …  
    27552728                            PteDst.u = PGM_PAGE_GET_HCPHYS(pPage) | PteDstBase.u;
    27562729
    2757 # ifdef VBOX_WITH_NEW_PHYS_CODE
    27582730                        /* Only map writable pages writable. */
    27592731                        if (    PteDst.n.u1Write
    … …  
    27642736                            Log3(("SyncPT: write-protecting %RGp pPage=%R[pgmpage] at %RGv\n", GCPhys, pPage, (RTGCPTR)(GCPtr | (iPTDst << SHW_PT_SHIFT))));
    27652737                        }
    2766 # endif
    27672738
    27682739# ifdef PGMPOOL_WITH_USER_TRACKING
    … …  
    41524123    RTHCPTR     HCPtrGuestCR3;
    41534124    RTHCPHYS    HCPhysGuestCR3;
    4154 # ifdef VBOX_WITH_NEW_PHYS_CODE
    41554125    pgmLock(pVM);
    41564126    PPGMPAGE    pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhysCR3);
    … …  
    41584128    HCPhysGuestCR3 = PGM_PAGE_GET_HCPHYS(pPage);
    41594129    /** @todo this needs some reworking wrt. locking.  */
    4160 #  if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
     4130# if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    41614131    HCPtrGuestCR3 = NIL_RTHCPTR;
    41624132    int rc = VINF_SUCCESS;
    4163 #  else
     4133# else
    41644134    int rc = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhysCR3 & GST_CR3_PAGE_MASK, (void **)&HCPtrGuestCR3);
    4165 #  endif
     4135# endif
    41664136    pgmUnlock(pVM);
    4167 # else  /* !VBOX_WITH_NEW_PHYS_CODE */
    4168     int rc = pgmRamGCPhys2HCPtrAndHCPhys(&pVM->pgm.s, GCPhysCR3 & GST_CR3_PAGE_MASK, &HCPtrGuestCR3, &HCPhysGuestCR3);
    4169 # endif /* !VBOX_WITH_NEW_PHYS_CODE */
    41704137    if (RT_SUCCESS(rc))
    41714138    {
    … …  
    42044171                    RTHCPHYS    HCPhys;
    42054172                    RTGCPHYS    GCPhys = pGuestPDPT->a[i].u & X86_PDPE_PG_MASK;
    4206 #  ifdef VBOX_WITH_NEW_PHYS_CODE
    42074173                    pgmLock(pVM);
    42084174                    PPGMPAGE    pPage  = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
    42094175                    AssertReturn(pPage, VERR_INTERNAL_ERROR_2);
    42104176                    HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
    4211 #   if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
     4177#  if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    42124178                    HCPtr = NIL_RTHCPTR;
    42134179                    int rc2 = VINF_SUCCESS;
    4214 #   else
     4180#  else
    42154181                    int rc2 = pgmPhysGCPhys2CCPtrInternal(pVM, pPage, GCPhys, (void **)&HCPtr);
    4216 #   endif
     4182#  endif
    42174183                    pgmUnlock(pVM);
    4218 #  else  /* !VBOX_WITH_NEW_PHYS_CODE */
    4219                     int rc2 = pgmRamGCPhys2HCPtrAndHCPhys(&pVM->pgm.s, GCPhys, &HCPtr, &HCPhys);
    4220 #  endif /* !VBOX_WITH_NEW_PHYS_CODE */
    42214184                    if (RT_SUCCESS(rc2))
    42224185                    {

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

    r18266 r18666  
    115115                    ("Not R0 pointer! pvUserR0=%RHv\n", pvUserR0),
    116116                    VERR_INVALID_PARAMETER);
    117 #ifdef VBOX_WITH_NEW_PHYS_CODE
    118117    AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
    119118    AssertReturn(pfnHandlerR0, VERR_INVALID_PARAMETER);
    120119    AssertReturn(pfnHandlerRC, VERR_INVALID_PARAMETER);
    121 #else
    122     AssertReturn(pfnHandlerR3 || pfnHandlerR0 || pfnHandlerRC, VERR_INVALID_PARAMETER);
    123 #endif
    124120
    125121    /*
    … …  
    219215    for (;;)
    220216    {
    221 #ifndef VBOX_WITH_NEW_PHYS_CODE
    222         /* Physical chunk in dynamically allocated range not present? */
    223         if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(&pRam->aPages[i])))
    224         {
    225             RTGCPHYS GCPhys = pRam->GCPhys + (i << PAGE_SHIFT);
    226 # ifdef IN_RING3
    227             int rc2 = pgmr3PhysGrowRange(pVM, GCPhys);
    228 # else
    229             int rc2 = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhys);
    230 # endif
    231             if (rc2 != VINF_SUCCESS)
    232                 return rc2;
    233         }
    234 
    235 #endif /* !VBOX_WITH_NEW_PHYS_CODE */
    236217        PPGMPAGE pPage = &pRam->aPages[i];
    237 #ifdef VBOX_WITH_NEW_PHYS_CODE
    238218        AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO || PGM_PAGE_IS_MMIO(pPage),
    239219                  ("%RGp %R[pgmpage]\n", pRam->GCPhys + (i << PAGE_SHIFT), pPage));
    240 #endif
    241220
    242221        /* Only do upgrades. */
    … …  
    244223        {
    245224            PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, uState);
    246 #ifndef VBOX_WITH_NEW_PHYS_CODE
    247             Assert(PGM_PAGE_GET_HCPHYS(pPage));
    248 #endif
    249225
    250226            int rc2 = pgmPoolTrackFlushGCPhys(pVM, pPage, &fFlushTLBs);
    … …  
    419395
    420396
    421 #ifdef VBOX_WITH_NEW_PHYS_CODE
    422397/**
    423398 * Resets an aliased page.
    … …  
    457432    NOREF(GCPhysPage);
    458433}
    459 #endif
    460434
    461435
    … …  
    487461        if (RT_SUCCESS(rc))
    488462        {
    489 #ifdef VBOX_WITH_NEW_PHYS_CODE
    490463            /* Reset MMIO2 for MMIO pages to MMIO, since this aliasing is our business.
    491464               (We don't flip MMIO to RAM though, that's PGMPhys.cpp's job.)  */
    … …  
    493466                pgmHandlerPhysicalResetAliasedPage(pVM, pPage, GCPhys);
    494467            AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO || PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", GCPhys, pPage));
    495 #endif
    496468            PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_NONE);
    497469        }
    … …  
    852824                Assert(pRam->GCPhysLast >= pCur->Core.KeyLast);
    853825
    854 #ifdef VBOX_WITH_NEW_PHYS_CODE
    855826                if (pCur->enmType == PGMPHYSHANDLERTYPE_MMIO)
    856827                {
    … …  
    871842                }
    872843                else
    873 #endif
    874844                {
    875845                    /*
    … …  
    1026996            int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPageRemap, &pPageRemap);
    1027997            AssertRCReturn(rc, rc);
    1028 #ifdef VBOX_WITH_NEW_PHYS_CODE
    1029998            AssertMsgReturn(PGM_PAGE_GET_TYPE(pPageRemap) == PGMPAGETYPE_MMIO2,
    1030999                            ("GCPhysPageRemap=%RGp %R[pgmpage]\n", GCPhysPageRemap, pPageRemap),
    10311000                            VERR_PGM_PHYS_NOT_MMIO2);
    1032 #endif
    10331001
    10341002            PPGMPAGE pPage;
    10351003            rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPage, &pPage);
    10361004            AssertRCReturn(rc, rc);
    1037 #ifdef VBOX_WITH_NEW_PHYS_CODE
    10381005            if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
    10391006            {
    … …  
    10531020            }
    10541021            Assert(PGM_PAGE_IS_ZERO(pPage));
    1055 #endif
    10561022
    10571023            /*
    … …  
    10611027            LogFlow(("PGMHandlerPhysicalPageAlias: %RGp (%R[pgmpage]) alias for %RGp (%R[pgmpage])\n",
    10621028                     GCPhysPage, pPage, GCPhysPageRemap, pPageRemap ));
    1063 #ifdef VBOX_WITH_NEW_PHYS_CODE
    10641029            PGM_PAGE_SET_HCPHYS(pPage, PGM_PAGE_GET_HCPHYS(pPageRemap));
    10651030            PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO2_ALIAS_MMIO);
    … …  
    10681033            PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
    10691034            LogFlow(("PGMHandlerPhysicalPageAlias: => %R[pgmpage]\n", pPage));
    1070 #else
    1071             pPage->HCPhys = pPageRemap->HCPhys;
    1072             PGM_PAGE_SET_TRACKING(pPage, 0);
    1073             PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
    1074 #endif
    10751035
    10761036#ifndef IN_RC
    … …  
    16391599                        if (    !REMR3IsPageAccessHandled(pVM, State.GCPhys)
    16401600                                /* ignore shadowed ROM for the time being. */
    1641 # ifdef VBOX_WITH_NEW_PHYS_CODE
    1642                             &&  PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_ROM_SHADOW
    1643 # else
    1644                             &&  (pPage->HCPhys & (MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO2)) != (MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO2)
    1645 # endif
    1646                            )
     1601                            &&  PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_ROM_SHADOW)
    16471602                        {
    16481603                            AssertMsgFailed(("ram range vs phys handler REM mismatch. GCPhys=%RGp state=%d %s\n",

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

    r18617 r18666  
    7575{
    7676    int             rc;
    77 #ifdef VBOX_WITH_NEW_PHYS_CODE
    7877    PPGMROMRANGE    pRom = (PPGMROMRANGE)pvUser;
    7978    uint32_t        iPage = (GCPhysFault - pRom->GCPhys) >> PAGE_SHIFT;
    … …  
    8483        case PGMROMPROT_READ_RAM_WRITE_IGNORE:
    8584        {
    86 #endif
    8785            /*
    8886             * If it's a simple instruction which doesn't change the cpu state
    … …  
    108106            else if (RT_UNLIKELY(rc == VERR_INTERNAL_ERROR))
    109107                return rc;
    110 #ifdef VBOX_WITH_NEW_PHYS_CODE
    111108            break;
    112109        }
    … …  
    126123                                  VERR_INTERNAL_ERROR);
    127124    }
    128 #endif
    129125
    130126    STAM_COUNTER_INC(&pVM->pgm.s.StatRZGuestROMWriteUnhandled);
    … …  
    175171{
    176172    PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
    177 #ifdef VBOX_WITH_NEW_PHYS_CODE
    178173    return pPage
    179174        && PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM;
    180 #else
    181     return pPage
    182         && !(pPage->HCPhys & (MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO2));
    183 #endif
    184175}
    185176
    … …  
    941932VMMDECL(int) PGMPhysGCPhys2CCPtr(PVM pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
    942933{
    943 #ifdef VBOX_WITH_NEW_PHYS_CODE
    944 # if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
     934#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    945935
    946936    /*
    … …  
    956946        {
    957947            *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK)); /** @todo add a read only flag? */
    958 #if 0
     948# if 0
    959949            pLock->pvMap = 0;
    960950            pLock->pvPage = pPage;
    961 #else
     951# else
    962952            pLock->u32Dummy = UINT32_MAX;
    963 #endif
     953# endif
    964954            AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
    965955            rc = VINF_SUCCESS;
    … …  
    967957    }
    968958
    969 # else  /* IN_RING3 || IN_RING0 */
     959#else  /* IN_RING3 || IN_RING0 */
    970960    int rc = pgmLock(pVM);
    971961    AssertRCReturn(rc, rc);
    … …  
    1000990            if (pMap)
    1001991                pMap->cRefs++;
    1002 #if 0 /** @todo implement locking properly */
     992# if 0 /** @todo implement locking properly */
    1003993            if (RT_LIKELY(pPage->cLocks != PGM_PAGE_MAX_LOCKS))
    1004994                if (RT_UNLIKELY(++pPage->cLocks == PGM_PAGE_MAX_LOCKS))
    … …  
    1008998                        pMap->cRefs++; /* Extra ref to prevent it from going away. */
    1009999                }
    1010 #endif
     1000# endif
    10111001            *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
    10121002            pLock->pvPage = pPage;
    … …  
    10181008#endif /* IN_RING3 || IN_RING0 */
    10191009    return rc;
    1020 
    1021 #else
    1022     /*
    1023      * Temporary fallback code.
    1024      */
    1025 # if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    1026 /** @todo @bugref{3202}: check up this path. */
    1027     return PGMDynMapGCPageOff(pVM, GCPhys, ppv);
    1028 # else
    1029     return PGMPhysGCPhys2R3Ptr(pVM, GCPhys, 1, (PRTR3PTR)ppv);
    1030 # endif
    1031 #endif
    10321010}
    10331011
    … …  
    10591037VMMDECL(int) PGMPhysGCPhys2CCPtrReadOnly(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
    10601038{
    1061 #ifdef VBOX_WITH_NEW_PHYS_CODE
    1062 # if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
     1039#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    10631040
    10641041    /*
    … …  
    10741051        {
    10751052            *ppv = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK)); /** @todo add a read only flag? */
    1076 #if 0
     1053# if 0
    10771054            pLock->pvMap = 0;
    10781055            pLock->pvPage = pPage;
    1079 #else
     1056# else
    10801057            pLock->u32Dummy = UINT32_MAX;
    1081 #endif
     1058# endif
    10821059            AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* not returned */, ("%Rrc\n", rc));
    10831060            rc = VINF_SUCCESS;
    … …  
    10851062    }
    10861063
    1087 # else  /* IN_RING3 || IN_RING0 */
     1064#else  /* IN_RING3 || IN_RING0 */
    10881065    int rc = pgmLock(pVM);
    10891066    AssertRCReturn(rc, rc);
    … …  
    11081085            if (pMap)
    11091086                pMap->cRefs++;
    1110 #if 0 /** @todo implement locking properly */
     1087# if 0 /** @todo implement locking properly */
    11111088            if (RT_LIKELY(pPage->cLocks != PGM_PAGE_MAX_LOCKS))
    11121089                if (RT_UNLIKELY(++pPage->cLocks == PGM_PAGE_MAX_LOCKS))
    … …  
    11161093                        pMap->cRefs++; /* Extra ref to prevent it from going away. */
    11171094                }
    1118 #endif
     1095# endif
    11191096            *ppv = (void *)((uintptr_t)pTlbe->pv | (GCPhys & PAGE_OFFSET_MASK));
    11201097            pLock->pvPage = pPage;
    … …  
    11261103#endif /* IN_RING3 || IN_RING0 */
    11271104    return rc;
    1128 
    1129 #else  /* !VBOX_WITH_NEW_PHYS_CODE */
    1130     /*
    1131      * Fallback code.
    1132      */
    1133     return PGMPhysGCPhys2CCPtr(pVM, GCPhys, (void **)ppv, pLock);
    1134 #endif /* !VBOX_WITH_NEW_PHYS_CODE */
    11351105}
    11361106
    … …  
    12191189VMMDECL(void) PGMPhysReleasePageMappingLock(PVM pVM, PPGMPAGEMAPLOCK pLock)
    12201190{
    1221 #ifdef VBOX_WITH_NEW_PHYS_CODE
    12221191#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    12231192    /* currently nothing to do here. */
    … …  
    12511220    }
    12521221#endif /* IN_RING3 */
    1253 #else
    1254     NOREF(pVM);
    1255     NOREF(pLock);
    1256 #endif
    12571222}
    12581223
    … …  
    12781243VMMDECL(int) PGMPhysGCPhys2R3Ptr(PVM pVM, RTGCPHYS GCPhys, RTUINT cbRange, PRTR3PTR pR3Ptr)
    12791244{
    1280 #ifdef VBOX_WITH_NEW_PHYS_CODE
    12811245/** @todo this is kind of hacky and needs some more work. */
    12821246    VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
    12831247
    12841248    Log(("PGMPhysGCPhys2R3Ptr(,%RGp,%#x,): dont use this API!\n", GCPhys, cbRange)); /** @todo eliminate this API! */
    1285 # if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
     1249#if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    12861250    AssertFailedReturn(VERR_NOT_IMPLEMENTED);
    1287 # else
     1251#else
    12881252    pgmLock(pVM);
    12891253
    … …  
    12971261    Assert(rc <= VINF_SUCCESS);
    12981262    return rc;
    1299 # endif
    1300 
    1301 #else  /* !VBOX_WITH_NEW_PHYS_CODE */
    1302 
    1303     if ((GCPhys & PGM_DYNAMIC_CHUNK_BASE_MASK) != ((GCPhys+cbRange-1) & PGM_DYNAMIC_CHUNK_BASE_MASK))
    1304     {
    1305         AssertMsgFailed(("%RGp - %RGp crosses a chunk boundary!!\n", GCPhys, GCPhys+cbRange));
    1306         LogRel(("PGMPhysGCPhys2HCPtr %RGp - %RGp crosses a chunk boundary!!\n", GCPhys, GCPhys+cbRange));
    1307         return VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY;
    1308     }
    1309 
    1310     PPGMRAMRANGE pRam;
    1311     PPGMPAGE pPage;
    1312     int rc = pgmPhysGetPageAndRangeEx(&pVM->pgm.s, GCPhys, &pPage, &pRam);
    1313     if (RT_FAILURE(rc))
    1314         return rc;
    1315 
    1316 #ifndef PGM_IGNORE_RAM_FLAGS_RESERVED
    1317     if (RT_UNLIKELY(PGM_PAGE_IS_RESERVED(pPage)))
    1318         return VERR_PGM_PHYS_PAGE_RESERVED;
    13191263#endif
    1320 
    1321     RTGCPHYS off = GCPhys - pRam->GCPhys;
    1322     if (RT_UNLIKELY(off + cbRange > pRam->cb))
    1323     {
    1324         AssertMsgFailed(("%RGp - %RGp crosses a chunk boundary!!\n", GCPhys, GCPhys + cbRange));
    1325         return VERR_PGM_GCPHYS_RANGE_CROSSES_BOUNDARY;
    1326     }
    1327 
    1328     if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
    1329     {
    1330         unsigned iChunk = (off >> PGM_DYNAMIC_CHUNK_SHIFT);
    1331 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0) /* ASSUMES this is a rare occurence */
    1332         PRTR3UINTPTR paChunkR3Ptrs = (PRTR3UINTPTR)MMHyperR3ToCC(pVM, pRam->paChunkR3Ptrs);
    1333         *pR3Ptr = (RTR3PTR)(paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
    1334 #else
    1335         *pR3Ptr = (RTR3PTR)(pRam->paChunkR3Ptrs[iChunk] + (off & PGM_DYNAMIC_CHUNK_OFFSET_MASK));
    1336 #endif
    1337     }
    1338     else if (RT_LIKELY(pRam->pvR3))
    1339         *pR3Ptr = (RTR3PTR)((RTR3UINTPTR)pRam->pvR3 + off);
    1340     else
    1341         return VERR_PGM_PHYS_PAGE_RESERVED;
    1342     return VINF_SUCCESS;
    1343 #endif /* !VBOX_WITH_NEW_PHYS_CODE */
    13441264}
    13451265
    … …  
    14201340VMMDECL(int) PGMPhysGCPtr2R3Ptr(PVM pVM, RTGCPTR GCPtr, PRTR3PTR pR3Ptr)
    14211341{
    1422 #ifdef VBOX_WITH_NEW_PHYS_CODE
    14231342    VM_ASSERT_EMT(pVM); /* no longer safe for use outside the EMT thread! */
    1424 #endif
    1425 
    14261343    RTGCPHYS GCPhys;
    14271344    int rc = PGM_GST_PFN(GetPage,pVM)(pVM, (RTGCUINTPTR)GCPtr, NULL, &GCPhys);
    … …  
    14661383#endif /* IN_RING3 */
    14671384
    1468 #ifdef VBOX_WITH_NEW_PHYS_CODE
    14691385
    14701386/**
    … …  
    16901606}
    16911607
    1692 #else /* Old PGMPhysRead */
    1693 
    1694 /**
    1695  * Read physical memory.
    1696  *
    1697  * This API respects access handlers and MMIO. Use PGMPhysSimpleReadGCPhys() if you
    1698  * want to ignore those.
    1699  *
    1700  * @param   pVM             VM Handle.
    1701  * @param   GCPhys          Physical address start reading from.
    1702  * @param   pvBuf           Where to put the read bits.
    1703  * @param   cbRead          How many bytes to read.
    1704  */
    1705 VMMDECL(void) PGMPhysRead(PVM pVM, RTGCPHYS GCPhys, void *pvBuf, size_t cbRead)
    1706 {
    1707 #ifdef IN_RING3
    1708     bool fGrabbedLock = false;
    1709 #endif
    1710 
    1711     AssertMsg(cbRead > 0, ("don't even think about reading zero bytes!\n"));
    1712     if (cbRead == 0)
    1713         return;
    1714 
    1715     LogFlow(("PGMPhysRead: %RGp %d\n", GCPhys, cbRead));
    1716 
    1717 #ifdef IN_RING3
    1718     if (!VM_IS_EMT(pVM))
    1719     {
    1720         pgmLock(pVM);
    1721         fGrabbedLock = true;
    1722     }
    1723 #endif
    1724 
    1725     /*
    1726      * Copy loop on ram ranges.
    1727      */
    1728     PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
    1729     for (;;)
    1730     {
    1731         /* Find range. */
    1732         while (pRam && GCPhys > pRam->GCPhysLast)
    1733             pRam = pRam->CTX_SUFF(pNext);
    1734         /* Inside range or not? */
    1735         if (pRam && GCPhys >= pRam->GCPhys)
    1736         {
    1737             /*
    1738              * Must work our way thru this page by page.
    1739              */
    1740             RTGCPHYS off = GCPhys - pRam->GCPhys;
    1741             while (off < pRam->cb)
    1742             {
    1743                 unsigned iPage = off >> PAGE_SHIFT;
    1744                 PPGMPAGE pPage = &pRam->aPages[iPage];
    1745                 size_t   cb;
    1746 
    1747                 /* Physical chunk in dynamically allocated range not present? */
    1748                 if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(pPage)))
    1749                 {
    1750                     /* Treat it as reserved; return zeros */
    1751                     cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1752                     if (cb >= cbRead)
    1753                     {
    1754                         memset(pvBuf, 0, cbRead);
    1755                         goto l_End;
    1756                     }
    1757                     memset(pvBuf, 0, cb);
    1758                 }
    1759                 /* temp hacks, will be reorganized. */
    1760                 /*
    1761                  * Physical handler.
    1762                  */
    1763                 else if (   RT_UNLIKELY(PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) >= PGM_PAGE_HNDL_PHYS_STATE_ALL)
    1764                          && !(pPage->HCPhys & MM_RAM_FLAGS_MMIO)) /// @todo PAGE FLAGS
    1765                 {
    1766                     int rc = VINF_PGM_HANDLER_DO_DEFAULT;
    1767                     cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1768 
    1769 #ifdef IN_RING3 /** @todo deal with this in GC and R0! */
    1770                     /* find and call the handler */
    1771                     PPGMPHYSHANDLER pNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesR3->PhysHandlers, GCPhys);
    1772                     if (pNode && pNode->pfnHandlerR3)
    1773                     {
    1774                         size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    1775                         if (cbRange < cb)
    1776                             cb = cbRange;
    1777                         if (cb > cbRead)
    1778                             cb = cbRead;
    1779 
    1780                         void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
    1781 
    1782                         /* Note! Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
    1783                         rc = pNode->pfnHandlerR3(pVM, GCPhys, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, pNode->pvUserR3);
    1784                     }
    1785 #endif /* IN_RING3 */
    1786                     if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
    1787                     {
    1788 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    1789                         void *pvSrc = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    1790 #else
    1791                         void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
    1792 #endif
    1793 
    1794                         if (cb >= cbRead)
    1795                         {
    1796                             memcpy(pvBuf, pvSrc, cbRead);
    1797                             goto l_End;
    1798                         }
    1799                         memcpy(pvBuf, pvSrc, cb);
    1800                     }
    1801                     else if (cb >= cbRead)
    1802                         goto l_End;
    1803                 }
    1804                 /*
    1805                  * Virtual handlers.
    1806                  */
    1807                 else if (   RT_UNLIKELY(PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) >= PGM_PAGE_HNDL_VIRT_STATE_ALL)
    1808                          && !(pPage->HCPhys & MM_RAM_FLAGS_MMIO)) /// @todo PAGE FLAGS
    1809                 {
    1810                     int rc = VINF_PGM_HANDLER_DO_DEFAULT;
    1811                     cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1812 #ifdef IN_RING3 /** @todo deal with this in GC and R0! */
    1813                     /* Search the whole tree for matching physical addresses (rather expensive!) */
    1814                     PPGMVIRTHANDLER pNode;
    1815                     unsigned iPage;
    1816                     int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
    1817                     if (RT_SUCCESS(rc2) && pNode->pfnHandlerR3)
    1818                     {
    1819                         size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    1820                         if (cbRange < cb)
    1821                             cb = cbRange;
    1822                         if (cb > cbRead)
    1823                             cb = cbRead;
    1824                         RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pNode->Core.Key & PAGE_BASE_GC_MASK)
    1825                                           + (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
    1826 
    1827                         void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
    1828 
    1829                         /* Note! Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
    1830                         rc = pNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, 0);
    1831                     }
    1832 #endif /* IN_RING3 */
    1833                     if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
    1834                     {
    1835 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    1836                         void *pvSrc = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    1837 #else
    1838                         void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
    1839 #endif
    1840                         if (cb >= cbRead)
    1841                         {
    1842                             memcpy(pvBuf, pvSrc, cbRead);
    1843                             goto l_End;
    1844                         }
    1845                         memcpy(pvBuf, pvSrc, cb);
    1846                     }
    1847                     else if (cb >= cbRead)
    1848                         goto l_End;
    1849                 }
    1850                 else
    1851                 {
    1852                     switch (pPage->HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_ROM)) /** @todo PAGE FLAGS */
    1853                     {
    1854                         /*
    1855                          * Normal memory or ROM.
    1856                          */
    1857                         case 0:
    1858                         case MM_RAM_FLAGS_ROM:
    1859                         case MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_RESERVED:
    1860                         //case MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO2: /* = shadow */ - //MMIO2 isn't in the mask.
    1861                         case MM_RAM_FLAGS_MMIO2: // MMIO2 isn't in the mask.
    1862                         {
    1863 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    1864                             void *pvSrc = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    1865 #else
    1866                             void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
    1867 #endif
    1868                             cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1869                             if (cb >= cbRead)
    1870                             {
    1871 #if defined(IN_RING3) && defined(PGM_PHYSMEMACCESS_CACHING)
    1872                                 if (cbRead <= 4 && !fGrabbedLock /* i.e. EMT */)
    1873                                     pgmPhysCacheAdd(pVM, &pVM->pgm.s.pgmphysreadcache, GCPhys, (uint8_t*)pvSrc);
    1874 #endif /* IN_RING3 && PGM_PHYSMEMACCESS_CACHING */
    1875                                 memcpy(pvBuf, pvSrc, cbRead);
    1876                                 goto l_End;
    1877                             }
    1878                             memcpy(pvBuf, pvSrc, cb);
    1879                             break;
    1880                         }
    1881 
    1882                         /*
    1883                          * All reserved, nothing there.
    1884                          */
    1885                         case MM_RAM_FLAGS_RESERVED:
    1886                             cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1887                             if (cb >= cbRead)
    1888                             {
    1889                                 memset(pvBuf, 0, cbRead);
    1890                                 goto l_End;
    1891                             }
    1892                             memset(pvBuf, 0, cb);
    1893                             break;
    1894 
    1895                         /*
    1896                          * The rest needs to be taken more carefully.
    1897                          */
    1898                         default:
    1899 #if 1                   /** @todo r=bird: Can you do this properly please. */
    1900                             /** @todo Try MMIO; quick hack */
    1901                             if (cbRead <= 8 && IOMMMIORead(pVM, GCPhys, (uint32_t *)pvBuf, cbRead) == VINF_SUCCESS)
    1902                                 goto l_End;
    1903 #endif
    1904 
    1905                             /** @todo fix me later. */
    1906                             AssertReleaseMsgFailed(("Unknown read at %RGp size %u implement the complex physical reading case %RHp\n",
    1907                                                     GCPhys, cbRead,
    1908                                                     pPage->HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_ROM))); /** @todo PAGE FLAGS */
    1909                             cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    1910                             break;
    1911                     }
    1912                 }
    1913 
    1914                 cbRead -= cb;
    1915                 off    += cb;
    1916                 pvBuf   = (char *)pvBuf + cb;
    1917             }
    1918 
    1919             GCPhys = pRam->GCPhysLast + 1;
    1920         }
    1921         else
    1922         {
    1923             LogFlow(("PGMPhysRead: Unassigned %RGp size=%u\n", GCPhys, cbRead));
    1924 
    1925             /*
    1926              * Unassigned address space.
    1927              */
    1928             size_t cb;
    1929             if (    !pRam
    1930                 ||  (cb = pRam->GCPhys - GCPhys) >= cbRead)
    1931             {
    1932                 memset(pvBuf, 0, cbRead);
    1933                 goto l_End;
    1934             }
    1935 
    1936             memset(pvBuf, 0, cb); /** @todo this is wrong, unassigne == 0xff not 0x00! */
    1937             cbRead -= cb;
    1938             pvBuf   = (char *)pvBuf + cb;
    1939             GCPhys += cb;
    1940         }
    1941     }
    1942 l_End:
    1943 #ifdef IN_RING3
    1944     if (fGrabbedLock)
    1945         pgmUnlock(pVM);
    1946 #endif
    1947     return;
    1948 }
    1949 
    1950 #endif /* Old PGMPhysRead */
    1951 #ifdef VBOX_WITH_NEW_PHYS_CODE
    19521608
    19531609/**
    … …  
    24112067}
    24122068
    2413 #else /* Old PGMPhysWrite */
    2414 
    2415 /**
    2416  * Write to physical memory.
    2417  *
    2418  * This API respects access handlers and MMIO. Use PGMPhysSimpleReadGCPhys() if you
    2419  * want to ignore those.
    2420  *
    2421  * @param   pVM             VM Handle.
    2422  * @param   GCPhys          Physical address to write to.
    2423  * @param   pvBuf           What to write.
    2424  * @param   cbWrite         How many bytes to write.
    2425  */
    2426 VMMDECL(void) PGMPhysWrite(PVM pVM, RTGCPHYS GCPhys, const void *pvBuf, size_t cbWrite)
    2427 {
    2428 #ifdef IN_RING3
    2429     bool fGrabbedLock = false;
    2430 #endif
    2431 
    2432     AssertMsg(!pVM->pgm.s.fNoMorePhysWrites, ("Calling PGMPhysWrite after pgmR3Save()!\n"));
    2433     AssertMsg(cbWrite > 0, ("don't even think about writing zero bytes!\n"));
    2434     if (cbWrite == 0)
    2435         return;
    2436 
    2437     LogFlow(("PGMPhysWrite: %RGp %d\n", GCPhys, cbWrite));
    2438 
    2439 #ifdef IN_RING3
    2440     if (!VM_IS_EMT(pVM))
    2441     {
    2442         pgmLock(pVM);
    2443         fGrabbedLock = true;
    2444     }
    2445 #endif
    2446     /*
    2447      * Copy loop on ram ranges.
    2448      */
    2449     PPGMRAMRANGE    pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
    2450     for (;;)
    2451     {
    2452         /* Find range. */
    2453         while (pRam && GCPhys > pRam->GCPhysLast)
    2454             pRam = pRam->CTX_SUFF(pNext);
    2455         /* Inside range or not? */
    2456         if (pRam && GCPhys >= pRam->GCPhys)
    2457         {
    2458             /*
    2459              * Must work our way thru this page by page.
    2460              */
    2461             RTGCPTR off = GCPhys - pRam->GCPhys;
    2462             while (off < pRam->cb)
    2463             {
    2464                 RTGCPTR     iPage = off >> PAGE_SHIFT;
    2465                 PPGMPAGE    pPage = &pRam->aPages[iPage];
    2466 
    2467                 /* Physical chunk in dynamically allocated range not present? */
    2468                 if (RT_UNLIKELY(!PGM_PAGE_GET_HCPHYS(pPage)))
    2469                 {
    2470                     int         rc;
    2471                     RTGCPHYS    GCPhysPage = pRam->GCPhys + off;
    2472 #ifdef IN_RING3
    2473                     if (fGrabbedLock)
    2474                     {
    2475                         pgmUnlock(pVM);
    2476                         rc = pgmr3PhysGrowRange(pVM, GCPhysPage);
    2477                         if (rc == VINF_SUCCESS)
    2478                             PGMPhysWrite(pVM, GCPhysPage, pvBuf, cbWrite); /* try again; can't assume pRam is still valid (paranoia) */
    2479                         return;
    2480                     }
    2481                     rc = pgmr3PhysGrowRange(pVM, GCPhysPage);
    2482 #else
    2483                     rc = CTXALLMID(VMM, CallHost)(pVM, VMMCALLHOST_PGM_RAM_GROW_RANGE, GCPhysPage);
    2484 #endif
    2485                     if (rc != VINF_SUCCESS)
    2486                         goto l_End;
    2487                 }
    2488 
    2489                 size_t   cb;
    2490                 /* temporary hack, will reogranize is later. */
    2491                 /*
    2492                  * Virtual handlers
    2493                  */
    2494                 if (    PGM_PAGE_HAS_ACTIVE_VIRTUAL_HANDLERS(pPage)
    2495                     && !(pPage->HCPhys & MM_RAM_FLAGS_MMIO)) /// @todo PAGE FLAGS
    2496                 {
    2497                     if (PGM_PAGE_HAS_ACTIVE_PHYSICAL_HANDLERS(pPage))
    2498                     {
    2499                         /*
    2500                          * Physical write handler + virtual write handler.
    2501                          * Consider this a quick workaround for the CSAM + shadow caching problem.
    2502                          *
    2503                          * We hand it to the shadow caching first since it requires the unchanged
    2504                          * data. CSAM will have to put up with it already being changed.
    2505                          */
    2506                         int rc = VINF_PGM_HANDLER_DO_DEFAULT;
    2507                         cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    2508 #ifdef IN_RING3 /** @todo deal with this in GC and R0! */
    2509                         /* 1. The physical handler */
    2510                         PPGMPHYSHANDLER pPhysNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesR3->PhysHandlers, GCPhys);
    2511                         if (pPhysNode && pPhysNode->pfnHandlerR3)
    2512                         {
    2513                             size_t cbRange = pPhysNode->Core.KeyLast - GCPhys + 1;
    2514                             if (cbRange < cb)
    2515                                 cb = cbRange;
    2516                             if (cb > cbWrite)
    2517                                 cb = cbWrite;
    2518 
    2519                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2520 
    2521                             /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
    2522                             rc = pPhysNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pPhysNode->pvUserR3);
    2523                         }
    2524 
    2525                         /* 2. The virtual handler (will see incorrect data) */
    2526                         PPGMVIRTHANDLER pVirtNode;
    2527                         unsigned iPage;
    2528                         int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirtNode, &iPage);
    2529                         if (RT_SUCCESS(rc2) && pVirtNode->pfnHandlerR3)
    2530                         {
    2531                             size_t cbRange = pVirtNode->Core.KeyLast - GCPhys + 1;
    2532                             if (cbRange < cb)
    2533                                 cb = cbRange;
    2534                             if (cb > cbWrite)
    2535                                 cb = cbWrite;
    2536                             RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirtNode->Core.Key & PAGE_BASE_GC_MASK)
    2537                                               + (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
    2538 
    2539                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2540 
    2541                             /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
    2542                             rc2 = pVirtNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
    2543                             if (    (   rc2 != VINF_PGM_HANDLER_DO_DEFAULT
    2544                                      && rc == VINF_PGM_HANDLER_DO_DEFAULT)
    2545                                 ||  (   RT_FAILURE(rc2)
    2546                                      && RT_SUCCESS(rc)))
    2547                                 rc = rc2;
    2548                         }
    2549 #endif /* IN_RING3 */
    2550                         if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
    2551                         {
    2552 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2553                             void *pvDst = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    2554 #else
    2555                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2556 #endif
    2557                             if (cb >= cbWrite)
    2558                             {
    2559                                 memcpy(pvDst, pvBuf, cbWrite);
    2560                                 goto l_End;
    2561                             }
    2562                             memcpy(pvDst, pvBuf, cb);
    2563                         }
    2564                         else if (cb >= cbWrite)
    2565                             goto l_End;
    2566                     }
    2567                     else
    2568                     {
    2569                         int rc = VINF_PGM_HANDLER_DO_DEFAULT;
    2570                         cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    2571 #ifdef IN_RING3
    2572 /** @todo deal with this in GC and R0! */
    2573                         /* Search the whole tree for matching physical addresses (rather expensive!) */
    2574                         PPGMVIRTHANDLER pNode;
    2575                         unsigned iPage;
    2576                         int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
    2577                         if (RT_SUCCESS(rc2) && pNode->pfnHandlerR3)
    2578                         {
    2579                             size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    2580                             if (cbRange < cb)
    2581                                 cb = cbRange;
    2582                             if (cb > cbWrite)
    2583                                 cb = cbWrite;
    2584                             RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pNode->Core.Key & PAGE_BASE_GC_MASK)
    2585                                               + (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
    2586 
    2587                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2588 
    2589                             /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
    2590                             rc = pNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
    2591                         }
    2592 #endif /* IN_RING3 */
    2593                         if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
    2594                         {
    2595 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2596                             void *pvDst = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    2597 #else
    2598                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2599 #endif
    2600                             if (cb >= cbWrite)
    2601                             {
    2602                                 memcpy(pvDst, pvBuf, cbWrite);
    2603                                 goto l_End;
    2604                             }
    2605                             memcpy(pvDst, pvBuf, cb);
    2606                         }
    2607                         else if (cb >= cbWrite)
    2608                             goto l_End;
    2609                     }
    2610                 }
    2611                 /*
    2612                  * Physical handler.
    2613                  */
    2614                 else if (   RT_UNLIKELY(PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) >= PGM_PAGE_HNDL_PHYS_STATE_WRITE)
    2615                          && !(pPage->HCPhys & MM_RAM_FLAGS_MMIO)) /// @todo PAGE FLAGS
    2616                 {
    2617                     int rc = VINF_PGM_HANDLER_DO_DEFAULT;
    2618                     cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    2619 #ifdef IN_RING3 /** @todo deal with this in GC and R0! */
    2620                     /* find and call the handler */
    2621                     PPGMPHYSHANDLER pNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesR3->PhysHandlers, GCPhys);
    2622                     if (pNode && pNode->pfnHandlerR3)
    2623                     {
    2624                         size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
    2625                         if (cbRange < cb)
    2626                             cb = cbRange;
    2627                         if (cb > cbWrite)
    2628                             cb = cbWrite;
    2629 
    2630                         void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2631 
    2632                         /** @todo Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
    2633                         rc = pNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pNode->pvUserR3);
    2634                     }
    2635 #endif /* IN_RING3 */
    2636                     if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
    2637                     {
    2638 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2639                         void *pvDst = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    2640 #else
    2641                         void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2642 #endif
    2643                         if (cb >= cbWrite)
    2644                         {
    2645                             memcpy(pvDst, pvBuf, cbWrite);
    2646                             goto l_End;
    2647                         }
    2648                         memcpy(pvDst, pvBuf, cb);
    2649                     }
    2650                     else if (cb >= cbWrite)
    2651                         goto l_End;
    2652                 }
    2653                 else
    2654                 {
    2655                     /** @todo r=bird: missing MM_RAM_FLAGS_ROM here, we shall not allow anyone to overwrite the ROM! */
    2656                     switch (pPage->HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_MMIO2)) /** @todo PAGE FLAGS */
    2657                     {
    2658                         /*
    2659                          * Normal memory, MMIO2 or writable shadow ROM.
    2660                          */
    2661                         case 0:
    2662                         case MM_RAM_FLAGS_MMIO2:
    2663                         case MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO2: /* shadow rom */
    2664                         {
    2665 #if defined(IN_RC) || defined(VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0)
    2666                             void *pvDst = pgmDynMapHCPageOff(&pVM->pgm.s, PGM_PAGE_GET_HCPHYS(pPage) + (off & PAGE_OFFSET_MASK));
    2667 #else
    2668                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
    2669 #endif
    2670                             cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    2671                             if (cb >= cbWrite)
    2672                             {
    2673 #if defined(IN_RING3) && defined(PGM_PHYSMEMACCESS_CACHING)
    2674                                 if (cbWrite <= 4 && !fGrabbedLock /* i.e. EMT */)
    2675                                     pgmPhysCacheAdd(pVM, &pVM->pgm.s.pgmphyswritecache, GCPhys, (uint8_t*)pvDst);
    2676 #endif /* IN_RING3 && PGM_PHYSMEMACCESS_CACHING */
    2677                                 memcpy(pvDst, pvBuf, cbWrite);
    2678                                 goto l_End;
    2679                             }
    2680                             memcpy(pvDst, pvBuf, cb);
    2681                             break;
    2682                         }
    2683 
    2684                         /*
    2685                          * All reserved, nothing there.
    2686                          */
    2687                         case MM_RAM_FLAGS_RESERVED:
    2688                         case MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO2:
    2689                             cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
    2690                             if (cb >= cbWrite)
    2691                                 goto l_End;
    2692                             break;
    2693 
    2694 
    2695                         /*
    2696                          * The rest needs to be taken more carefully.
    2697                          */
    2698                         default:
    2699 #if 1                   /** @todo r=bird: Can you do this properly please. */
    2700                             /** @todo Try MMIO; quick hack */
    2701                             if (cbWrite <= 8 && IOMMMIOWrite(pVM, GCPhys, *(uint32_t *)pvBuf, cbWrite) == VINF_SUCCESS)
    2702                                 goto l_End;
    2703 #endif
    2704 
    2705                             /** @todo fix me later. */
    2706                             AssertReleaseMsgFailed(("Unknown write at %RGp size %u implement the complex physical writing case %RHp\n",
    2707                                                     GCPhys, cbWrite,
    2708                                                     (pPage->HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_MMIO2)))); /** @todo PAGE FLAGS */
    2709                             /* skip the write */
    2710                             cb = cbWrite;
    2711                             break;
    2712                     }
    2713                 }
    2714 
    2715                 cbWrite -= cb;
    2716                 off     += cb;
    2717                 pvBuf    = (const char *)pvBuf + cb;
    2718             }
    2719 
    2720             GCPhys = pRam->GCPhysLast + 1;
    2721         }
    2722         else
    2723         {
    2724             /*
    2725              * Unassigned address space.
    2726              */
    2727             size_t cb;
    2728             if (    !pRam
    2729                 ||  (cb = pRam->GCPhys - GCPhys) >= cbWrite)
    2730                 goto l_End;
    2731 
    2732             cbWrite -= cb;
    2733             pvBuf   = (const char *)pvBuf + cb;
    2734             GCPhys += cb;
    2735         }
    2736     }
    2737 l_End:
    2738 #ifdef IN_RING3
    2739     if (fGrabbedLock)
    2740         pgmUnlock(pVM);
    2741 #endif
    2742     return;
    2743 }
    2744 
    2745 #endif /* Old PGMPhysWrite */
    2746 
    27472069
    27482070/**
    … …  
    31582480        }
    31592481
    3160 #ifdef VBOX_WITH_NEW_PHYS_CODE
    31612482        return PGMPhysRead(pVM, GCPhys, pvDst, cb);
    3162 #else
    3163         PGMPhysRead(pVM, GCPhys, pvDst, cb);
    3164         return VINF_SUCCESS;
    3165 #endif
    31662483    }
    31672484
    … …  
    31852502        /* copy */
    31862503        size_t cbRead = PAGE_SIZE - ((RTGCUINTPTR)GCPtrSrc & PAGE_OFFSET_MASK);
    3187 #ifdef VBOX_WITH_NEW_PHYS_CODE
    31882504        rc = PGMPhysRead(pVM, GCPhys, pvDst, cbRead);
    31892505        if (cbRead >= cb || RT_FAILURE(rc))
    31902506            return rc;
    3191 #else
    3192         if (cbRead >= cb)
    3193         {
    3194             PGMPhysRead(pVM, GCPhys, pvDst, cb);
    3195             return VINF_SUCCESS;
    3196         }
    3197         PGMPhysRead(pVM, GCPhys, pvDst, cbRead);
    3198 #endif
    31992507
    32002508        /* next */
    … …  
    32562564        }
    32572565
    3258 #ifdef VBOX_WITH_NEW_PHYS_CODE
    32592566        return PGMPhysWrite(pVM, GCPhys, pvSrc, cb);
    3260 #else
    3261         PGMPhysWrite(pVM, GCPhys, pvSrc, cb);
    3262         return VINF_SUCCESS;
    3263 #endif
    32642567    }
    32652568
    … …  
    32872590        /* copy */
    32882591        size_t cbWrite = PAGE_SIZE - ((RTGCUINTPTR)GCPtrDst & PAGE_OFFSET_MASK);
    3289 #ifdef VBOX_WITH_NEW_PHYS_CODE
    32902592        int rc = PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite);
    32912593        if (cbWrite >= cb || RT_FAILURE(rc))
    32922594            return rc;
    3293 #else
    3294         if (cbWrite >= cb)
    3295         {
    3296             PGMPhysWrite(pVM, GCPhys, pvSrc, cb);
    3297             return VINF_SUCCESS;
    3298         }
    3299         PGMPhysWrite(pVM, GCPhys, pvSrc, cbWrite);
    3300 #endif
    33012595
    33022596        /* next */

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

    r18355 r18666  
    26502650    if (u16)
    26512651    {
    2652 # ifdef VBOX_WITH_NEW_PHYS_CODE
    26532652        /*
    26542653         * The zero page is currently screwing up the tracking and we'll
    … …  
    26602659            rc = VINF_PGM_GCPHYS_ALIASED;
    26612660        else
    2662 # endif
    26632661        {
    26642662# ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0
    … …  
    26872685
    26882686#elif defined(PGMPOOL_WITH_CACHE)
    2689 # ifdef VBOX_WITH_NEW_PHYS_CODE
    26902687    if (PGM_PAGE_IS_ZERO(pPhysPage))
    26912688        rc = VINF_PGM_GCPHYS_ALIASED;
    26922689    else
    2693 # endif
    26942690    {
    26952691# ifdef VBOX_WITH_2X_4GB_ADDR_SPACE_IN_R0

  • trunk/src/VBox/VMM/VMMGC/PDMGCDevice.cpp

    r18645 r18666  
    254254             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
    255255
    256 #ifdef VBOX_WITH_NEW_PHYS_CODE
    257256    int rc = PGMPhysRead(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbRead);
    258257    AssertRC(rc); /** @todo track down the users for this bugger. */
    259 #else
    260     PGMPhysRead(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbRead);
    261     int rc = VINF_SUCCESS;
    262 #endif
    263258
    264259    Log(("pdmGCDevHlp_PhysRead: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, rc));
    … …  
    274269             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
    275270
    276 #ifdef VBOX_WITH_NEW_PHYS_CODE
    277271    int rc = PGMPhysWrite(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbWrite);
    278272    AssertRC(rc); /** @todo track down the users for this bugger. */
    279 #else
    280     PGMPhysWrite(pDevIns->Internal.s.pVMRC, GCPhys, pvBuf, cbWrite);
    281     int rc = VINF_SUCCESS;
    282 #endif
    283273
    284274    Log(("pdmGCDevHlp_PhysWrite: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, rc));

  • trunk/src/VBox/VMM/VMMR0/HWVMXR0.cpp

    r18617 r18666  
    657657        /* Read the selector:offset pair of the interrupt handler. */
    658658        GCPhysHandler = (RTGCPHYS)pCtx->idtr.pIdt + iGate * 4;
    659 #ifdef VBOX_WITH_NEW_PHYS_CODE
    660659        rc = PGMPhysSimpleReadGCPhys(pVM, &offset, GCPhysHandler,     sizeof(offset)); AssertRC(rc);
    661660        rc = PGMPhysSimpleReadGCPhys(pVM, &sel,    GCPhysHandler + 2, sizeof(sel));    AssertRC(rc);
    662 #else
    663         PGMPhysRead(pVM, GCPhysHandler,     &offset, sizeof(offset));
    664         PGMPhysRead(pVM, GCPhysHandler + 2, &sel,    sizeof(sel));
    665 #endif
    666661
    667662        LogFlow(("IDT handler %04X:%04X\n", sel, offset));
    … …  
    671666        pCtx->sp -= 2;
    672667        LogFlow(("ss:sp %04X:%04X eflags=%x\n", pCtx->ss, pCtx->sp, pCtx->eflags.u));
    673 #ifdef VBOX_WITH_NEW_PHYS_CODE
    674668        rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->eflags, sizeof(uint16_t)); AssertRC(rc);
    675 #else
    676         PGMPhysWrite(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->eflags, sizeof(uint16_t));
    677 #endif
    678669        pCtx->sp -= 2;
    679670        LogFlow(("ss:sp %04X:%04X cs=%x\n", pCtx->ss, pCtx->sp, pCtx->cs));
    680 #ifdef VBOX_WITH_NEW_PHYS_CODE
    681671        rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->cs, sizeof(uint16_t)); AssertRC(rc);
    682 #else
    683         PGMPhysWrite(pVM, pCtx->ssHid.u64Base + pCtx->sp, &pCtx->cs, sizeof(uint16_t));
    684 #endif
    685672        pCtx->sp -= 2;
    686673        LogFlow(("ss:sp %04X:%04X ip=%x\n", pCtx->ss, pCtx->sp, ip));
    687 #ifdef VBOX_WITH_NEW_PHYS_CODE
    688674        rc = PGMPhysSimpleWriteGCPhys(pVM, pCtx->ssHid.u64Base + pCtx->sp, &ip, sizeof(ip)); AssertRC(rc);
    689 #else
    690         PGMPhysWrite(pVM, pCtx->ssHid.u64Base + pCtx->sp, &ip, sizeof(ip));
    691 #endif
    692675
    693676        /* Update the CPU state for executing the handler. */
    … …  
    26052588                        }
    26062589                        eflags.u = 0;
    2607 #ifdef VBOX_WITH_NEW_PHYS_CODE
    26082590                        rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    26092591                        if (RT_FAILURE(rc))
    … …  
    26122594                            break;
    26132595                        }
    2614 #else
    2615                         PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    2616 #endif
    26172596                        LogFlow(("POPF %x -> %RGv mask=%x\n", eflags.u, pCtx->rsp, uMask));
    26182597                        pCtx->eflags.u = (pCtx->eflags.u & ~(X86_EFL_POPF_BITS & uMask)) | (eflags.u & X86_EFL_POPF_BITS & uMask);
    … …  
    26552634                        eflags.Bits.u1VM = 0;
    26562635
    2657 #ifdef VBOX_WITH_NEW_PHYS_CODE
    26582636                        rc = PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    26592637                        if (RT_FAILURE(rc))
    … …  
    26622640                            break;
    26632641                        }
    2664 #else
    2665                         PGMPhysWrite(pVM, (RTGCPHYS)GCPtrStack, &eflags.u, cbParm);
    2666 #endif
    26672642                        LogFlow(("PUSHF %x -> %RGv\n", eflags.u, GCPtrStack));
    26682643                        pCtx->esp -= cbParm;
    … …  
    26902665                            break;
    26912666                        }
    2692 #ifdef VBOX_WITH_NEW_PHYS_CODE
    26932667                        rc = PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame));
    26942668                        if (RT_FAILURE(rc))
    … …  
    26972671                            break;
    26982672                        }
    2699 #else
    2700                         PGMPhysRead(pVM, (RTGCPHYS)GCPtrStack, &aIretFrame[0], sizeof(aIretFrame));
    2701 #endif
    27022673                        pCtx->ip            = aIretFrame[0];
    27032674                        pCtx->cs            = aIretFrame[1];

  • trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

    r18645 r18666  
    257257             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
    258258
    259 #ifdef VBOX_WITH_NEW_PHYS_CODE
    260259    int rc = PGMPhysRead(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbRead);
    261260    AssertRC(rc); /** @todo track down the users for this bugger. */
    262 #else
    263     PGMPhysRead(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbRead);
    264     int rc = VINF_SUCCESS;
    265 #endif
    266261
    267262    Log(("pdmR0DevHlp_PhysRead: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, rc));
    … …  
    277272             pDevIns, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
    278273
    279 #ifdef VBOX_WITH_NEW_PHYS_CODE
    280274    int rc = PGMPhysWrite(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbWrite);
    281275    AssertRC(rc); /** @todo track down the users for this bugger. */
    282 #else
    283     PGMPhysWrite(pDevIns->Internal.s.pVMR0, GCPhys, pvBuf, cbWrite);
    284     int rc = VINF_SUCCESS;
    285 #endif
    286276
    287277    Log(("pdmR0DevHlp_PhysWrite: caller=%p/%d: returns %Rrc\n", pDevIns, pDevIns->iInstance, rc));

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

    r18233 r18666  
    458458                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMAllocHandy);
    459459                    break;
    460 #ifndef VBOX_WITH_NEW_PHYS_CODE
    461                 case VMMCALLHOST_PGM_RAM_GROW_RANGE:
    462                     STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallPGMGrowRAM);
    463                     break;
    464 #endif
    465460                case VMMCALLHOST_REM_REPLAY_HANDLER_NOTIFICATIONS:
    466461                    STAM_COUNTER_INC(&pVM->vmm.s.StatRZCallRemReplay);
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