VirtualBox

Changeset 7753 in vbox


Ignore:
Timestamp:
Apr 4, 2008 8:35:44 PM (17 years ago)
Author:
vboxsync
Message:

The PGM bits of the MMIO cleanup.
Moved the parts of PGMR3Reset that deals with RAM (zeroing it) and sketched out the new code there.
Fixed a bug in PGM_PAGE_INIT_ZERO* where the type and state was switched.

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

Legend:

Unmodified
Added
Removed

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

    r7741 r7753  
    17391739    VM_ASSERT_EMT(pVM);
    17401740
     1741    pgmLock(pVM);
     1742
    17411743    /*
    17421744     * Unfix any fixed mappings and disable CR3 monitoring.
    … …  
    17701772
    17711773    /*
    1772      * Zero memory.
    1773      */
    1774     for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3; pRam; pRam = pRam->pNextR3)
    1775     {
    1776         unsigned iPage = pRam->cb >> PAGE_SHIFT;
    1777         while (iPage-- > 0)
     1774     * Reset (zero) RAM pages.
     1775     */
     1776    rc = pgmR3PhysRamReset(pVM);
     1777    if (RT_SUCCESS(rc))
     1778    {
     1779#ifdef VBOX_WITH_NEW_PHYS_CODE
     1780        /*
     1781         * Reset (zero) shadow ROM pages.
     1782         */
     1783        rc = pgmR3PhysRomReset(pVM);
     1784#endif
     1785        if (RT_SUCCESS(rc))
    17781786        {
    1779             if (pRam->aPages[iPage].HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_MMIO2)) /** @todo PAGE FLAGS */
    1780             {
    1781                 /* shadow ram is reloaded elsewhere. */
    1782                 Log4(("PGMR3Reset: not clearing phys page %RGp due to flags %RHp\n", pRam->GCPhys + (iPage << PAGE_SHIFT), pRam->aPages[iPage].HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO))); /** @todo PAGE FLAGS */
    1783                 continue;
    1784             }
    1785             if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
    1786             {
    1787                 unsigned iChunk = iPage >> (PGM_DYNAMIC_CHUNK_SHIFT - PAGE_SHIFT);
    1788                 if (pRam->pavHCChunkHC[iChunk])
    1789                     ASMMemZero32((char *)pRam->pavHCChunkHC[iChunk] + ((iPage << PAGE_SHIFT) & PGM_DYNAMIC_CHUNK_OFFSET_MASK), PAGE_SIZE);
    1790             }
    1791             else
    1792                 ASMMemZero32((char *)pRam->pvHC + (iPage << PAGE_SHIFT), PAGE_SIZE);
     1787            /*
     1788             * Switch mode back to real mode.
     1789             */
     1790            rc = pgmR3ChangeMode(pVM, PGMMODE_REAL);
     1791            STAM_REL_COUNTER_RESET(&pVM->pgm.s.cGuestModeChanges);
    17931792        }
    17941793    }
    17951794
    1796 #ifdef VBOX_WITH_NEW_PHYS_CODE
    1797     /*
    1798      * Zero shadow ROM pages.
    1799      */
    1800     rc = pgmR3PhysRomReset(pVM);
     1795    pgmUnlock(pVM);
     1796    //return rc;
     1797    AssertReleaseRC(rc);
     1798}
     1799
     1800
     1801#ifdef VBOX_STRICT
     1802/**
     1803 * VM state change callback for clearing fNoMorePhysWrites after
     1804 * a snapshot has been created.
     1805 */
     1806static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
     1807{
     1808    if (enmState == VMSTATE_RUNNING)
     1809        pVM->pgm.s.fNoMorePhysWrites = false;
     1810}
    18011811#endif
    1802 
    1803     /*
    1804      * Switch mode back to real mode.
    1805      */
    1806     rc = pgmR3ChangeMode(pVM, PGMMODE_REAL);
    1807     AssertReleaseRC(rc);
    1808     STAM_REL_COUNTER_RESET(&pVM->pgm.s.cGuestModeChanges);
    1809 }
    18101812
    18111813
    … …  
    18201822    return PDMR3CritSectDelete(&pVM->pgm.s.CritSect);
    18211823}
    1822 
    1823 
    1824 #ifdef VBOX_STRICT
    1825 /**
    1826  * VM state change callback for clearing fNoMorePhysWrites after
    1827  * a snapshot has been created.
    1828  */
    1829 static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
    1830 {
    1831     if (enmState == VMSTATE_RUNNING)
    1832         pVM->pgm.s.fNoMorePhysWrites = false;
    1833 }
    1834 #endif
    18351824
    18361825

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

    r7728 r7753  
    563563
    564564/**
    565  * Clears the page structure.
     565 * Initializes the page structure.
    566566 * @param   pPage       Pointer to the physical guest page tracking structure.
    567567 */
    … …  
    579579
    580580/**
    581  * Clears the page structure.
     581 * Initializes the page structure of a ZERO page.
    582582 * @param   pPage       Pointer to the physical guest page tracking structure.
    583583 */
    584584#ifdef VBOX_WITH_NEW_PHYS_CODE
    585585# define PGM_PAGE_INIT_ZERO(pPage, pVM, _uType)  \
    586     PGM_PAGE_INIT(pPage, (pVM)->pgm.s.HCPhysZeroPg, NIL_GMM_PAGEID, PGM_PAGE_STATE_ZERO, (_uType))
     586    PGM_PAGE_INIT(pPage, (pVM)->pgm.s.HCPhysZeroPg, NIL_GMM_PAGEID, (_uType), PGM_PAGE_STATE_ZERO)
    587587#else
    588588# define PGM_PAGE_INIT_ZERO(pPage, pVM, _uType)  \
    589     PGM_PAGE_INIT(pPage, 0, NIL_GMM_PAGEID, PGM_PAGE_STATE_ZERO, (_uType))
     589    PGM_PAGE_INIT(pPage, 0, NIL_GMM_PAGEID, (_uType), PGM_PAGE_STATE_ZERO)
    590590#endif
    591591/** Temporary hack. Replaced by PGM_PAGE_INIT_ZERO once the old code is kicked out. */
    592592# define PGM_PAGE_INIT_ZERO_REAL(pPage, pVM, _uType)  \
    593     PGM_PAGE_INIT(pPage, (pVM)->pgm.s.HCPhysZeroPg, NIL_GMM_PAGEID, PGM_PAGE_STATE_ZERO, (_uType))
     593    PGM_PAGE_INIT(pPage, (pVM)->pgm.s.HCPhysZeroPg, NIL_GMM_PAGEID, (_uType), PGM_PAGE_STATE_ZERO)
    594594
    595595
    … …  
    25902590#ifdef IN_RING3
    25912591int             pgmR3PhysChunkMap(PVM pVM, uint32_t idChunk, PPPGMCHUNKR3MAP ppChunk);
     2592int             pgmR3PhysRamReset(PVM pVM);
    25922593int             pgmR3PhysRomReset(PVM pVM);
    25932594#ifndef VBOX_WITH_NEW_PHYS_CODE

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

    r7731 r7753  
    199199    while (pRam && GCPhysLast >= pRam->GCPhys)
    200200    {
    201         if (    GCPhys     <= pRam->GCPhysLast
    202             &&  GCPhysLast >= pRam->GCPhys)
     201        if (    GCPhysLast >= pRam->GCPhys
     202            &&  GCPhys     <= pRam->GCPhysLast)
    203203            AssertLogRelMsgFailedReturn(("%RGp-%RGp (%s) conflicts with existing %RGp-%RGp (%s)\n",
    204204                                         GCPhys, GCPhysLast, pszDesc,
    … …  
    235235    pNew->cb            = cb;
    236236    pNew->fFlags        = 0;
     237
    237238    pNew->pvHC          = NULL;
    238 
    239239    pNew->pavHCChunkHC  = NULL;
    240240    pNew->pavHCChunkGC  = 0;
    … …  
    271271
    272272/**
     273 * Resets (zeros) the RAM.
     274 *
     275 * ASSUMES that the caller owns the PGM lock.
     276 *
     277 * @returns VBox status code.
     278 * @param   pVM     Pointer to the shared VM structure.
     279 */
     280int pgmR3PhysRamReset(PVM pVM)
     281{
     282    /*
     283     * Walk the ram ranges.
     284     */
     285    for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3; pRam; pRam = pRam->pNextR3)
     286    {
     287        uint32_t iPage = pRam->cb >> PAGE_SHIFT; Assert((RTGCPHYS)iPage << PAGE_SHIFT == pRam->cb);
     288#ifdef VBOX_WITH_NEW_PHYS_CODE
     289        if (!pVM->pgm.f.fRamPreAlloc)
     290        {
     291            /* Replace all RAM pages by ZERO pages. */
     292            while (iPage-- > 0)
     293            {
     294                PPGMPAGE pPage = &pRam->aPages[iPage];
     295                switch (PGM_PAGE_GET_TYPE(pPage))
     296                {
     297                    case PGMPAGETYPE_RAM:
     298                        if (!PGM_PAGE_IS_ZERO(pPage))
     299                            pgmPhysFreePage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)i << PAGE_SHIFT));
     300                        break;
     301
     302                    case PGMPAGETYPE_MMIO2:
     303                    case PGMPAGETYPE_ROM_SHADOW: /// @todo ??
     304                    case PGMPAGETYPE_ROM:
     305                    case PGMPAGETYPE_MMIO:
     306                        break;
     307                    default:
     308                        AssertFailed();
     309                }
     310            } /* for each page */
     311        }
     312        else
     313#endif
     314        {
     315            /* Zero the memory. */
     316            while (iPage-- > 0)
     317            {
     318                PPGMPAGE pPage = &pRam->aPages[iPage];
     319                switch (PGM_PAGE_GET_TYPE(pPage))
     320                {
     321#ifndef VBOX_WITH_NEW_PHYS_CODE
     322                    case PGMPAGETYPE_INVALID:
     323                    case PGMPAGETYPE_MMIO2: /** @todo fix MMIO2 resetting. */
     324                    case PGMPAGETYPE_RAM:
     325                        if (pRam->aPages[iPage].HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_MMIO2)) /** @todo PAGE FLAGS */
     326                        {
     327                            /* shadow ram is reloaded elsewhere. */
     328                            Log4(("PGMR3Reset: not clearing phys page %RGp due to flags %RHp\n", pRam->GCPhys + (iPage << PAGE_SHIFT), pRam->aPages[iPage].HCPhys & (MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO))); /** @todo PAGE FLAGS */
     329                            continue;
     330                        }
     331                        if (pRam->fFlags & MM_RAM_FLAGS_DYNAMIC_ALLOC)
     332                        {
     333                            unsigned iChunk = iPage >> (PGM_DYNAMIC_CHUNK_SHIFT - PAGE_SHIFT);
     334                            if (pRam->pavHCChunkHC[iChunk])
     335                                ASMMemZero32((char *)pRam->pavHCChunkHC[iChunk] + ((iPage << PAGE_SHIFT) & PGM_DYNAMIC_CHUNK_OFFSET_MASK), PAGE_SIZE);
     336                        }
     337                        else
     338                            ASMMemZero32((char *)pRam->pvHC + (iPage << PAGE_SHIFT), PAGE_SIZE);
     339                        break;
     340#else
     341                    case PGMPAGETYPE_RAM:
     342                        switch (PGM_PAGE_GET_STATE(pPage))
     343                        {
     344                            case PGM_PAGE_STATE_ZERO:
     345                                break;
     346                            case PGM_PAGE_STATE_SHARED:
     347                            case PGM_PAGE_STATE_WRITE_MONITORED:
     348                                rc = pgmPhysPageMakeWritable(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)i << PAGE_SHIFT));
     349                                AssertLogRelRCReturn(rc, rc);
     350                            case PGM_PAGE_STATE_ALLOCATED:
     351                            {
     352                                void *pvPage;
     353                                PPGMPAGEMAP pMapIgnored;
     354                                rc = pgmPhysPageMap(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)i << PAGE_SHIFT), &pMapIgnored, &pvPage);
     355                                AssertLogRelRCReturn(rc, rc);
     356                                ASMMemZeroPage(pvPage);
     357                                break;
     358                            }
     359                        }
     360                        break;
     361
     362                    case PGMPAGETYPE_MMIO2:
     363#endif
     364                    case PGMPAGETYPE_ROM_SHADOW:
     365                    case PGMPAGETYPE_ROM:
     366                    case PGMPAGETYPE_MMIO:
     367                        break;
     368                    default:
     369                        AssertFailed();
     370
     371                }
     372            } /* for each page */
     373        }
     374
     375    }
     376
     377    return VINF_SUCCESS;
     378}
     379
     380
     381/**
    273382 * This is the interface IOM is using to register an MMIO region.
    274383 *
    … …  
    277386 * register the callbacks.
    278387 *
     388 * @returns VBox status code.
     389 *
     390 * @param   pVM             Pointer to the shared VM structure.
     391 * @param   GCPhys          The start of the MMIO region.
     392 * @param   cb              The size of the MMIO region.
     393 * @param   pfnHandlerR3    The address of the ring-3 handler. (IOMR3MMIOHandler)
     394 * @param   pvUserR3        The user argument for R3.
     395 * @param   pfnHandlerR0    The address of the ring-0 handler. (IOMMMIOHandler)
     396 * @param   pvUserR0        The user argument for R0.
     397 * @param   pfnHandlerGC    The address of the GC handler. (IOMMMIOHandler)
     398 * @param   pvUserGC        The user argument for GC.
     399 * @param   pszDesc         The description of the MMIO region.
    279400 */
    280401PDMR3DECL(int) PGMR3PhysMMIORegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb,
    … …  
    284405                                     R3PTRTYPE(const char *) pszDesc)
    285406{
    286 
    287     int rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_MMIO, GCPhys, GCPhys + (cb - 1),
    288                                           pfnHandlerR3, pvUserR3,
    289                                           pfnHandlerR0, pvUserR0,
    290                                           pfnHandlerGC, pvUserGC, pszDesc);
     407    /*
     408     * Assert on some assumption.
     409     */
     410    VM_ASSERT_EMT(pVM);
     411    AssertReturn(!(cb & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
     412    AssertReturn(!(GCPhys & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
     413    AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
     414    AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
     415
     416    /*
     417     * Make sure there's a RAM range structure for the region.
     418     */
     419    int rc;
     420    RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
     421    bool fRamExists = false;
     422    PPGMRAMRANGE pRamPrev = NULL;
     423    PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
     424    while (pRam && GCPhysLast >= pRam->GCPhys)
     425    {
     426        if (    GCPhysLast >= pRam->GCPhys
     427            &&  GCPhys     <= pRam->GCPhysLast)
     428        {
     429            /* Simplification: all within the same range. */
     430            AssertLogRelMsgReturn(   GCPhys     >= pRam->GCPhys
     431                                  && GCPhysLast <= pRam->GCPhysLast,
     432                                  ("%RGp-%RGp (MMIO/%s) falls partly outside %RGp-%RGp (%s)\n",
     433                                   GCPhys, GCPhysLast, pszDesc,
     434                                   pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
     435                                  VERR_PGM_RAM_CONFLICT);
     436
     437            /* Check that it's all RAM or MMIO pages. */
     438            PCPGMPAGE pPage = &pRam->aPages[GCPhys - pRam->GCPhys >> PAGE_SHIFT];
     439            uint32_t cLeft = cb >> PAGE_SHIFT;
     440            while (cLeft-- > 0)
     441            {
     442                AssertLogRelMsgReturn(   PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM
     443                                      || PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO,
     444                                      ("%RGp-%RGp (MMIO/%s): %RGp is not a RAM or MMIO page - type=%d desc=%s\n",
     445                                       GCPhys, GCPhysLast, pszDesc, PGM_PAGE_GET_TYPE(pPage), pRam->pszDesc),
     446                                      VERR_PGM_RAM_CONFLICT);
     447                pPage++;
     448            }
     449
     450            /* Looks good. */
     451            fRamExists = true;
     452            break;
     453        }
     454
     455        /* next */
     456        pRamPrev = pRam;
     457        pRam = pRam->pNextR3;
     458    }
     459    PPGMRAMRANGE pNew;
     460    if (fRamExists)
     461        pNew = NULL;
     462    else
     463    {
     464        /*
     465         * No RAM range, insert an ad-hoc one.
     466         *
     467         * Note that we don't have to tell REM about this range because
     468         * PGMHandlerPhysicalRegisterEx will do that for us.
     469         */
     470        Log(("PGMR3PhysMMIORegister: Adding ad-hoc MMIO range for %RGp-%RGp %s\n", GCPhys, GCPhysLast, pszDesc));
     471
     472        const uint32_t cPages = cb >> PAGE_SHIFT;
     473        const size_t cbRamRange = RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]);
     474        rc = MMHyperAlloc(pVM, RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]), 16, MM_TAG_PGM_PHYS, (void **)&pNew);
     475        AssertLogRelMsgRCReturn(rc, ("cbRamRange=%zu\n", cbRamRange), rc);
     476
     477        /* Initialize the range. */
     478        pNew->GCPhys        = GCPhys;
     479        pNew->GCPhysLast    = GCPhysLast;
     480        pNew->pszDesc       = pszDesc;
     481        pNew->cb            = cb;
     482        pNew->fFlags        = 0; /* Some MMIO flag here? */
     483
     484        pNew->pvHC          = NULL;
     485        pNew->pavHCChunkHC  = NULL;
     486        pNew->pavHCChunkGC  = 0;
     487
     488        uint32_t iPage = cPages;
     489        while (iPage-- > 0)
     490            PGM_PAGE_INIT_ZERO_REAL(&pNew->aPages[iPage], pVM, PGMPAGETYPE_MMIO);
     491        Assert(PGM_PAGE_GET_TYPE(&pNew->aPages[0]) == PGMPAGETYPE_MMIO);
     492
     493        /* link it */
     494        pgmR3PhysLinkRamRange(pVM, pNew, pRamPrev);
     495    }
     496
     497    /*
     498     * Register the access handler.
     499     */
     500    rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_MMIO, GCPhys, GCPhysLast,
     501                                      pfnHandlerR3, pvUserR3,
     502                                      pfnHandlerR0, pvUserR0,
     503                                      pfnHandlerGC, pvUserGC, pszDesc);
     504    if (    RT_FAILURE(rc)
     505        &&  !fRamExists)
     506    {
     507        /* remove the ad-hoc range. */
     508        pgmR3PhysUnlinkRamRange2(pVM, pNew, pRamPrev);
     509        pNew->cb = pNew->GCPhys = pNew->GCPhysLast = NIL_RTGCPHYS;
     510        MMHyperFree(pVM, pRam);
     511    }
     512
    291513    return rc;
    292514}
    … …  
    296518 * This is the interface IOM is using to register an MMIO region.
    297519 *
    298  * It will validate the MMIO region, call PGMHandlerPhysicalDeregister,
    299  * and free the RAM range if one was allocated specially for this MMIO
    300  * region.
     520 * It will take care of calling PGMHandlerPhysicalDeregister and clean up
     521 * any ad-hoc PGMRAMRANGE left behind.
     522 *
     523 * @returns VBox status code.
     524 * @param   pVM             Pointer to the shared VM structure.
     525 * @param   GCPhys          The start of the MMIO region.
     526 * @param   cb              The size of the MMIO region.
    301527 */
    302528PDMR3DECL(int) PGMR3PhysMMIODeregister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb)
    303529{
     530    VM_ASSERT_EMT(pVM);
     531
     532    /*
     533     * First deregister the handler, then check if we should remove the ram range.
     534     */
    304535    int rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
     536    if (RT_SUCCESS(rc))
     537    {
     538        RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
     539        PPGMRAMRANGE pRamPrev = NULL;
     540        PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
     541        while (pRam && GCPhysLast >= pRam->GCPhys)
     542        {
     543            /*if (    GCPhysLast >= pRam->GCPhys
     544                &&  GCPhys     <= pRam->GCPhysLast) - later */
     545            if (    GCPhysLast == pRam->GCPhysLast
     546                &&  GCPhys     == pRam->GCPhys)
     547            {
     548                Assert(pRam->cb == cb);
     549
     550                /*
     551                 * See if all the pages are dead MMIO pages.
     552                 */
     553                bool fAllMMIO = true;
     554                PPGMPAGE pPage = &pRam->aPages[0];
     555                uint32_t cLeft = cb >> PAGE_SHIFT;
     556                while (cLeft-- > 0)
     557                {
     558                    if (    PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO
     559                        /*|| not-out-of-action later */)
     560                    {
     561                        fAllMMIO = false;
     562                        break;
     563                    }
     564                    pPage++;
     565                }
     566
     567                /*
     568                 * Unlink it and free if it's all MMIO.
     569                 */
     570                if (fAllMMIO)
     571                {
     572                    Log(("PGMR3PhysMMIODeregister: Freeing ad-hoc MMIO range for %RGp-%RGp %s\n",
     573                         GCPhys, GCPhysLast, pRam->pszDesc));
     574
     575                    pgmR3PhysUnlinkRamRange2(pVM, pRam, pRamPrev);
     576                    pRam->cb = pRam->GCPhys = pRam->GCPhysLast = NIL_RTGCPHYS;
     577                    MMHyperFree(pVM, pRam);
     578                }
     579                break;
     580            }
     581
     582            /* next */
     583            pRamPrev = pRam;
     584            pRam = pRam->pNextR3;
     585        }
     586    }
    305587
    306588    return rc;
    … …  
    11771459 * This is done after the normal memory has been cleared.
    11781460 *
     1461 * ASSUMES that the caller owns the PGM lock.
     1462 *
    11791463 * @param   pVM         The VM handle.
    11801464 */
    … …  
    12341518            {
    12351519                /* clear all the pages. */
    1236                 pgmLock(pVM);
    12371520                for (uint32_t iPage = 0; iPage < cPages; iPage++)
    12381521                {
    … …  
    12471530                    if (RT_FAILURE(rc))
    12481531                        break;
    1249                     memset(pvDstPage, 0, PAGE_SIZE);
     1532                    ASMMemZeroPage(pvDstPage);
    12501533                }
    1251                 pgmUnlock(pVM);
    12521534                AssertRCReturn(rc, rc);
    12531535            }

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

    r7642 r7753  
    122122    {
    123123#ifdef IN_RING3
    124         /*
    125          * If this is an MMIO registration, we'll just add a range for it.
    126          */
    127         if (    enmType == PGMPHYSHANDLERTYPE_MMIO
    128             &&  (   !pRam
    129                  || GCPhysLast < pRam->GCPhys)
    130            )
    131         {
    132             size_t cb = GCPhysLast - GCPhys + 1;
    133             Assert(cb == RT_ALIGN_Z(cb, PAGE_SIZE));
    134             int rc = PGMR3PhysRegister(pVM, NULL, GCPhys, cb, MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_MMIO, NULL, pszDesc);
    135             if (VBOX_FAILURE(rc))
    136                 return rc;
    137 
    138             /* search again. */
    139             pRam = CTXALLSUFF(pVM->pgm.s.pRamRanges);
    140             while (pRam && GCPhys > pRam->GCPhysLast)
    141                 pRam = CTXALLSUFF(pRam->pNext);
    142         }
    143 
    144         if (    !pRam
    145             ||  GCPhysLast < pRam->GCPhys
    146             ||  GCPhys > pRam->GCPhysLast)
    147 #endif /* IN_RING3 */
    148         {
    149 #ifdef IN_RING3
    150             DBGFR3Info(pVM, "phys", NULL, NULL);
     124        DBGFR3Info(pVM, "phys", NULL, NULL);
    151125#endif
    152             AssertMsgFailed(("No RAM range for %VGp-%VGp\n", GCPhys, GCPhysLast));
    153             return VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
    154         }
     126        AssertMsgFailed(("No RAM range for %VGp-%VGp\n", GCPhys, GCPhysLast));
     127        return VERR_PGM_HANDLER_PHYSICAL_NO_RAM_RANGE;
    155128    }
    156129
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