Changeset 18143 in vbox for trunk/src/VBox/VMM/PGMPhys.cpp

Timestamp:

Mar 23, 2009 3:10:24 PM (16 years ago)

Author:

vboxsync

Message:

VMM,Devices: Changed ROM registration and fixed some shadowed ROM issues in the new phys code.

File:

• trunk/src/VBox/VMM/PGMPhys.cpp (modified) (19 diffs)

trunk/src/VBox/VMM/PGMPhys.cpp

@@ -347 +347 @@
 
 #ifdef VBOX_WITH_NEW_PHYS_CODE
-/** 
+/**
  * VMR3ReqCall worker for PGMR3PhysGCPhys2CCPtrExternal to make pages writable.
- *  
+ *
  * @returns see PGMR3PhysGCPhys2CCPtrExternal
  * @param   pVM         The VM handle.
@@ -355 +355 @@
  * @param   ppv         Where to store the mapping address.
  * @param   pLock       Where to store the lock.
- */ 
+ */
 static DECLCALLBACK(int) pgmR3PhysGCPhys2CCPtrDelegated(PVM pVM, PRTGCPHYS pGCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
 {
     /*
-     * Just hand it to PGMPhysGCPhys2CCPtr and check that it's not a page with 
+     * Just hand it to PGMPhysGCPhys2CCPtr and check that it's not a page with
      * an access handler after it succeeds.
      */
@@ -392 +392 @@
  * Requests the mapping of a guest page into ring-3, external threads.
  *
- * When you're done with the page, call PGMPhysReleasePageMappingLock() ASAP to 
- * release it. 
- *
- * This API will assume your intention is to write to the page, and will 
- * therefore replace shared and zero pages. If you do not intend to modify the 
- * page, use the PGMR3PhysGCPhys2CCPtrReadOnlyExternal() API. 
+ * When you're done with the page, call PGMPhysReleasePageMappingLock() ASAP to
+ * release it.
+ *
+ * This API will assume your intention is to write to the page, and will
+ * therefore replace shared and zero pages. If you do not intend to modify the
+ * page, use the PGMR3PhysGCPhys2CCPtrReadOnlyExternal() API.
  *
  * @returns VBox status code.
  * @retval  VINF_SUCCESS on success.
- * @retval  VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical 
+ * @retval  VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
  *          backing or if the page has any active access handlers. The caller
  *          must fall back on using PGMR3PhysWriteExternal.
@@ -445 +445 @@
             /*
              * If the page is shared, the zero page, or being write monitored
-             * it must be converted to an page that's writable if possible. 
+             * it must be converted to an page that's writable if possible.
              * This has to be done on an EMT.
              */
@@ -451 +451 @@
             {
                 pgmUnlock(pVM);
-    
+
                 PVMREQ pReq = NULL;
                 rc = VMR3ReqCall(pVM, VMREQDEST_ANY, &pReq, RT_INDEFINITE_WAIT,
@@ -496 +496 @@
 /**
  * Requests the mapping of a guest page into ring-3, external threads.
- * 
+ *
  * When you're done with the page, call PGMPhysReleasePageMappingLock() ASAP to
  * release it.
@@ -502 +502 @@
  * @returns VBox status code.
  * @retval  VINF_SUCCESS on success.
- * @retval  VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical 
+ * @retval  VERR_PGM_PHYS_PAGE_RESERVED it it's a valid page but has no physical
  *          backing or if the page as an active ALL access handler. The caller
  *          must fall back on using PGMPhysRead.
@@ -538 +538 @@
             rc = VERR_PGM_PHYS_PAGE_RESERVED;
 #endif
-        else 
+        else
         {
             /*
@@ -1696 +1696 @@
  * @param   pvBinary            Pointer to the binary data backing the ROM image.
  *                              This must be exactly \a cbRange in size.
- * @param   fFlags              Mask of flags. PGMPHYS_ROM_FLAG_SHADOWED
- *                              and/or PGMPHYS_ROM_FLAG_PERMANENT_BINARY.
+ * @param   fFlags              Mask of flags. PGMPHYS_ROM_FLAGS_SHADOWED
+ *                              and/or PGMPHYS_ROM_FLAGS_PERMANENT_BINARY.
  * @param   pszDesc             Pointer to description string. This must not be freed.
  *
@@ -1720 +1720 @@
     AssertPtrReturn(pvBinary, VERR_INVALID_PARAMETER);
     AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
-    AssertReturn(!(fFlags & ~(PGMPHYS_ROM_FLAG_SHADOWED | PGMPHYS_ROM_FLAG_PERMANENT_BINARY)), VERR_INVALID_PARAMETER);
+    AssertReturn(!(fFlags & ~(PGMPHYS_ROM_FLAGS_SHADOWED | PGMPHYS_ROM_FLAGS_PERMANENT_BINARY)), VERR_INVALID_PARAMETER);
     VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_VM_INVALID_VM_STATE);
 
@@ -1794 +1794 @@
      */
     uint32_t cExtraBaseCost = fRamExists ? cPages : 0;
-    if (fFlags & PGMPHYS_ROM_FLAG_SHADOWED)
+    if (fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
         cExtraBaseCost += cPages;
     if (cExtraBaseCost)
@@ -1899 +1899 @@
              * to PGM atm).
              */
-            if (fFlags & PGMPHYS_ROM_FLAG_SHADOWED)
+            if (fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
             {
                 REMR3NotifyPhysRomRegister(pVM, GCPhys, cb, NULL, true /* fShadowed */);
                 rc = PGMR3HandlerPhysicalRegister(pVM,
-                                                  fFlags & PGMPHYS_ROM_FLAG_SHADOWED
+                                                  fFlags & PGMPHYS_ROM_FLAGS_SHADOWED
                                                   ? PGMPHYSHANDLERTYPE_PHYSICAL_ALL
                                                   : PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
@@ -1914 +1914 @@
             {
                 rc = PGMR3HandlerPhysicalRegister(pVM,
-                                                  fFlags & PGMPHYS_ROM_FLAG_SHADOWED
+                                                  fFlags & PGMPHYS_ROM_FLAGS_SHADOWED
                                                   ? PGMPHYSHANDLERTYPE_PHYSICAL_ALL
                                                   : PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
@@ -1954 +1954 @@
                     pRomNew->cb = cb;
                     pRomNew->fFlags = fFlags;
-                    pRomNew->pvOriginal = fFlags & PGMPHYS_ROM_FLAG_PERMANENT_BINARY ? pvBinary : NULL;
+                    pRomNew->pvOriginal = fFlags & PGMPHYS_ROM_FLAGS_PERMANENT_BINARY ? pvBinary : NULL;
                     pRomNew->pszDesc = pszDesc;
 
@@ -2037 +2037 @@
     Assert(iPage < (pRom->cb >> PAGE_SHIFT));
     PPGMROMPAGE     pRomPage = &pRom->aPages[iPage];
-    switch (pRomPage->enmProt)
-    {
-        /*
-         * Ignore.
-         */
-        case PGMROMPROT_READ_ROM_WRITE_IGNORE:
-        case PGMROMPROT_READ_RAM_WRITE_IGNORE:
-            return VINF_SUCCESS;
-
-        /*
-         * Write to the ram page.
-         */
-        case PGMROMPROT_READ_ROM_WRITE_RAM:
-        case PGMROMPROT_READ_RAM_WRITE_RAM: /* yes this will get here too, it's *way* simpler that way. */
-        {
-            /* This should be impossible now, pvPhys doesn't work cross page anylonger. */
-            Assert(((GCPhys - pRom->GCPhys + cbBuf - 1) >> PAGE_SHIFT) == iPage);
-
+    Log5(("pgmR3PhysRomWriteHandler: %d %c %#08RGp %#04zx\n", pRomPage->enmProt, enmAccessType == PGMACCESSTYPE_READ ? 'R' : 'W', GCPhys, cbBuf));
+
+    if (enmAccessType == PGMACCESSTYPE_READ)
+    {
+        switch (pRomPage->enmProt)
+        {
             /*
-             * Take the lock, do lazy allocation, map the page and copy the data.
-             *
-             * Note that we have to bypass the mapping TLB since it works on
-             * guest physical addresses and entering the shadow page would
-             * kind of screw things up...
+             * Take the default action.
              */
-            int rc = pgmLock(pVM);
-            AssertRC(rc);
-
-            if (RT_UNLIKELY(PGM_PAGE_GET_STATE(&pRomPage->Shadow) != PGM_PAGE_STATE_ALLOCATED))
+            case PGMROMPROT_READ_ROM_WRITE_IGNORE:
+            case PGMROMPROT_READ_RAM_WRITE_IGNORE:
+            case PGMROMPROT_READ_ROM_WRITE_RAM:
+            case PGMROMPROT_READ_RAM_WRITE_RAM:
+                return VINF_PGM_HANDLER_DO_DEFAULT;
+
+            default:
+                AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
+                                       pRom->aPages[iPage].enmProt, iPage, GCPhys),
+                                      VERR_INTERNAL_ERROR);
+        }
+    }
+    else
+    {
+        Assert(enmAccessType == PGMACCESSTYPE_WRITE);
+        switch (pRomPage->enmProt)
+        {
+            /*
+             * Ignore writes.
+             */
+            case PGMROMPROT_READ_ROM_WRITE_IGNORE:
+            case PGMROMPROT_READ_RAM_WRITE_IGNORE:
+                return VINF_SUCCESS;
+
+            /*
+             * Write to the ram page.
+             */
+            case PGMROMPROT_READ_ROM_WRITE_RAM:
+            case PGMROMPROT_READ_RAM_WRITE_RAM: /* yes this will get here too, it's *way* simpler that way. */
             {
-                rc = pgmPhysPageMakeWritable(pVM, &pRomPage->Shadow, GCPhys);
-                if (RT_FAILURE(rc))
+                /* This should be impossible now, pvPhys doesn't work cross page anylonger. */
+                Assert(((GCPhys - pRom->GCPhys + cbBuf - 1) >> PAGE_SHIFT) == iPage);
+
+                /*
+                 * Take the lock, do lazy allocation, map the page and copy the data.
+                 *
+                 * Note that we have to bypass the mapping TLB since it works on
+                 * guest physical addresses and entering the shadow page would
+                 * kind of screw things up...
+                 */
+                int rc = pgmLock(pVM);
+                AssertRC(rc);
+                PPGMPAGE pShadowPage = &pRomPage->Shadow;
+                if (!PGMROMPROT_IS_ROM(pRomPage->enmProt))
                 {
-                    pgmUnlock(pVM);
-                    return rc;
+                    pShadowPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
+                    AssertLogRelReturn(pShadowPage, VERR_INTERNAL_ERROR);
                 }
-                AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* returned */, ("%Rrc\n", rc));
+
+                if (RT_UNLIKELY(PGM_PAGE_GET_STATE(pShadowPage) != PGM_PAGE_STATE_ALLOCATED))
+                {
+                    rc = pgmPhysPageMakeWritable(pVM, pShadowPage, GCPhys);
+                    if (RT_FAILURE(rc))
+                    {
+                        pgmUnlock(pVM);
+                        return rc;
+                    }
+                    AssertMsg(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3 /* returned */, ("%Rrc\n", rc));
+                }
+
+                void       *pvDstPage;
+                PPGMPAGEMAP pMapIgnored;
+                int rc2 = pgmPhysPageMap(pVM, pShadowPage, GCPhys & X86_PTE_PG_MASK, &pMapIgnored, &pvDstPage);
+                if (RT_SUCCESS(rc2))
+                    memcpy((uint8_t *)pvDstPage + (GCPhys & PAGE_OFFSET_MASK), pvBuf, cbBuf);
+                else
+                    rc = rc2;
+
+                pgmUnlock(pVM);
+                return rc;
             }
 
-            void *pvDstPage;
-            PPGMPAGEMAP pMapIgnored;
-            int rc2 = pgmPhysPageMap(pVM, &pRomPage->Shadow, GCPhys & X86_PTE_PG_MASK, &pMapIgnored, &pvDstPage);
-            if (RT_SUCCESS(rc2))
-                memcpy((uint8_t *)pvDstPage + (GCPhys & PAGE_OFFSET_MASK), pvBuf, cbBuf);
-            else
-                rc = rc2;
-
-            pgmUnlock(pVM);
-            return rc;
-        }
-
-        default:
-            AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
-                                   pRom->aPages[iPage].enmProt, iPage, GCPhys),
-                                  VERR_INTERNAL_ERROR);
+            default:
+                AssertMsgFailedReturn(("enmProt=%d iPage=%d GCPhys=%RGp\n",
+                                       pRom->aPages[iPage].enmProt, iPage, GCPhys),
+                                      VERR_INTERNAL_ERROR);
+        }
     }
 }
@@ -2112 +2143 @@
         const uint32_t cPages = pRom->cb >> PAGE_SHIFT;
 
-        if (pRom->fFlags & PGMPHYS_ROM_FLAG_SHADOWED)
+        if (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED)
         {
             /*
@@ -2246 +2277 @@
         if (    GCPhys     <= pRom->GCPhysLast
             &&  GCPhysLast >= pRom->GCPhys
-            &&  (pRom->fFlags & PGMPHYS_ROM_FLAG_SHADOWED))
+            &&  (pRom->fFlags & PGMPHYS_ROM_FLAGS_SHADOWED))
         {
             /*
@@ -2254 +2285 @@
             uint32_t const cPages = pRom->GCPhysLast <= GCPhysLast
                                   ? pRom->cb >> PAGE_SHIFT
-                                  : (GCPhysLast - pRom->GCPhys) >> PAGE_SHIFT;
+                                  : (GCPhysLast - pRom->GCPhys + 1) >> PAGE_SHIFT;
             for (uint32_t iPage = (GCPhys - pRom->GCPhys) >> PAGE_SHIFT;
                  iPage < cPages;
@@ -2279 +2310 @@
                     /** @todo preserve the volatile flags (handlers) when these have been moved out of HCPhys! */
                 }
+                pRomPage->enmProt = enmProt;
             }