Changeset 92170 in vbox for trunk

Timestamp:

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

Author:

vboxsync

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

Location:

trunk

Files:

• include/VBox/err.h (modified) (1 diff)
• include/VBox/vmm/nem.h (modified) (1 diff)
• include/VBox/vmm/vm.h (modified) (2 diffs)
• include/VBox/vmm/vm.mac (modified) (1 diff)
• src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h (modified) (6 diffs)
• src/VBox/VMM/VMMR3/NEMR3Native-win.cpp (modified) (23 diffs)
• src/VBox/VMM/VMMR3/PGMPhys.cpp (modified) (17 diffs)
• src/VBox/VMM/include/NEMInternal.h (modified) (1 diff)
• src/VBox/VMM/include/PGMInternal.h (modified) (2 diffs)

trunk/include/VBox/err.h

@@ -3011 +3011 @@
 /** NEM init failed because of missing kernel API (\#5). */
 #define VERR_NEM_MISSING_KERNEL_API_5               (-6815)
+/** NEM failed to query dirty page bitmap. */
+#define VERR_NEM_QUERY_DIRTY_BITMAP_FAILED          (-6816)
 
 /** NEM internal processing error \#0. */

trunk/include/VBox/vmm/nem.h

@@ -62 +62 @@
 VMMR3_INT_DECL(void) NEMR3NotifyFF(PVM pVM, PVMCPU pVCpu, uint32_t fFlags);
 
-VMMR3_INT_DECL(int)  NEMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, void *pvR3, uint8_t *pu2State);
+/**
+ * Checks if dirty page tracking for MMIO2 ranges is supported.
+ *
+ * If it is, PGM will not install a physical write access handler for the MMIO2
+ * region and instead just forward dirty bit queries NEMR3QueryMmio2DirtyBits.
+ * The enable/disable control of the tracking will be ignored, and PGM will
+ * always set NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES for such ranges.
+ *
+ * @retval  true if supported.
+ * @retval  false if not.
+ * @param   pVM     The cross context VM structure.
+ */
+VMMR3_INT_DECL(bool) NEMR3IsMmio2DirtyPageTrackingSupported(PVM pVM);
+
+/**
+ * Worker for PGMR3PhysMmio2QueryAndResetDirtyBitmap.
+ *
+ * @returns VBox status code.
+ * @param   pVM         The cross context VM structure.
+ * @param   GCPhys      The address of the MMIO2 range.
+ * @param   cb          The size of the MMIO2 range.
+ * @param   uNemRange   The NEM internal range number.
+ * @param   pvBitmap    The output bitmap.  Must be 8-byte aligned.  Ignored
+ *                      when @a cbBitmap is zero.
+ * @param   cbBitmap    The size of the bitmap.  Must be the size of the whole
+ *                      MMIO2 range, rounded up to the nearest 8 bytes.
+ *                      When zero only a reset is done.
+ */
+VMMR3_INT_DECL(int)  NEMR3PhysMmio2QueryAndResetDirtyBitmap(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t uNemRange,
+                                                            void *pvBitmap, size_t cbBitmap);
+
+VMMR3_INT_DECL(int)  NEMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, void *pvR3,
+                                                uint8_t *pu2State, uint32_t *puNemRange);
 VMMR3_INT_DECL(int)  NEMR3NotifyPhysMmioExMapEarly(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t fFlags,
-                                                   void *pvRam, void *pvMmio2, uint8_t *pu2State);
+                                                   void *pvRam, void *pvMmio2, uint8_t *pu2State, uint32_t *puNemRange);
 VMMR3_INT_DECL(int)  NEMR3NotifyPhysMmioExMapLate(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t fFlags,
-                                                  void *pvRam, void *pvMmio2);
+                                                  void *pvRam, void *pvMmio2, uint32_t *puNemRange);
 VMMR3_INT_DECL(int)  NEMR3NotifyPhysMmioExUnmap(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t fFlags,
                                                 void *pvRam, void *pvMmio2, uint8_t *pu2State);
 /** @name Flags for NEMR3NotifyPhysMmioExMap and NEMR3NotifyPhysMmioExUnmap.
  * @{ */
+/** Set if the range is replacing RAM rather that unused space. */
+#define NEM_NOTIFY_PHYS_MMIO_EX_F_REPLACE               RT_BIT(0)
 /** Set if it's MMIO2 being mapped or unmapped. */
-#define NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2     RT_BIT(0)
-/** Set if the range is replacing RAM rather that unused space. */
-#define NEM_NOTIFY_PHYS_MMIO_EX_F_REPLACE   RT_BIT(1)
+#define NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2                 RT_BIT(1)
+/** Set if MMIO2 and dirty page tracking is configured. */
+#define NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES     RT_BIT(2)
 /** @} */
 

trunk/include/VBox/vmm/vm.h

@@ -1346 +1346 @@
         struct NEM  s;
 #endif
-        uint8_t     padding[256];       /* multiple of 64 */
+        uint8_t     padding[512];       /* multiple of 64 */
     } nem;
 
@@ -1454 +1454 @@
 
     /** Padding for aligning the structure size on a page boundrary. */
-    uint8_t         abAlignment2[2008 - sizeof(PVMCPUR3) * VMM_MAX_CPU_COUNT];
+    uint8_t         abAlignment2[1752 - sizeof(PVMCPUR3) * VMM_MAX_CPU_COUNT];
 
     /* ---- end small stuff ---- */

trunk/include/VBox/vmm/vm.mac

@@ -149 +149 @@
     .em                     resb 256
     alignb 64
-    .nem                    resb 256
+    .nem                    resb 512
     alignb 64
     .tm                     resb 10112

trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

@@ -1601 +1601 @@
 # else
     RT_NOREF_PV(pVCpu);
+    STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
+    STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     if (SUCCEEDED(hrc))
 # endif
@@ -1796 +1798 @@
 # else
     /** @todo figure out whether we mess up the state or if it's WHv.   */
+    STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, X86_PAGE_SIZE);
+    STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     if (SUCCEEDED(hrc))
 # endif
@@ -4648 +4652 @@
     if (pvMemR3)
     {
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
         HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvMemR3, GCPhys, cb,
                                      WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute | WHvMapGpaRangeFlagWrite);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
         if (SUCCEEDED(hrc))
             *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
@@ -4813 +4819 @@
             }
 #  else
+            STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
             HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst, X86_PAGE_SIZE);
+            STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
             if (SUCCEEDED(hrc))
             {
@@ -4908 +4916 @@
         if (RT_SUCCESS(rc))
         {
+            STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRangePage, a);
             HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, (void *)pvPage, GCPhysDst, X86_PAGE_SIZE,
                                          WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute);
+            STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRangePage, a);
             if (SUCCEEDED(hrc))
             {
@@ -4963 +4973 @@
 
 #elif defined(IN_RING3)
+    STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, X86_PAGE_SIZE);
+    STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRangePage, a);
     if (SUCCEEDED(hrc))
     {

trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

@@ -59 +59 @@
 #include <iprt/system.h>
 #include <iprt/utf16.h>
+
+#ifndef NTDDI_WIN10_VB /* Present in W10 2004 SDK, quite possibly earlier. */
+HRESULT WINAPI WHvQueryGpaRangeDirtyBitmap(WHV_PARTITION_HANDLE, WHV_GUEST_PHYSICAL_ADDRESS, UINT64, UINT64 *, UINT32);
+# define WHvMapGpaRangeFlagTrackDirtyPages      ((WHV_MAP_GPA_RANGE_FLAGS)0x00000008)
+#endif
 
 
@@ -96 +101 @@
 static decltype(WHvUnmapGpaRange) *                 g_pfnWHvUnmapGpaRange;
 static decltype(WHvTranslateGva) *                  g_pfnWHvTranslateGva;
+static decltype(WHvQueryGpaRangeDirtyBitmap) *      g_pfnWHvQueryGpaRangeDirtyBitmap;
 #ifndef NEM_WIN_USE_OUR_OWN_RUN_API
 static decltype(WHvCreateVirtualProcessor) *        g_pfnWHvCreateVirtualProcessor;
@@ -147 +153 @@
     NEM_WIN_IMPORT(0, false, WHvUnmapGpaRange),
     NEM_WIN_IMPORT(0, false, WHvTranslateGva),
+    NEM_WIN_IMPORT(0, true,  WHvQueryGpaRangeDirtyBitmap),
 #ifndef NEM_WIN_USE_OUR_OWN_RUN_API
     NEM_WIN_IMPORT(0, false, WHvCreateVirtualProcessor),
@@ -222 +229 @@
 # define WHvUnmapGpaRange                           g_pfnWHvUnmapGpaRange
 # define WHvTranslateGva                            g_pfnWHvTranslateGva
+# define WHvQueryGpaRangeDirtyBitmap                g_pfnWHvQueryGpaRangeDirtyBitmap
 # define WHvCreateVirtualProcessor                  g_pfnWHvCreateVirtualProcessor
 # define WHvDeleteVirtualProcessor                  g_pfnWHvDeleteVirtualProcessor
@@ -522 +530 @@
         {
             int rc2 = RTLdrGetSymbol(ahMods[g_aImports[i].idxDll], g_aImports[i].pszName, (void **)g_aImports[i].ppfn);
-            if (RT_FAILURE(rc2))
+            if (RT_SUCCESS(rc2))
+            {
+                if (g_aImports[i].fOptional)
+                    LogRel(("NEM:  info: Found optional import %s!%s.\n",
+                            s_apszDllNames[g_aImports[i].idxDll], g_aImports[i].pszName));
+            }
+            else
             {
                 *g_aImports[i].ppfn = NULL;
@@ -1370 +1384 @@
                                        "/NEM/PagesUnmapAll", STAMUNIT_PAGES, "Times we had to unmap all the pages");
 #endif
+#ifdef VBOX_WITH_PGM_NEM_MODE
+                        STAMR3Register(pVM, &pVM->nem.s.StatProfMapGpaRange, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
+                                       "/NEM/PagesMapGpaRange", STAMUNIT_TICKS_PER_CALL, "Profiling calls to WHvMapGpaRange for bigger stuff");
+                        STAMR3Register(pVM, &pVM->nem.s.StatProfUnmapGpaRange, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
+                                       "/NEM/PagesUnmapGpaRange", STAMUNIT_TICKS_PER_CALL, "Profiling calls to WHvUnmapGpaRange for bigger stuff");
+                        STAMR3Register(pVM, &pVM->nem.s.StatProfQueryGpaRangeDirtyBitmap, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
+                                       "/NEM/PagesQueryGpaRangeDirtyBitmap", STAMUNIT_TICKS_PER_CALL, "Profiling calls to WHvQueryGpaRangeDirtyBitmap (MMIO2/VRAM)");
+#  endif
+#  ifndef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
+                        STAMR3Register(pVM, &pVM->nem.s.StatProfMapGpaRangePage, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
+                                       "/NEM/PagesMapGpaRangePage", STAMUNIT_TICKS_PER_CALL, "Profiling calls to WHvMapGpaRange for single pages");
+                        STAMR3Register(pVM, &pVM->nem.s.StatProfUnmapGpaRangePage, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS,
+                                       "/NEM/PagesUnmapGpaRangePage", STAMUNIT_TICKS_PER_CALL, "Profiling calls to WHvUnmapGpaRange for single pages");
+#  endif
 
                         for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
@@ -1972 +2000 @@
 
 
-VMMR3_INT_DECL(int) NEMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, void *pvR3, uint8_t *pu2State)
-{
-    Log5(("NEMR3NotifyPhysRamRegister: %RGp LB %RGp, pvR3=%p\n", GCPhys, cb, pvR3));
+VMMR3_INT_DECL(int) NEMR3NotifyPhysRamRegister(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, void *pvR3,
+                                               uint8_t *pu2State, uint32_t *puNemRange)
+{
+    Log5(("NEMR3NotifyPhysRamRegister: %RGp LB %RGp, pvR3=%p pu2State=%p (%d) puNemRange=%p (%d)\n",
+          GCPhys, cb, pvR3, pu2State, pu2State, puNemRange, *puNemRange));
+
     *pu2State = UINT8_MAX;
+    RT_NOREF(puNemRange);
+
 #if !defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) && defined(VBOX_WITH_PGM_NEM_MODE)
     if (pvR3)
     {
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
         HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvR3, GCPhys, cb,
                                      WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagWrite | WHvMapGpaRangeFlagExecute);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
         if (SUCCEEDED(hrc))
             *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
@@ -1987 +2022 @@
             LogRel(("NEMR3NotifyPhysRamRegister: GCPhys=%RGp LB %RGp pvR3=%p hrc=%Rhrc (%#x) Last=%#x/%u\n",
                     GCPhys, cb, pvR3, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+            STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
             return VERR_NEM_MAP_PAGES_FAILED;
         }
@@ -1997 +2033 @@
 
 
+VMMR3_INT_DECL(bool) NEMR3IsMmio2DirtyPageTrackingSupported(PVM pVM)
+{
+    RT_NOREF(pVM);
+    return g_pfnWHvQueryGpaRangeDirtyBitmap != NULL;
+}
+
+
 VMMR3_INT_DECL(int) NEMR3NotifyPhysMmioExMapEarly(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t fFlags,
-                                                  void *pvRam, void *pvMmio2, uint8_t *pu2State)
-{
-    Log5(("NEMR3NotifyPhysMmioExMapEarly: %RGp LB %RGp fFlags=%#x pvRam=%p pvMmio2=%p pu2State=%p (%d)\n",
-          GCPhys, cb, fFlags, pvRam, pvMmio2, pu2State, *pu2State));
+                                                  void *pvRam, void *pvMmio2, uint8_t *pu2State, uint32_t *puNemRange)
+{
+    Log5(("NEMR3NotifyPhysMmioExMapEarly: %RGp LB %RGp fFlags=%#x pvRam=%p pvMmio2=%p pu2State=%p (%d) puNemRange=%p (%#x)\n",
+          GCPhys, cb, fFlags, pvRam, pvMmio2, pu2State, *pu2State, puNemRange, puNemRange ? *puNemRange : UINT32_MAX));
+    RT_NOREF(puNemRange);
 
 #if !defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) && defined(VBOX_WITH_PGM_NEM_MODE)
@@ -2009 +2053 @@
     if (fFlags & NEM_NOTIFY_PHYS_MMIO_EX_F_REPLACE)
     {
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRange, a);
         HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, cb);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRange, a);
         if (SUCCEEDED(hrc))
         { /* likely */ }
@@ -2019 +2065 @@
             LogRel(("NEMR3NotifyPhysMmioExMapEarly: GCPhys=%RGp LB %RGp fFlags=%#x: Unmap -> hrc=%Rhrc (%#x) Last=%#x/%u\n",
                     GCPhys, cb, fFlags, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+            STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
             return VERR_NEM_UNMAP_PAGES_FAILED;
         }
@@ -2029 +2076 @@
     {
         Assert(fFlags & NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2);
-        HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvMmio2, GCPhys, cb,
-                                     WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagWrite | WHvMapGpaRangeFlagExecute);
+        WHV_MAP_GPA_RANGE_FLAGS fWHvFlags = WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagWrite | WHvMapGpaRangeFlagExecute;
+        if ((fFlags & NEM_NOTIFY_PHYS_MMIO_EX_F_TRACK_DIRTY_PAGES) && g_pfnWHvQueryGpaRangeDirtyBitmap)
+            fWHvFlags |= WHvMapGpaRangeFlagTrackDirtyPages;
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
+        HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvMmio2, GCPhys, cb, fWHvFlags);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
         if (SUCCEEDED(hrc))
             *pu2State = NEM_WIN_PAGE_STATE_WRITABLE;
         else
         {
-            LogRel(("NEMR3NotifyPhysMmioExMapEarly: GCPhys=%RGp LB %RGp fFlags=%#x pvMmio2=%p: Map -> hrc=%Rhrc (%#x) Last=%#x/%u\n",
-                    GCPhys, cb, fFlags, pvMmio2, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+            LogRel(("NEMR3NotifyPhysMmioExMapEarly: GCPhys=%RGp LB %RGp fFlags=%#x pvMmio2=%p fWHvFlags=%#x: Map -> hrc=%Rhrc (%#x) Last=%#x/%u\n",
+                    GCPhys, cb, fFlags, pvMmio2, fWHvFlags, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+            STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
             return VERR_NEM_MAP_PAGES_FAILED;
         }
@@ -2056 +2108 @@
 
 VMMR3_INT_DECL(int) NEMR3NotifyPhysMmioExMapLate(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t fFlags,
-                                                 void *pvRam, void *pvMmio2)
-{
-    RT_NOREF(pVM, GCPhys, cb, fFlags, pvRam, pvMmio2);
+                                                 void *pvRam, void *pvMmio2, uint32_t *puNemRange)
+{
+    RT_NOREF(pVM, GCPhys, cb, fFlags, pvRam, pvMmio2, puNemRange);
     return VINF_SUCCESS;
 }
@@ -2078 +2130 @@
     if (fFlags & NEM_NOTIFY_PHYS_MMIO_EX_F_MMIO2)
     {
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfUnmapGpaRange, a);
         HRESULT hrc = WHvUnmapGpaRange(pVM->nem.s.hPartition, GCPhys, cb);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfUnmapGpaRange, a);
         if (FAILED(hrc))
         {
@@ -2084 +2138 @@
                      GCPhys, cb, fFlags, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
             rc = VERR_NEM_UNMAP_PAGES_FAILED;
+            STAM_REL_COUNTER_INC(&pVM->nem.s.StatUnmapPageFailed);
         }
     }
@@ -2093 +2148 @@
     {
         AssertPtr(pvRam);
+        STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
         HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvRam, GCPhys, cb,
                                      WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagWrite | WHvMapGpaRangeFlagExecute);
+        STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
         if (SUCCEEDED(hrc))
         { /* likely */ }
@@ -2102 +2159 @@
                     GCPhys, cb, pvMmio2, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
             rc = VERR_NEM_MAP_PAGES_FAILED;
+            STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
         }
         if (pu2State)
@@ -2117 +2175 @@
 #endif
     return rc;
+}
+
+
+VMMR3_INT_DECL(int) NEMR3PhysMmio2QueryAndResetDirtyBitmap(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cb, uint32_t uNemRange,
+                                                           void *pvBitmap, size_t cbBitmap)
+{
+#if !defined(NEM_WIN_USE_HYPERCALLS_FOR_PAGES) && defined(VBOX_WITH_PGM_NEM_MODE)
+    Assert(VM_IS_NEM_ENABLED(pVM));
+    AssertReturn(g_pfnWHvQueryGpaRangeDirtyBitmap, VERR_INTERNAL_ERROR_2);
+    Assert(cbBitmap == (uint32_t)cbBitmap);
+    RT_NOREF(uNemRange);
+
+    STAM_REL_PROFILE_START(&pVM->nem.s.StatProfQueryGpaRangeDirtyBitmap, a);
+    HRESULT hrc = WHvQueryGpaRangeDirtyBitmap(pVM->nem.s.hPartition, GCPhys, cb, (UINT64 *)pvBitmap, (uint32_t)cbBitmap);
+    STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfQueryGpaRangeDirtyBitmap, a);
+    if (SUCCEEDED(hrc))
+        return VINF_SUCCESS;
+
+    AssertLogRelMsgFailed(("GCPhys=%RGp LB %RGp pvBitmap=%p LB %#zx hrc=%Rhrc (%#x) Last=%#x/%u\n",
+                           GCPhys, cb, pvBitmap, cbBitmap, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+    return VERR_NEM_QUERY_DIRTY_BITMAP_FAILED;
+
+#else
+    RT_NOREF(pVM, GCPhys, cb, uNemRange, pvBitmap, cbBitmap);
+    AssertFailed();
+    return VERR_NOT_IMPLEMENTED;
+#endif
 }
 
@@ -2171 +2256 @@
      */
     AssertPtrReturn(pvPages, VERR_INVALID_POINTER);
+    STAM_REL_PROFILE_START(&pVM->nem.s.StatProfMapGpaRange, a);
     HRESULT hrc = WHvMapGpaRange(pVM->nem.s.hPartition, pvPages, GCPhys, cb, WHvMapGpaRangeFlagRead | WHvMapGpaRangeFlagExecute);
+    STAM_REL_PROFILE_STOP(&pVM->nem.s.StatProfMapGpaRange, a);
     if (SUCCEEDED(hrc))
         *pu2State = NEM_WIN_PAGE_STATE_READABLE;
@@ -2178 +2265 @@
         LogRel(("nemR3NativeNotifyPhysRomRegisterEarly: GCPhys=%RGp LB %RGp pvPages=%p fFlags=%#x hrc=%Rhrc (%#x) Last=%#x/%u\n",
                 GCPhys, cb, pvPages, fFlags, hrc, hrc, RTNtLastStatusValue(), RTNtLastErrorValue()));
+        STAM_REL_COUNTER_INC(&pVM->nem.s.StatMapPageFailed);
         return VERR_NEM_MAP_PAGES_FAILED;
     }
@@ -2187 +2275 @@
 }
 
+#ifdef NEM_WIN_WITH_A20
 
 /**
@@ -2229 +2318 @@
 
 
-#ifdef NEM_WIN_WITH_A20
 /**
  * Unmaps a page from Hyper-V for the purpose of emulating A20 gate behavior.
@@ -2244 +2332 @@
                                      nemR3WinUnsetForA20CheckerCallback, NULL);
 }
-#endif
-
+
+#endif /* NEM_WIN_WITH_A20 */
 
 /**

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
 
     /*

trunk/src/VBox/VMM/include/NEMInternal.h

@@ -217 +217 @@
     STAMCOUNTER                 StatMapPageFailed;
     STAMCOUNTER                 StatUnmapPageFailed;
+#  ifdef VBOX_WITH_PGM_NEM_MODE
+    STAMPROFILE                 StatProfMapGpaRange;
+    STAMPROFILE                 StatProfUnmapGpaRange;
+    STAMPROFILE                 StatProfQueryGpaRangeDirtyBitmap;
+#  endif
+#  ifndef NEM_WIN_USE_HYPERCALLS_FOR_PAGES
+    STAMPROFILE                 StatProfMapGpaRangePage;
+    STAMPROFILE                 StatProfUnmapGpaRangePage;
+#  endif
 
 #  ifdef NEM_WIN_USE_HYPERCALLS_FOR_PAGES

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

@@ -1179 +1179 @@
     /** PGM_RAM_RANGE_FLAGS_* flags. */
     uint32_t                            fFlags;
-    uint32_t                            fPadding1;
+    /** NEM specific info, UINT32_MAX if not used. */
+    uint32_t                            uNemRange;
     /** Last address in the range (inclusive). Page aligned (-1). */
     RTGCPHYS                            GCPhysLast;
@@ -1421 +1422 @@
      * reduced during saved state loading. */
     RTGCPHYS                            cbReal;
-    /** Pointer to the physical handler for MMIO. */
+    /** Pointer to the physical handler for MMIO.
+     * If NEM is responsible for tracking dirty pages in simple memory mode, this
+     * will be NULL. */
     R3PTRTYPE(PPGMPHYSHANDLER)          pPhysHandlerR3;
     /** Live save per page tracking data for MMIO2. */