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

Timestamp:

Nov 1, 2021 10:06:25 PM (3 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

147993

Message:

VMM/PGM,NEM: Let NEM handle dirty VRAM (MMIO2) page tracking. Saves lots of exits when using the VBoxVGA device or VMSVGA in non-VMSVGA mode. Added a 32-bit NEM field to the PGMRAMRANGE structure called uNemRange. bugref:10122

File:

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

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

@@ -1504 +1504 @@
         int rc = NEMR3NotifyPhysMmioExMapEarly(pVM, GCPhys, GCPhysLast - GCPhys + 1, fNemNotify,
                                                pRam->pvR3 ? (uint8_t *)pRam->pvR3 + GCPhys - pRam->GCPhys : NULL,
-                                               pvMmio2, &u2State);
+                                               pvMmio2, &u2State, NULL /*puNemRange*/);
         AssertLogRelRCReturn(rc, rc);
 
@@ -1542 +1542 @@
     {
         uint32_t const fNemNotify = (pvMmio2 ? NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2 : 0) | NEM_NOTIFY_PHYS_MMIO_EX_F_REPLACE;
-        rc = NEMR3NotifyPhysMmioExMapEarly(pVM, GCPhys, GCPhysLast - GCPhys + 1, fNemNotify, NULL, pvMmio2, &u2State);
+        rc = NEMR3NotifyPhysMmioExMapEarly(pVM, GCPhys, GCPhysLast - GCPhys + 1, fNemNotify, NULL, pvMmio2,
+                                           &u2State, NULL /*puNemRange*/);
         AssertLogRelRCReturnStmt(rc, GMMR3FreePagesCleanup(pReq), rc);
     }
@@ -1605 +1606 @@
     pNew->pszDesc       = pszDesc;
     pNew->fFlags        = fFlags;
+    pNew->uNemRange     = UINT32_MAX;
     pNew->pvR3          = NULL;
     pNew->paLSPages     = NULL;
@@ -1651 +1653 @@
     {
         uint8_t u2State = UINT8_MAX;
-        int rc = NEMR3NotifyPhysRamRegister(pVM, GCPhys, pNew->cb, pNew->pvR3, &u2State);
+        int rc = NEMR3NotifyPhysRamRegister(pVM, GCPhys, pNew->cb, pNew->pvR3, &u2State, &pNew->uNemRange);
         if (RT_SUCCESS(rc))
         {
@@ -2363 +2365 @@
         if (VM_IS_NEM_ENABLED(pVM))
         {
-            rc = NEMR3NotifyPhysMmioExMapEarly(pVM, GCPhys, cPages << PAGE_SHIFT, 0 /*fFlags*/, NULL, NULL, &u2State);
+            rc = NEMR3NotifyPhysMmioExMapEarly(pVM, GCPhys, cPages << PAGE_SHIFT, 0 /*fFlags*/, NULL, NULL,
+                                               &u2State, &pNew->uNemRange);
             AssertLogRelRCReturnStmt(rc, MMHyperFree(pVM, pNew), rc);
         }
@@ -2409 +2412 @@
             rc = NEMR3NotifyPhysMmioExMapLate(pVM, GCPhys, GCPhysLast - GCPhys + 1, fNemNotify,
                                               fRamExists ? (uint8_t *)pRam->pvR3 + (uintptr_t)(GCPhys - pRam->GCPhys) : NULL,
-                                              NULL);
+                                              NULL, !fRamExists ? &pRam->uNemRange : NULL);
             AssertLogRelRCReturn(rc, rc);
         }
@@ -2844 +2847 @@
         pNew->RamRange.cb           = pNew->cbReal = (RTGCPHYS)cPagesTrackedByChunk << X86_PAGE_SHIFT;
         pNew->RamRange.fFlags      |= PGM_RAM_RANGE_FLAGS_AD_HOC_MMIO_EX;
+        pNew->RamRange.uNemRange    = UINT32_MAX;
         //pNew->RamRange.pvR3       = NULL;
         //pNew->RamRange.paLSPages  = NULL;
@@ -2853 +2857 @@
 
         /*
-         * Pre-allocate a handler if we're tracking dirty pages.
+         * Pre-allocate a handler if we're tracking dirty pages, unless NEM takes care of this.
          */
-        if (fFlags & PGMPHYS_MMIO2_FLAGS_TRACK_DIRTY_PAGES)
+        if (   (fFlags & PGMPHYS_MMIO2_FLAGS_TRACK_DIRTY_PAGES)
+#ifdef VBOX_WITH_PGM_NEM_MODE
+            && !NEMR3IsMmio2DirtyPageTrackingSupported(pVM)
+#endif
+            )
+
         {
             rc = pgmHandlerPhysicalExCreate(pVM, pVM->pgm.s.hMmio2DirtyPhysHandlerType,
@@ -3462 +3471 @@
                 int rc = NEMR3NotifyPhysMmioExMapEarly(pVM, pCurMmio->RamRange.GCPhys,
                                                        pCurMmio->RamRange.GCPhysLast - pCurMmio->RamRange.GCPhys + 1,
-                                                       NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2,
-                                                       NULL /*pvRam*/, pCurMmio->RamRange.pvR3, &u2NemState);
+                                                       NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2
+                                                       | (pCurMmio->fFlags & PGMREGMMIO2RANGE_F_TRACK_DIRTY_PAGES
+                                                          ? NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES : 0),
+                                                       NULL /*pvRam*/, pCurMmio->RamRange.pvR3,
+                                                       &u2NemState, &pCurMmio->RamRange.uNemRange);
                 AssertLogRelRCReturnStmt(rc, PGM_UNLOCK(pVM), rc);
             }
@@ -3529 +3541 @@
         int rc;
         uint32_t fNemFlags = NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2;
+        if (pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_TRACK_DIRTY_PAGES)
+            fNemFlags |= NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES;
         if (fRamExists)
             rc = NEMR3NotifyPhysMmioExMapLate(pVM, GCPhys, GCPhysLast - GCPhys + 1, fNemFlags | NEM_NOTIFY_PHYS_MMIO_EX_F_REPLACE,
-                                              pRam->pvR3 ? (uint8_t *)pRam->pvR3 + GCPhys - pRam->GCPhys : NULL, pFirstMmio->pvR3);
+                                              pRam->pvR3 ? (uint8_t *)pRam->pvR3 + GCPhys - pRam->GCPhys : NULL, pFirstMmio->pvR3,
+                                              NULL /*puNemRange*/);
         else
         {
@@ -3538 +3553 @@
             {
                 rc = NEMR3NotifyPhysMmioExMapLate(pVM, pCurMmio->RamRange.GCPhys, pCurMmio->RamRange.cb, fNemFlags,
-                                                  NULL, pCurMmio->RamRange.pvR3);
+                                                  NULL, pCurMmio->RamRange.pvR3, &pCurMmio->RamRange.uNemRange);
                 if ((pCurMmio->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK) || RT_FAILURE(rc))
                     break;
@@ -3614 +3629 @@
     int            rcRet     = VINF_SUCCESS;
 #ifdef VBOX_WITH_NATIVE_NEM
-    uint32_t const fNemFlags = NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2;
+    uint32_t const fNemFlags = NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2
+                             | (fOldFlags & PGMREGMMIO2RANGE_F_TRACK_DIRTY_PAGES
+                                ? NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES : 0);
 #endif
     if (fOldFlags & PGMREGMMIO2RANGE_F_OVERLAPPING)
@@ -3757 +3774 @@
                                 ("%s: %#x\n", pFirstMmio->RamRange.pszDesc, pFirstMmio->fFlags),
                                 rc = VERR_NOT_SUPPORTED);
-
-#ifdef VBOX_WITH_PGM_NEM_MODE
-            /*
-             * Currently not supported for NEM in simple memory mode.
-             */
-            /** @todo implement this for NEM. */
-            if (RT_SUCCESS(rc))
-                AssertLogRelMsgStmt(VM_IS_NEM_ENABLED(pVM), ("%s: %#x\n", pFirstMmio->RamRange.pszDesc),
-                                    rc = VERR_PGM_NOT_SUPPORTED_FOR_NEM_MODE);
-#endif
             if (RT_SUCCESS(rc))
             {
@@ -3867 +3874 @@
     for (PPGMREGMMIO2RANGE pCur = pFirstRegMmio;;)
     {
-        cbTotal     += pCur->cbReal; /** @todo good question for NEM... */
+        cbTotal     += pCur->RamRange.cb; /* Not using cbReal here, because NEM is not in on the creating, only the mapping. */
         fTotalDirty |= pCur->fFlags;
         if (pCur->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK)
@@ -3892 +3899 @@
     if (pvBitmap)
     {
+#ifdef VBOX_WITH_PGM_NEM_MODE
+        if (pFirstRegMmio->pPhysHandlerR3 == NULL)
+        {
+            AssertReturn(VM_IS_NEM_ENABLED(pVM), VERR_INTERNAL_ERROR_4);
+            uint8_t *pbBitmap = (uint8_t *)pvBitmap;
+            for (PPGMREGMMIO2RANGE pCur = pFirstRegMmio; pCur; pCur = pCur->pNextR3)
+            {
+                size_t const cbBitmapChunk = pCur->RamRange.cb / PAGE_SIZE / 8;
+                Assert((RTGCPHYS)cbBitmapChunk * PAGE_SIZE * 8 == pCur->RamRange.cb);
+                int rc2 = NEMR3PhysMmio2QueryAndResetDirtyBitmap(pVM, pCur->RamRange.GCPhys, pCur->RamRange.cb,
+                                                                 pCur->RamRange.uNemRange, pbBitmap, cbBitmapChunk);
+                if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                    rc = rc2;
+                if (pCur->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK)
+                    break;
+                pbBitmap += pCur->RamRange.cb / PAGE_SIZE / 8;
+            }
+        }
+        else
+#endif
         if (fTotalDirty & PGMREGMMIO2RANGE_F_IS_DIRTY)
         {
@@ -3949 +3976 @@
     else if (   (pFirstRegMmio->fFlags & (PGMREGMMIO2RANGE_F_MAPPED | PGMREGMMIO2RANGE_F_TRACKING_ENABLED))
              ==                          (PGMREGMMIO2RANGE_F_MAPPED | PGMREGMMIO2RANGE_F_TRACKING_ENABLED))
-        rc = PGMHandlerPhysicalReset(pVM, pFirstRegMmio->RamRange.GCPhys);
+    {
+#ifdef VBOX_WITH_PGM_NEM_MODE
+        if (pFirstRegMmio->pPhysHandlerR3 == NULL)
+        {
+            AssertReturn(VM_IS_NEM_ENABLED(pVM), VERR_INTERNAL_ERROR_4);
+            for (PPGMREGMMIO2RANGE pCur = pFirstRegMmio; pCur; pCur = pCur->pNextR3)
+            {
+                int rc2 = NEMR3PhysMmio2QueryAndResetDirtyBitmap(pVM, pCur->RamRange.GCPhys, pCur->RamRange.cb,
+                                                                 pCur->RamRange.uNemRange, NULL, 0);
+                if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                    rc = rc2;
+                if (pCur->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK)
+                    break;
+            }
+        }
+        else
+#endif
+        {
+            for (PPGMREGMMIO2RANGE pCur = pFirstRegMmio; pCur; pCur = pCur->pNextR3)
+            {
+                pCur->fFlags &= ~PGMREGMMIO2RANGE_F_IS_DIRTY;
+                int rc2 = PGMHandlerPhysicalReset(pVM, pCur->RamRange.GCPhys);
+                if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+                    rc = rc2;
+                if (pCur->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK)
+                    break;
+            }
+        }
+    }
 
     return rc;
@@ -4006 +4061 @@
                  , VERR_INVALID_FUNCTION);
     AssertReturn(pDevIns == pFirstRegMmio->pDevInsR3, VERR_NOT_OWNER);
+
+#ifdef VBOX_WITH_PGM_NEM_MODE
+    /*
+     * This is a nop if NEM is responsible for doing the tracking, we simply
+     * leave the tracking on all the time there.
+     */
+    if (pFirstRegMmio->pPhysHandlerR3 == NULL)
+    {
+        AssertReturn(VM_IS_NEM_ENABLED(pVM), VERR_INTERNAL_ERROR_4);
+        return VINF_SUCCESS;
+    }
+#endif
 
     /*