Changeset 93650 in vbox for trunk/src/VBox

Timestamp:

Feb 8, 2022 10:43:53 AM (3 years ago)

Author:

vboxsync

Message:

VMM/PGM,*: Split the physical access handler type registration into separate ring-0 and ring-3 steps, expanding the type to 64-bit. bugref:10094

Location:

trunk/src/VBox

Files:

• Devices/Graphics/DevVGA-SVGA.cpp (modified) (4 diffs)
• Devices/Graphics/DevVGA-SVGA.h (modified) (1 diff)
• Runtime/Makefile.kmk (modified) (3 diffs)
• VMM/Makefile.kmk (modified) (1 diff)
• VMM/VMMAll/IEMAllCImplVmxInstr.cpp.h (modified) (1 diff)
• VMM/VMMAll/IOMAllMmioNew.cpp (modified) (2 diffs)
• VMM/VMMAll/MMAllHyper.cpp (modified) (1 diff)
• VMM/VMMAll/PGMAllBth.h (modified) (4 diffs)
• VMM/VMMAll/PGMAllHandler.cpp (modified) (23 diffs)
• VMM/VMMAll/PGMAllPhys.cpp (modified) (13 diffs)
• VMM/VMMR0/IEMR0.cpp (added)
• VMM/VMMR0/IOMR0.cpp (modified) (2 diffs)
• VMM/VMMR0/PDMR0DevHlp.cpp (modified) (3 diffs)
• VMM/VMMR0/PGMR0.cpp (modified) (7 diffs)
• VMM/VMMR0/PGMR0Pool.cpp (modified) (1 diff)
• VMM/VMMR0/VMMR0.cpp (modified) (5 diffs)
• VMM/VMMR3/IEMR3.cpp (modified) (1 diff)
• VMM/VMMR3/IOM.cpp (modified) (1 diff)
• VMM/VMMR3/PDMDevHlp.cpp (modified) (2 diffs)
• VMM/VMMR3/PGM.cpp (modified) (4 diffs)
• VMM/VMMR3/PGMHandler.cpp (modified) (6 diffs)
• VMM/VMMR3/PGMPhys.cpp (modified) (1 diff)
• VMM/VMMR3/PGMPool.cpp (modified) (1 diff)
• VMM/include/GIMInternal.h (modified) (1 diff)
• VMM/include/IEMInternal.h (modified) (2 diffs)
• VMM/include/IOMInternal.h (modified) (1 diff)
• VMM/include/PGMInline.h (modified) (1 diff)
• VMM/include/PGMInternal.h (modified) (11 diffs)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

@@ -6219 +6219 @@
     pSVGAState = pThisCC->svga.pSvgaR3State;
 
-    /* Register the write-protected GBO access handler type. */
-    rc = PDMDevHlpPGMHandlerPhysicalTypeRegister(pDevIns, PGMPHYSHANDLERKIND_WRITE,
-                                                 vmsvgaR3GboAccessHandler,
-                                                 NULL, NULL,
-                                                 NULL, NULL,
+    /* Register the write-protected GBO access handler type (no ring-0 callbacks here). */
+    rc = PDMDevHlpPGMHandlerPhysicalTypeRegister(pDevIns, PGMPHYSHANDLERKIND_WRITE, vmsvgaR3GboAccessHandler,
                                                  "VMSVGA GBO", &pSVGAState->hGboAccessHandlerType);
     AssertRCReturn(rc, rc);
@@ -6273 +6270 @@
 # ifdef DEBUG_GMR_ACCESS
     /* Register the GMR access handler type. */
-    rc = PDMDevHlpPGMHandlerPhysicalTypeRegister(pDevIns, PGMPHYSHANDLERKIND_WRITE,
-                                                 vmsvgaR3GmrAccessHandler,
-                                                 NULL, NULL,
-                                                 NULL, NULL,
+    rc = PDMDevHlpPGMHandlerPhysicalTypeRegister(pDevIns, PGMPHYSHANDLERKIND_WRITE, vmsvgaR3GmrAccessHandler,
                                                  "VMSVGA GMR", &pThis->svga.hGmrAccessHandlerType);
     AssertRCReturn(rc, rc);
@@ -6282 +6276 @@
 
 # if defined(VMSVGA_USE_FIFO_ACCESS_HANDLER) || defined(DEBUG_FIFO_ACCESS)
-    /* Register the FIFO access handler type.  In addition to
-       debugging FIFO access, this is also used to facilitate
-       extended fifo thread sleeps. */
+    /* Register the FIFO access handler type.  In addition to debugging FIFO
+       access, this is also used to facilitate extended fifo thread sleeps. */
     rc = PDMDevHlpPGMHandlerPhysicalTypeRegister(pDevIns,
 #  ifdef DEBUG_FIFO_ACCESS
@@ -6292 +6285 @@
 #  endif
                                                  vmsvgaR3FifoAccessHandler,
-                                                 NULL, NULL,
-                                                 NULL, NULL,
                                                  "VMSVGA FIFO", &pThis->svga.hFifoAccessHandlerType);
     AssertRCReturn(rc, rc);

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.h

@@ -370 +370 @@
     /** FIFO debug access handler type handle. */
     PGMPHYSHANDLERTYPE          hFifoAccessHandlerType;
-#elif defined(DEBUG_GMR_ACCESS)
-    uint32_t                    uPadding1;
 #endif
     /** Number of GMRs (VMSVGA_MAX_GMR_IDS, count of elements in VMSVGAR3STATE::paGMR array). */

trunk/src/VBox/Runtime/Makefile.kmk

@@ -2789 +2789 @@
         common/misc/term.cpp \
         common/path/RTPathFilename.cpp \
+        common/rand/rand.cpp \
+        common/rand/randadv.cpp \
+        common/rand/randparkmiller.cpp \
         common/string/strprintf-ellipsis.cpp \
         common/string/strprintf2-ellipsis.cpp \
@@ -2794 +2797 @@
         common/string/strncmp.cpp \
         common/string/strpbrk.cpp \
+        common/string/strtonum.cpp \
         common/string/RTStrCat.cpp \
         common/string/RTStrCatEx.cpp \
@@ -2824 +2828 @@
         generic/critsect-generic.cpp \
         generic/critsectrw-generic.cpp \
+        generic/RTRandAdvCreateSystemFaster-generic.cpp \
+        generic/RTRandAdvCreateSystemTruer-generic.cpp \
         \
         $(RuntimeNoCrt_SOURCES)

trunk/src/VBox/VMM/Makefile.kmk

@@ -481 +481 @@
         VMMR0/HMVMXR0.cpp \
         VMMR0/HMSVMR0.cpp \
+        VMMR0/IEMR0.cpp \
         VMMR0/IOMR0.cpp \
         VMMR0/IOMR0IoPort.cpp \

trunk/src/VBox/VMM/VMMAll/IEMAllCImplVmxInstr.cpp.h

@@ -6851 +6851 @@
         if (!PGMHandlerPhysicalIsRegistered(pVCpu->CTX_SUFF(pVM), GCPhysApicAccess))
         {
-            PVMCC pVM       = pVCpu->CTX_SUFF(pVM);
-            PVMCPUCC pVCpu0 = VMCC_GET_CPU_0(pVM);
+            PVMCC pVM = pVCpu->CTX_SUFF(pVM);
             int rc = PGMHandlerPhysicalRegister(pVM, GCPhysApicAccess, GCPhysApicAccess + X86_PAGE_4K_SIZE - 1,
-                                                pVCpu0->iem.s.hVmxApicAccessPage, 0 /*uUser*/, NULL /*pszDesc*/);
+                                                pVM->iem.s.hVmxApicAccessPage, 0 /*uUser*/, NULL /*pszDesc*/);
             if (RT_SUCCESS(rc))
             { /* likely */ }

trunk/src/VBox/VMM/VMMAll/IOMAllMmioNew.cpp

@@ -728 +728 @@
  * @remarks The @a uUser argument is the MMIO handle.
  */
-DECLEXPORT(VBOXSTRICTRC) iomMmioPfHandlerNew(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore,
-                                             RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
+DECLCALLBACK(VBOXSTRICTRC) iomMmioPfHandlerNew(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pCtxCore,
+                                               RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
 {
     STAM_PROFILE_START(&pVM->iom.s.StatMmioPfHandler, Prf);
@@ -797 +797 @@
  * @remarks The @a uUser argument is the MMIO handle.
  */
-PGM_ALL_CB2_DECL(VBOXSTRICTRC) iomMmioHandlerNew(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf,
-                                                 size_t cbBuf, PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
+DECLCALLBACK(VBOXSTRICTRC) iomMmioHandlerNew(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhysFault, void *pvPhys, void *pvBuf,
+                                             size_t cbBuf, PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
 {
     STAM_PROFILE_START(UnusedMacroArg, Prf);

trunk/src/VBox/VMM/VMMAll/MMAllHyper.cpp

@@ -1260 +1260 @@
 
 /**
- * Converts a context neutral heap offset into a pointer.
- *
- * @returns Pointer to hyper heap data.
- * @param   pVM         The cross context VM structure.
- * @param   offHeap     The hyper heap offset.
- */
-VMMDECL(void *) MMHyperHeapOffsetToPtr(PVM pVM, uint32_t offHeap)
-{
-    Assert(offHeap - MMYPERHEAP_HDR_SIZE <= pVM->mm.s.CTX_SUFF(pHyperHeap)->cbHeap);
-    return (uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap) + offHeap;
-}
-
-
-/**
- * Converts a context specific heap pointer into a neutral heap offset.
- *
- * @returns Heap offset.
- * @param   pVM         The cross context VM structure.
- * @param   pv          Pointer to the heap data.
- */
-VMMDECL(uint32_t) MMHyperHeapPtrToOffset(PVM pVM, void *pv)
-{
-    size_t offHeap = (uint8_t *)pv - (uint8_t *)pVM->mm.s.CTX_SUFF(pHyperHeap);
-    Assert(offHeap - MMYPERHEAP_HDR_SIZE <= pVM->mm.s.CTX_SUFF(pHyperHeap)->cbHeap);
-    return (uint32_t)offHeap;
-}
-
-
-/**
  * Checks if an address is within the hypervisor memory area.
  *

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

@@ -243 +243 @@
         if (pCur)
         {
-            PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+            PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
 
 #  ifdef PGM_SYNC_N_PAGES
@@ -312 +312 @@
             }
 
-            if (pCurType->CTX_SUFF(pfnPfHandler))
+            if (pCurType->pfnPfHandler)
             {
                 STAM_PROFILE_START(&pCur->Stat, h);
@@ -318 +318 @@
                 if (pCurType->fKeepPgmLock)
                 {
-                    rcStrict = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault,
-                                                                !pCurType->fRing0DevInsIdx ? pCur->uUser
-                                                                : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser));
+                    rcStrict = pCurType->pfnPfHandler(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault,
+                                                      !pCurType->fRing0DevInsIdx ? pCur->uUser
+                                                      : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser));
 
 #  ifdef VBOX_WITH_STATISTICS
@@ -335 +335 @@
                     *pfLockTaken = false;
 
-                    rcStrict = pCurType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault, uUser);
+                    rcStrict = pCurType->pfnPfHandler(pVM, pVCpu, uErr, pRegFrame, pvFault, GCPhysFault, uUser);
 
 #  ifdef VBOX_WITH_STATISTICS

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

@@ -47 +47 @@
 
 /*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Dummy physical access handler type record. */
+CTX_SUFF(PGMPHYSHANDLERTYPEINT) const g_pgmHandlerPhysicalDummyType =
+{
+    /* .hType = */              UINT64_C(0x93b7557e1937aaff),
+    /* .enmKind = */            PGMPHYSHANDLERKIND_INVALID,
+    /* .uState = */             PGM_PAGE_HNDL_PHYS_STATE_ALL,
+    /* .fKeepPgmLock = */       true,
+    /* .fRing0DevInsIdx = */    false,
+#ifdef IN_RING0
+    /* .afPadding = */          {false},
+    /* .pfnHandler = */         pgmR0HandlerPhysicalHandlerToRing3,
+    /* .pfnPfHandler = */       pgmR0HandlerPhysicalPfHandlerToRing3,
+#elif defined(IN_RING3)
+    /* .fRing0Enabled = */      false,
+    /* .pfnHandler = */         pgmR3HandlerPhysicalHandlerInvalid,
+#else
+# error "unsupported context"
+#endif
+    /* .pszDesc = */            "dummy"
+};
+
+
+/*********************************************************************************************************************************
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
@@ -55 +80 @@
 
 
-/**
- * Internal worker for releasing a physical handler type registration reference.
- *
- * @returns New reference count. UINT32_MAX if invalid input (asserted).
- * @param   pVM         The cross context VM structure.
- * @param   pType       Pointer to the type registration.
- */
-DECLINLINE(uint32_t) pgmHandlerPhysicalTypeRelease(PVMCC pVM, PPGMPHYSHANDLERTYPEINT pType)
-{
-    AssertMsgReturn(pType->u32Magic == PGMPHYSHANDLERTYPEINT_MAGIC, ("%#x\n", pType->u32Magic), UINT32_MAX);
-    uint32_t cRefs = ASMAtomicDecU32(&pType->cRefs);
-    if (cRefs == 0)
-    {
-        PGM_LOCK_VOID(pVM);
-        pType->u32Magic = PGMPHYSHANDLERTYPEINT_MAGIC_DEAD;
-        RTListOff32NodeRemove(&pType->ListNode);
-        PGM_UNLOCK(pVM);
-        MMHyperFree(pVM, pType);
-    }
-    return cRefs;
-}
-
-
-/**
- * Internal worker for retaining a physical handler type registration reference.
- *
- * @returns New reference count. UINT32_MAX if invalid input (asserted).
- * @param   pVM         The cross context VM structure.
- * @param   pType       Pointer to the type registration.
- */
-DECLINLINE(uint32_t) pgmHandlerPhysicalTypeRetain(PVM pVM, PPGMPHYSHANDLERTYPEINT pType)
-{
-    NOREF(pVM);
-    AssertMsgReturn(pType->u32Magic == PGMPHYSHANDLERTYPEINT_MAGIC, ("%#x\n", pType->u32Magic), UINT32_MAX);
-    uint32_t cRefs = ASMAtomicIncU32(&pType->cRefs);
-    Assert(cRefs < _1M && cRefs > 0);
-    return cRefs;
-}
-
-
-/**
- * Releases a reference to a physical handler type registration.
- *
- * @returns New reference count. UINT32_MAX if invalid input (asserted).
- * @param   pVM         The cross context VM structure.
- * @param   hType       The type regiration handle.
- */
-VMMDECL(uint32_t) PGMHandlerPhysicalTypeRelease(PVMCC pVM, PGMPHYSHANDLERTYPE hType)
-{
-    if (hType != NIL_PGMPHYSHANDLERTYPE)
-        return pgmHandlerPhysicalTypeRelease(pVM, PGMPHYSHANDLERTYPEINT_FROM_HANDLE(pVM, hType));
-    return 0;
-}
-
-
-/**
- * Retains a reference to a physical handler type registration.
- *
- * @returns New reference count. UINT32_MAX if invalid input (asserted).
- * @param   pVM         The cross context VM structure.
- * @param   hType       The type regiration handle.
- */
-VMMDECL(uint32_t) PGMHandlerPhysicalTypeRetain(PVM pVM, PGMPHYSHANDLERTYPE hType)
-{
-    return pgmHandlerPhysicalTypeRetain(pVM, PGMPHYSHANDLERTYPEINT_FROM_HANDLE(pVM, hType));
-}
+#ifndef IN_RING3
+
+/**
+ * @callback_method_impl{FNPGMPHYSHANDLER,
+ *      Dummy for forcing ring-3 handling of the access.}
+ */
+DECLCALLBACK(VBOXSTRICTRC)
+pgmR0HandlerPhysicalHandlerToRing3(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
+                                   PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
+{
+    RT_NOREF(pVM, pVCpu, GCPhys, pvPhys, pvBuf, cbBuf, enmAccessType, enmOrigin, uUser);
+    return VINF_EM_RAW_EMULATE_INSTR;
+}
+
+
+/**
+ * @callback_method_impl{FNPGMRZPHYSPFHANDLER,
+ *      Dummy for forcing ring-3 handling of the access.}
+ */
+DECLCALLBACK(VBOXSTRICTRC)
+pgmR0HandlerPhysicalPfHandlerToRing3(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
+                                     RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
+{
+    RT_NOREF(pVM, pVCpu, uErrorCode, pRegFrame, pvFault, GCPhysFault, uUser);
+    return VINF_EM_RAW_EMULATE_INSTR;
+}
+
+#endif /* !IN_RING3 */
 
 
@@ -145 +132 @@
                                R3PTRTYPE(const char *) pszDesc, PPGMPHYSHANDLER *ppPhysHandler)
 {
-    PPGMPHYSHANDLERTYPEINT pType = PGMPHYSHANDLERTYPEINT_FROM_HANDLE(pVM, hType);
+    /*
+     * Validate input.
+     */
+    PCPGMPHYSHANDLERTYPEINT const pType = pgmHandlerPhysicalTypeHandleToPtr(pVM, hType);
+    AssertReturn(pType, VERR_INVALID_HANDLE);
+    AssertReturn(pType->enmKind > PGMPHYSHANDLERKIND_INVALID && pType->enmKind < PGMPHYSHANDLERKIND_END, VERR_INVALID_HANDLE);
+    AssertPtr(ppPhysHandler);
+
     Log(("pgmHandlerPhysicalExCreate: uUser=%#RX64 hType=%#x (%d, %s) pszDesc=%RHv:%s\n",
-         uUser, hType, pType->enmKind, R3STRING(pType->pszDesc), pszDesc, R3STRING(pszDesc)));
-
-    /*
-     * Validate input.
-     */
-    AssertPtr(ppPhysHandler);
-    AssertReturn(pType->u32Magic == PGMPHYSHANDLERTYPEINT_MAGIC, VERR_INVALID_HANDLE);
+         uUser, hType, pType->enmKind, pType->pszDesc, pszDesc, R3STRING(pszDesc)));
 
     /*
@@ -169 +157 @@
         pNew->uUser         = uUser;
         pNew->hType         = hType;
-        pNew->pszDesc       = pszDesc != NIL_RTR3PTR ? pszDesc : pType->pszDesc;
-        pgmHandlerPhysicalTypeRetain(pVM, pType);
+        pNew->pszDesc       = pszDesc != NIL_RTR3PTR ? pszDesc
+#ifdef IN_RING3
+                            : pType->pszDesc;
+#else
+                            : pVM->pgm.s.aPhysHandlerTypes[hType].pszDesc;
+#endif
         *ppPhysHandler = pNew;
         return VINF_SUCCESS;
@@ -213 +205 @@
      * Validate input.
      */
+    PGMPHYSHANDLERTYPE const      hType = pPhysHandler->hType;
+    PCPGMPHYSHANDLERTYPEINT const pType = pgmHandlerPhysicalTypeHandleToPtr(pVM, hType);
+    AssertReturn(pType, VERR_INVALID_HANDLE);
+    AssertReturn(pType->enmKind > PGMPHYSHANDLERKIND_INVALID && pType->enmKind < PGMPHYSHANDLERKIND_END, VERR_INVALID_HANDLE);
+
     AssertPtr(pPhysHandler);
-    PPGMPHYSHANDLERTYPEINT pType = PGMPHYSHANDLERTYPEINT_FROM_HANDLE(pVM, pPhysHandler->hType);
-    Assert(pType->u32Magic == PGMPHYSHANDLERTYPEINT_MAGIC);
-    Log(("pgmHandlerPhysicalExRegister: GCPhys=%RGp GCPhysLast=%RGp hType=%#x (%d, %s) pszDesc=%RHv:%s\n",
-         GCPhys, GCPhysLast, pPhysHandler->hType, pType->enmKind, R3STRING(pType->pszDesc), pPhysHandler->pszDesc, R3STRING(pPhysHandler->pszDesc)));
+
+    Log(("pgmHandlerPhysicalExRegister: GCPhys=%RGp GCPhysLast=%RGp hType=%#x (%d, %s) pszDesc=%RHv:%s\n", GCPhys, GCPhysLast,
+         hType, pType->enmKind, pType->pszDesc, pPhysHandler->pszDesc, R3STRING(pPhysHandler->pszDesc)));
     AssertReturn(pPhysHandler->Core.Key == NIL_RTGCPHYS, VERR_WRONG_ORDER);
 
@@ -313 +309 @@
 {
 #ifdef LOG_ENABLED
-    PPGMPHYSHANDLERTYPEINT pType = PGMPHYSHANDLERTYPEINT_FROM_HANDLE(pVM, hType);
+    PCPGMPHYSHANDLERTYPEINT pType = pgmHandlerPhysicalTypeHandleToPtr(pVM, hType);
     Log(("PGMHandlerPhysicalRegister: GCPhys=%RGp GCPhysLast=%RGp uUser=%#RX64 hType=%#x (%d, %s) pszDesc=%RHv:%s\n",
          GCPhys, GCPhysLast, uUser, hType, pType->enmKind, R3STRING(pType->pszDesc), pszDesc, R3STRING(pszDesc)));
@@ -353 +349 @@
     bool                    fFlushTLBs = false;
     int                     rc         = VINF_SUCCESS;
-    PPGMPHYSHANDLERTYPEINT  pCurType   = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+    PCPGMPHYSHANDLERTYPEINT pCurType   = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
     const unsigned          uState     = pCurType->uState;
     uint32_t                cPages     = pCur->cPages;
@@ -483 +479 @@
         AssertPtr(pHandler);
         AssertReturn(pHandler->Core.Key == NIL_RTGCPHYS, VERR_WRONG_ORDER);
-        PGMHandlerPhysicalTypeRelease(pVM, pHandler->hType);
         MMHyperFree(pVM, pHandler);
     }
@@ -539 +534 @@
 {
 #ifdef VBOX_WITH_NATIVE_NEM
-    PPGMPHYSHANDLERTYPEINT  pCurType    = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+    PCPGMPHYSHANDLERTYPEINT pCurType    = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
     RTGCPHYS                GCPhysStart = pCur->Core.Key;
     RTGCPHYS                GCPhysLast  = pCur->Core.KeyLast;
@@ -623 +618 @@
             || ((fAbove ? pCur->Core.Key : pCur->Core.KeyLast) >> GUEST_PAGE_SHIFT) != (GCPhys >> GUEST_PAGE_SHIFT))
             break;
-        PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+        PCPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
         uState = RT_MAX(uState, pCurType->uState);
 
@@ -636 +631 @@
 
     /*
-     * Update if we found something that is a higher priority
-     * state than the current.
+     * Update if we found something that is a higher priority state than the current.
      */
     if (uState != PGM_PAGE_HNDL_PHYS_STATE_NONE)
@@ -786 +780 @@
             }
 #ifdef VBOX_STRICT
-            PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-            AssertMsg(pCurType->enmKind != PGMPHYSHANDLERKIND_MMIO || PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", GCPhys, pPage));
+            PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+            AssertMsg(pCurType && (pCurType->enmKind != PGMPHYSHANDLERKIND_MMIO || PGM_PAGE_IS_MMIO(pPage)),
+                      ("%RGp %R[pgmpage]\n", GCPhys, pPage));
 #endif
             PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_NONE);
@@ -855 +850 @@
          */
         pgmHandlerPhysicalResetRamFlags(pVM, pCur);
-        PPGMPHYSHANDLERTYPEINT const pCurType      = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+        PCPGMPHYSHANDLERTYPEINT const pCurType     = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
+        @todo pCurType validation
         bool const                   fRestoreAsRAM = pCurType->pfnHandlerR3 /** @todo this isn't entirely correct. */
                                                   && pCurType->enmKind != PGMPHYSHANDLERKIND_MMIO;
@@ -1141 +1137 @@
          * Validate kind.
          */
-        PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+        PCPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
         switch (pCurType->enmKind)
         {
@@ -1205 +1201 @@
              */
             default:
-                AssertMsgFailed(("Invalid type %d! Corruption!\n",  pCurType->enmKind));
+                AssertMsgFailed(("Invalid type %d/%#x! Corruption!\n",  pCurType->enmKind, pCur->hType));
                 rc = VERR_PGM_PHYS_HANDLER_IPE;
                 break;
@@ -1249 +1245 @@
          * Validate kind.
          */
-        PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-        if (pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE)
+        PCPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+        if (   pCurType
+            && pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE)
         {
             STAM_COUNTER_INC(&pVM->pgm.s.Stats.CTX_MID_Z(Stat,PhysHandlerReset));
@@ -1316 +1313 @@
     if (RT_LIKELY(pCur))
     {
-        if (RT_LIKELY(    GCPhysPage >= pCur->Core.Key
-                      &&  GCPhysPage <= pCur->Core.KeyLast))
+        if (RT_LIKELY(   GCPhysPage >= pCur->Core.Key
+                      && GCPhysPage <= pCur->Core.KeyLast))
         {
             Assert(!(pCur->Core.Key & GUEST_PAGE_OFFSET_MASK));
             Assert((pCur->Core.KeyLast & GUEST_PAGE_OFFSET_MASK) == GUEST_PAGE_OFFSET_MASK);
 
-            PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-            AssertReturnStmt(   pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE
-                             || pCurType->enmKind == PGMPHYSHANDLERKIND_ALL,
+            PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+            AssertReturnStmt(   pCurType
+                             && (   pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE
+                                 || pCurType->enmKind == PGMPHYSHANDLERKIND_ALL),
                              PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
 
@@ -1488 +1486 @@
                       && GCPhysPage <= pCur->Core.KeyLast))
         {
-            PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+            PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
             AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
             AssertReturnStmt(!(pCur->Core.Key & GUEST_PAGE_OFFSET_MASK), PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
@@ -1617 +1615 @@
                       &&  GCPhysPage <= pCur->Core.KeyLast))
         {
-            PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+            PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
             AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
             AssertReturnStmt(!(pCur->Core.Key & GUEST_PAGE_OFFSET_MASK), PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
@@ -1706 +1704 @@
 #ifdef VBOX_STRICT
         Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
-        PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+        PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
         Assert(   pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE
                || pCurType->enmKind == PGMPHYSHANDLERKIND_ALL
@@ -1740 +1738 @@
         return true;
     }
-    PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+
+    /* Only whole pages can be disabled. */
+    Assert(   pCur->Core.Key     <= (GCPhys & ~(RTGCPHYS)GUEST_PAGE_OFFSET_MASK)
+           && pCur->Core.KeyLast >= (GCPhys | GUEST_PAGE_OFFSET_MASK));
+
+    PCPGMPHYSHANDLERTYPEINT const pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
     Assert(   pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE
            || pCurType->enmKind == PGMPHYSHANDLERKIND_ALL
            || pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO); /* sanity */
-    /* Only whole pages can be disabled. */
-    Assert(   pCur->Core.Key     <= (GCPhys & ~(RTGCPHYS)GUEST_PAGE_OFFSET_MASK)
-           && pCur->Core.KeyLast >= (GCPhys | GUEST_PAGE_OFFSET_MASK));
-
-    bool bRet = pCurType->enmKind != PGMPHYSHANDLERKIND_WRITE;
+    bool const fRet = pCurType->enmKind != PGMPHYSHANDLERKIND_WRITE;
     PGM_UNLOCK(pVM);
-    return bRet;
+    return fRet;
 }
 
@@ -1818 +1817 @@
                     if (pPhys)
                     {
-                        PPGMPHYSHANDLERTYPEINT pPhysType = (PPGMPHYSHANDLERTYPEINT)MMHyperHeapOffsetToPtr(pVM, pPhys->hType);
+                        PCPGMPHYSHANDLERTYPEINT pPhysType = pgmHandlerPhysicalTypeHandleToPtr(pVM, pPhys->hType);
                         unsigned uState = pPhysType->uState;
 
@@ -1829 +1828 @@
                                 ||  pPhys2->Core.Key > (State.GCPhys | GUEST_PAGE_OFFSET_MASK))
                                 break;
-                            PPGMPHYSHANDLERTYPEINT pPhysType2 = (PPGMPHYSHANDLERTYPEINT)MMHyperHeapOffsetToPtr(pVM, pPhys2->hType);
+                            PCPGMPHYSHANDLERTYPEINT pPhysType2 = pgmHandlerPhysicalTypeHandleToPtr(pVM, pPhys2->hType);
                             uState = RT_MAX(uState, pPhysType2->uState);
                             pPhys = pPhys2;

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

@@ -114 +114 @@
 
 
-#ifndef IN_RING3
-
-/**
- * @callback_method_impl{FNPGMPHYSHANDLER,
- *      Dummy for forcing ring-3 handling of the access.}
- */
-DECLEXPORT(VBOXSTRICTRC)
-pgmPhysHandlerRedirectToHC(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
-                           PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
-{
-    RT_NOREF(pVM, pVCpu, GCPhys, pvPhys, pvBuf, cbBuf, enmAccessType, enmOrigin, uUser);
-    return VINF_EM_RAW_EMULATE_INSTR;
-}
-
-
-/**
- * @callback_method_impl{FNPGMRZPHYSPFHANDLER,
- *      Dummy for forcing ring-3 handling of the access.}
- */
-VMMDECL(VBOXSTRICTRC) pgmPhysPfHandlerRedirectToHC(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
-                                                   RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
-{
-    RT_NOREF(pVM, pVCpu, uErrorCode, pRegFrame, pvFault, GCPhysFault, uUser);
-    return VINF_EM_RAW_EMULATE_INSTR;
-}
-
-#endif /* !IN_RING3 */
-
 /**
  * Looks up a ROM range by its PGMROMRANGE::GCPhys value.
@@ -161 +133 @@
  * @remarks The @a uUser argument is the PGMROMRANGE::GCPhys value.
  */
-DECLEXPORT(VBOXSTRICTRC) pgmPhysRomWritePfHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
-                                                  RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
+DECLCALLBACK(VBOXSTRICTRC) pgmPhysRomWritePfHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
+                                                    RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
 
 {
@@ -233 +205 @@
  * @remarks The @a uUser argument is the PGMROMRANGE::GCPhys value.
  */
-PGM_ALL_CB2_DECL(VBOXSTRICTRC)
+DECLCALLBACK(VBOXSTRICTRC)
 pgmPhysRomWriteHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
                        PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
@@ -396 +368 @@
  * @remarks The @a uUser is the MMIO2 index.
  */
-DECLEXPORT(VBOXSTRICTRC) pgmPhysMmio2WritePfHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
-                                                    RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
+DECLCALLBACK(VBOXSTRICTRC) pgmPhysMmio2WritePfHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame,
+                                                      RTGCPTR pvFault, RTGCPHYS GCPhysFault, uint64_t uUser)
 {
     RT_NOREF(pVCpu, uErrorCode, pRegFrame);
@@ -417 +389 @@
  * @remarks The @a uUser is the MMIO2 index.
  */
-PGM_ALL_CB2_DECL(VBOXSTRICTRC)
+DECLCALLBACK(VBOXSTRICTRC)
 pgmPhysMmio2WriteHandler(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, void *pvPhys, void *pvBuf, size_t cbBuf,
                          PGMACCESSTYPE enmAccessType, PGMACCESSORIGIN enmOrigin, uint64_t uUser)
@@ -2436 +2408 @@
     {
         PPGMPHYSHANDLER pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
-        AssertReleaseMsg(pCur, ("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
-        Assert(GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
-        Assert((pCur->Core.Key     & GUEST_PAGE_OFFSET_MASK) == 0);
-        Assert((pCur->Core.KeyLast & GUEST_PAGE_OFFSET_MASK) == GUEST_PAGE_OFFSET_MASK);
+        if (pCur)
+        {
+            Assert(pCur && GCPhys >= pCur->Core.Key && GCPhys <= pCur->Core.KeyLast);
+            Assert((pCur->Core.Key     & GUEST_PAGE_OFFSET_MASK) == 0);
+            Assert((pCur->Core.KeyLast & GUEST_PAGE_OFFSET_MASK) == GUEST_PAGE_OFFSET_MASK);
 #ifndef IN_RING3
-        if (enmOrigin != PGMACCESSORIGIN_IEM)
-        {
-            /* Cannot reliably handle informational status codes in this context */
-            pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
-            return VERR_PGM_PHYS_WR_HIT_HANDLER;
-        }
+            if (enmOrigin != PGMACCESSORIGIN_IEM)
+            {
+                /* Cannot reliably handle informational status codes in this context */
+                pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
+                return VERR_PGM_PHYS_WR_HIT_HANDLER;
+            }
 #endif
-        PPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-        PFNPGMPHYSHANDLER const      pfnHandler = pCurType->CTX_SUFF(pfnHandler); Assert(pfnHandler);
-        uint64_t const               uUser      = !pCurType->fRing0DevInsIdx ? pCur->uUser
-                                                : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser);
-
-        Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cb, pPage, R3STRING(pCur->pszDesc) ));
-        STAM_PROFILE_START(&pCur->Stat, h);
-        PGM_LOCK_ASSERT_OWNER(pVM);
-
-        /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
-        PGM_UNLOCK(pVM);
-        rcStrict = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, uUser);
-        PGM_LOCK_VOID(pVM);
+            PCPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
+            PFNPGMPHYSHANDLER const       pfnHandler = pCurType->pfnHandler; Assert(pfnHandler);
+            uint64_t const                uUser      = !pCurType->fRing0DevInsIdx ? pCur->uUser
+                                                     : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser);
+
+            Log5(("pgmPhysReadHandler: GCPhys=%RGp cb=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cb, pPage, R3STRING(pCur->pszDesc) ));
+            STAM_PROFILE_START(&pCur->Stat, h);
+            PGM_LOCK_ASSERT_OWNER(pVM);
+
+            /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
+            PGM_UNLOCK(pVM);
+            rcStrict = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, uUser);
+            PGM_LOCK_VOID(pVM);
 
 #ifdef VBOX_WITH_STATISTICS
-        pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
-        if (pCur)
-            STAM_PROFILE_STOP(&pCur->Stat, h);
+            pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
+            if (pCur)
+                STAM_PROFILE_STOP(&pCur->Stat, h);
 #else
-        pCur = NULL; /* might not be valid anymore. */
+            pCur = NULL; /* might not be valid anymore. */
 #endif
-        AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict, false),
-                        ("rcStrict=%Rrc GCPhys=%RGp\n", VBOXSTRICTRC_VAL(rcStrict), GCPhys));
-        if (   rcStrict != VINF_PGM_HANDLER_DO_DEFAULT
-            && !PGM_PHYS_RW_IS_SUCCESS(rcStrict))
-        {
-            pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
-            return rcStrict;
-        }
+            AssertLogRelMsg(PGM_HANDLER_PHYS_IS_VALID_STATUS(rcStrict, false),
+                            ("rcStrict=%Rrc GCPhys=%RGp\n", VBOXSTRICTRC_VAL(rcStrict), GCPhys));
+            if (   rcStrict != VINF_PGM_HANDLER_DO_DEFAULT
+                && !PGM_PHYS_RW_IS_SUCCESS(rcStrict))
+            {
+                pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
+                return rcStrict;
+            }
+        }
+        else
+            AssertLogRelMsgFailed(("GCPhys=%RGp cb=%#x\n", GCPhys, cb));
     }
 
@@ -2665 +2641 @@
      * Give priority to physical handlers (like #PF does).
      *
-     * Hope for a lonely physical handler first that covers the whole
-     * write area. This should be a pretty frequent case with MMIO and
-     * the heavy usage of full page handlers in the page pool.
+     * Hope for a lonely physical handler first that covers the whole write
+     * area.  This should be a pretty frequent case with MMIO and the heavy
+     * usage of full page handlers in the page pool.
      */
     PVMCPUCC pVCpu = VMMGetCpu(pVM);
@@ -2683 +2659 @@
             cbRange = cbWrite;
 
-        Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->CTX_SUFF(pfnHandler));
+        Assert(PGMPHYSHANDLER_GET_TYPE(pVM, pCur)->pfnHandler);
         Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n",
               GCPhys, cbRange, pPage, R3STRING(pCur->pszDesc) ));
@@ -2692 +2668 @@
         if (RT_SUCCESS(rcStrict))
         {
-            PPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-            PFNPGMPHYSHANDLER const      pfnHandler = pCurType->CTX_SUFF(pfnHandler);
-            uint64_t const               uUser      = !pCurType->fRing0DevInsIdx ? pCur->uUser
-                                                    : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser);
+            PCPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
+            PFNPGMPHYSHANDLER const       pfnHandler = pCurType->pfnHandler;
+            uint64_t const                uUser      = !pCurType->fRing0DevInsIdx ? pCur->uUser
+                                                     : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pCur->uUser);
             STAM_PROFILE_START(&pCur->Stat, h);
 
@@ -2747 +2723 @@
     else /* The handler is somewhere else in the page, deal with it below. */
         rcStrict = VINF_SUCCESS;
-    Assert(!PGM_PAGE_IS_MMIO_OR_ALIAS(pPage)); /* MMIO handlers are all PAGE_SIZEed! */
+    Assert(!PGM_PAGE_IS_MMIO_OR_ALIAS(pPage)); /* MMIO handlers are all GUEST_PAGE_SIZEed! */
 
     /*
@@ -2763 +2739 @@
     }
 
+    /** @todo clean up this code some more now there are no virtual handlers any
+     *        more. */
     /* The loop state (big + ugly). */
     PPGMPHYSHANDLER pPhys       = NULL;
@@ -2804 +2782 @@
         VBOXSTRICTRC rcStrict2 = VINF_PGM_HANDLER_DO_DEFAULT;
         uint32_t cbRange = (uint32_t)cbWrite;
+        Assert(cbRange == cbWrite);
 
         /*
@@ -2818 +2797 @@
                 cbRange = offPhysLast + 1;
 
-            PPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE(pVM, pPhys);
-            PFNPGMPHYSHANDLER const      pfnHandler = pCurType->CTX_SUFF(pfnHandler);
-            uint64_t const               uUser      = !pCurType->fRing0DevInsIdx ? pPhys->uUser
-                                                    : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pPhys->uUser);
+            PCPGMPHYSHANDLERTYPEINT const pCurType   = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pPhys);
+            PFNPGMPHYSHANDLER const       pfnHandler = pCurType->pfnHandler;
+            uint64_t const                uUser      = !pCurType->fRing0DevInsIdx ? pPhys->uUser
+                                                     : (uintptr_t)PDMDeviceRing0IdxToInstance(pVM, pPhys->uUser);
 
             Log5(("pgmPhysWriteHandler: GCPhys=%RGp cbRange=%#x pPage=%R[pgmpage] phys %s\n", GCPhys, cbRange, pPage, R3STRING(pPhys->pszDesc) ));

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

@@ -22 +22 @@
 #define LOG_GROUP LOG_GROUP_IOM
 #include <VBox/vmm/iom.h>
+#include <VBox/vmm/pgm.h>
 #include "IOMInternal.h"
 #include <VBox/vmm/vmcc.h>
 #include <VBox/log.h>
+#include <iprt/assert.h>
 #include <iprt/assertcompile.h>
+#include <iprt/errcore.h>
 
 
@@ -48 +51 @@
 
 /**
+ * Called during ring-0 init (vmmR0InitVM).
+ *
+ * @returns VBox status code.
+ * @param   pGVM    Pointer to the global VM structure.
+ */
+VMMR0_INT_DECL(int) IOMR0InitVM(PGVM pGVM)
+{
+    int rc = PGMR0HandlerPhysicalTypeSetUpContext(pGVM, PGMPHYSHANDLERKIND_MMIO, 0 /*fFlags*/,
+                                                  iomMmioHandlerNew, iomMmioPfHandlerNew,
+                                                  "MMIO", pGVM->iom.s.hNewMmioHandlerType);
+    AssertRCReturn(rc, rc);
+    return VINF_SUCCESS;
+}
+
+
+/**
  * Cleans up any loose ends before the GVM structure is destroyed.
  */

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

@@ -1321 +1321 @@
     LogFlow(("pdmR0DevHlp_HpetSetUpContext: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
     return VINF_SUCCESS;
+}
+
+
+/** @interface_method_impl{PDMDEVHLPR0,pfnPGMHandlerPhysicalTypeSetUpContext} */
+static DECLCALLBACK(int) pdmR0DevHlp_PGMHandlerPhysicalTypeSetUpContext(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
+                                                                        PFNPGMPHYSHANDLER pfnHandler,
+                                                                        PFNPGMRZPHYSPFHANDLER pfnPfHandler,
+                                                                        const char *pszDesc, PGMPHYSHANDLERTYPE hType)
+{
+    PDMDEV_ASSERT_DEVINS(pDevIns);
+    LogFlow(("pdmR0DevHlp_PGMHandlerPhysicalTypeSetUpContext: caller='%s'/%d: enmKind=%d pfnHandler=%p pfnPfHandler=%p pszDesc=%p:{%s} hType=%#x\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmKind, pfnHandler, pfnPfHandler, pszDesc, pszDesc, hType));
+
+    int rc = PGMR0HandlerPhysicalTypeSetUpContext(pDevIns->Internal.s.pGVM, enmKind, PGMPHYSHANDLER_F_R0_DEVINS_IDX,
+                                                  pfnHandler, pfnPfHandler, pszDesc, hType);
+
+    Log(("pdmR0DevHlp_PGMHandlerPhysicalTypeSetUpContext: caller='%s'/%d: returns %Rrc\n",
+         pDevIns->pReg->szName, pDevIns->iInstance, rc));
+    return rc;
 }
 
@@ -1477 +1496 @@
     pdmR0DevHlp_IoApicSetUpContext,
     pdmR0DevHlp_HpetSetUpContext,
+    pdmR0DevHlp_PGMHandlerPhysicalTypeSetUpContext,
     pdmR0DevHlp_PGMHandlerPhysicalPageTempOff,
     pdmR0DevHlp_MmioMapMmio2Page,
@@ -1589 +1609 @@
     pdmR0DevHlp_IoApicSetUpContext,
     pdmR0DevHlp_HpetSetUpContext,
+    pdmR0DevHlp_PGMHandlerPhysicalTypeSetUpContext,
     pdmR0DevHlp_PGMHandlerPhysicalPageTempOff,
     pdmR0DevHlp_MmioMapMmio2Page,

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

@@ -35 +35 @@
 #include <iprt/mem.h>
 #include <iprt/memobj.h>
+#include <iprt/rand.h>
 #include <iprt/string.h>
 #include <iprt/time.h>
@@ -83 +84 @@
 
     /*
+     * Initialize the handler type table with return to ring-3 callbacks so we
+     * don't have to do anything special for ring-3 only registrations.
+     *
+     * Note! The random bits of the hType value is mainly for prevent trouble
+     *       with zero initialized handles w/o needing to sacrifice handle zero.
+     */
+    for (size_t i = 0; i < RT_ELEMENTS(pGVM->pgm.s.aPhysHandlerTypes); i++)
+    {
+        pGVM->pgmr0.s.aPhysHandlerTypes[i].hType        = i | (RTRandU64() & ~(uint64_t)PGMPHYSHANDLERTYPE_IDX_MASK);
+        pGVM->pgmr0.s.aPhysHandlerTypes[i].enmKind      = PGMPHYSHANDLERKIND_INVALID;
+        pGVM->pgmr0.s.aPhysHandlerTypes[i].pfnHandler   = pgmR0HandlerPhysicalHandlerToRing3;
+        pGVM->pgmr0.s.aPhysHandlerTypes[i].pfnPfHandler = pgmR0HandlerPhysicalPfHandlerToRing3;
+
+        pGVM->pgm.s.aPhysHandlerTypes[i].hType          = pGVM->pgmr0.s.aPhysHandlerTypes[i].hType;
+        pGVM->pgm.s.aPhysHandlerTypes[i].enmKind        = PGMPHYSHANDLERKIND_INVALID;
+    }
+
+    /*
      * Get the physical address of the ZERO and MMIO-dummy pages.
      */
@@ -107 +126 @@
 VMMR0_INT_DECL(int) PGMR0InitVM(PGVM pGVM)
 {
-    RT_NOREF(pGVM);
-    /* Was used for DynMap init */
-    return VINF_SUCCESS;
+    /*
+     * Set up the ring-0 context for our access handlers.
+     */
+    int rc = PGMR0HandlerPhysicalTypeSetUpContext(pGVM, PGMPHYSHANDLERKIND_WRITE, 0 /*fFlags*/,
+                                                  pgmPhysRomWriteHandler, pgmPhysRomWritePfHandler,
+                                                  "ROM write protection", pGVM->pgm.s.hRomPhysHandlerType);
+    AssertLogRelRCReturn(rc, rc);
+
+    /*
+     * Register the physical access handler doing dirty MMIO2 tracing.
+     */
+    rc = PGMR0HandlerPhysicalTypeSetUpContext(pGVM, PGMPHYSHANDLERKIND_WRITE, PGMPHYSHANDLER_F_KEEP_PGM_LOCK,
+                                              pgmPhysMmio2WriteHandler, pgmPhysMmio2WritePfHandler,
+                                              "MMIO2 dirty page tracing", pGVM->pgm.s.hMmio2DirtyPhysHandlerType);
+    AssertLogRelRCReturn(rc, rc);
+
+    /*
+     * The page pool.
+     */
+    return pgmR0PoolInitVM(pGVM);
+}
+
+
+/**
+ * Called at the end of the ring-0 initialization to seal access handler types.
+ *
+ * @returns VBox status code.
+ * @param   pGVM    Pointer to the global VM structure.
+ */
+VMMR0_INT_DECL(void) PGMR0DoneInitVM(PGVM pGVM)
+{
+    /*
+     * Seal all the access handler types. Does both ring-3 and ring-0.
+     *
+     * Note! Since this is a void function and we don't have any ring-0 state
+     *       machinery for marking the VM as bogus, this code will just
+     *       override corrupted values as best as it can.
+     */
+    AssertCompile(RT_ELEMENTS(pGVM->pgmr0.s.aPhysHandlerTypes) == RT_ELEMENTS(pGVM->pgm.s.aPhysHandlerTypes));
+    for (size_t i = 0; i < RT_ELEMENTS(pGVM->pgmr0.s.aPhysHandlerTypes); i++)
+    {
+        PPGMPHYSHANDLERTYPEINTR0 const pTypeR0   = &pGVM->pgmr0.s.aPhysHandlerTypes[i];
+        PPGMPHYSHANDLERTYPEINTR3 const pTypeR3   = &pGVM->pgm.s.aPhysHandlerTypes[i];
+        PGMPHYSHANDLERKIND       const enmKindR3 = pTypeR3->enmKind;
+        PGMPHYSHANDLERKIND       const enmKindR0 = pTypeR0->enmKind;
+        AssertLogRelMsgStmt(pTypeR0->hType == pTypeR3->hType,
+                            ("i=%u %#RX64 vs %#RX64 %s\n", i, pTypeR0->hType, pTypeR3->hType, pTypeR0->pszDesc),
+                            pTypeR3->hType = pTypeR0->hType);
+        switch (enmKindR3)
+        {
+            case PGMPHYSHANDLERKIND_ALL:
+            case PGMPHYSHANDLERKIND_MMIO:
+                if (   enmKindR0 == enmKindR3
+                    || enmKindR0 == PGMPHYSHANDLERKIND_INVALID)
+                {
+                    pTypeR3->fRing0Enabled = enmKindR0 == enmKindR3;
+                    pTypeR0->uState = PGM_PAGE_HNDL_PHYS_STATE_ALL;
+                    pTypeR3->uState = PGM_PAGE_HNDL_PHYS_STATE_ALL;
+                    continue;
+                }
+                break;
+
+            case PGMPHYSHANDLERKIND_WRITE:
+                if (   enmKindR0 == enmKindR3
+                    || enmKindR0 == PGMPHYSHANDLERKIND_INVALID)
+                {
+                    pTypeR3->fRing0Enabled = enmKindR0 == enmKindR3;
+                    pTypeR0->uState = PGM_PAGE_HNDL_PHYS_STATE_WRITE;
+                    pTypeR3->uState = PGM_PAGE_HNDL_PHYS_STATE_WRITE;
+                    continue;
+                }
+                break;
+
+            default:
+                AssertLogRelMsgFailed(("i=%u enmKindR3=%d\n", i, enmKindR3));
+                RT_FALL_THROUGH();
+            case PGMPHYSHANDLERKIND_INVALID:
+                AssertLogRelMsg(enmKindR0 == PGMPHYSHANDLERKIND_INVALID,
+                                ("i=%u enmKind=%d %s\n", i, enmKindR0, pTypeR0->pszDesc));
+                AssertLogRelMsg(pTypeR0->pfnHandler == pgmR0HandlerPhysicalHandlerToRing3,
+                                ("i=%u pfnHandler=%p %s\n", i, pTypeR0->pfnHandler, pTypeR0->pszDesc));
+                AssertLogRelMsg(pTypeR0->pfnPfHandler == pgmR0HandlerPhysicalPfHandlerToRing3,
+                                ("i=%u pfnPfHandler=%p %s\n", i, pTypeR0->pfnPfHandler, pTypeR0->pszDesc));
+
+                /* Unused of bad ring-3 entry, make it and the ring-0 one harmless. */
+                pTypeR3->enmKind         = PGMPHYSHANDLERKIND_END;
+                pTypeR3->fRing0DevInsIdx = false;
+                pTypeR3->fKeepPgmLock    = false;
+                pTypeR3->uState          = 0;
+                break;
+        }
+        pTypeR3->fRing0Enabled   = false;
+
+        /* Make sure the entry is harmless and goes to ring-3. */
+        pTypeR0->enmKind         = PGMPHYSHANDLERKIND_END;
+        pTypeR0->pfnHandler      = pgmR0HandlerPhysicalHandlerToRing3;
+        pTypeR0->pfnPfHandler    = pgmR0HandlerPhysicalPfHandlerToRing3;
+        pTypeR0->fRing0DevInsIdx = false;
+        pTypeR0->fKeepPgmLock    = false;
+        pTypeR0->uState          = 0;
+        pTypeR0->pszDesc         = "invalid";
+    }
 }
 
@@ -631 +749 @@
     return SUPR0PageMapKernel(pGVM->pSession, pvR3, (uint32_t)offSub, (uint32_t)cbSub, 0 /*fFlags*/, ppvMapping);
 #endif
+}
+
+
+/**
+ * Updates a physical access handler type with ring-0 callback functions.
+ *
+ * The handler type must first have been registered in ring-3.
+ *
+ * @returns VBox status code.
+ * @param   pGVM            The global (ring-0) VM structure.
+ * @param   enmKind         The kind of access handler.
+ * @param   fFlags          PGMPHYSHANDLER_F_XXX
+ * @param   pfnHandler      Pointer to the ring-0 handler callback.
+ * @param   pfnPfHandler    Pointer to the ring-0 \#PF handler callback.
+ *                          callback.
+ * @param   pszDesc         The type description.
+ * @param   hType           The handle to do ring-0 callback registrations for.
+ * @thread  EMT(0)
+ */
+VMMR0_INT_DECL(int) PGMR0HandlerPhysicalTypeSetUpContext(PGVM pGVM, PGMPHYSHANDLERKIND enmKind, uint32_t fFlags,
+                                                         PFNPGMPHYSHANDLER pfnHandler, PFNPGMRZPHYSPFHANDLER pfnPfHandler,
+                                                         const char *pszDesc, PGMPHYSHANDLERTYPE hType)
+{
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
+    AssertPtrReturn(pfnPfHandler, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
+    AssertReturn(   enmKind == PGMPHYSHANDLERKIND_WRITE
+                 || enmKind == PGMPHYSHANDLERKIND_ALL
+                 || enmKind == PGMPHYSHANDLERKIND_MMIO,
+                 VERR_INVALID_PARAMETER);
+    AssertMsgReturn(!(fFlags & ~PGMPHYSHANDLER_F_VALID_MASK), ("%#x\n", fFlags), VERR_INVALID_FLAGS);
+
+    PPGMPHYSHANDLERTYPEINTR0 const pTypeR0 = &pGVM->pgmr0.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+    AssertMsgReturn(hType == pTypeR0->hType, ("%#RX64, expected=%#RX64\n", hType, pTypeR0->hType), VERR_INVALID_HANDLE);
+    AssertCompile(RT_ELEMENTS(pGVM->pgmr0.s.aPhysHandlerTypes) == RT_ELEMENTS(pGVM->pgm.s.aPhysHandlerTypes));
+    AssertCompile(RT_ELEMENTS(pGVM->pgmr0.s.aPhysHandlerTypes) == PGMPHYSHANDLERTYPE_IDX_MASK + 1);
+    AssertReturn(pTypeR0->enmKind == PGMPHYSHANDLERKIND_INVALID, VERR_ALREADY_INITIALIZED);
+
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
+    AssertRCReturn(rc, rc);
+    VM_ASSERT_STATE_RETURN(pGVM, VMSTATE_CREATING, VERR_VM_INVALID_VM_STATE); /** @todo ring-0 safe state check. */
+
+    PPGMPHYSHANDLERTYPEINTR3 const pTypeR3 = &pGVM->pgm.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+    AssertMsgReturn(pTypeR3->enmKind == enmKind,
+                    ("%#x: %d, expected %d\n", hType, pTypeR3->enmKind, enmKind),
+                    VERR_INVALID_HANDLE);
+    AssertMsgReturn(pTypeR3->fKeepPgmLock == RT_BOOL(fFlags & PGMPHYSHANDLER_F_KEEP_PGM_LOCK),
+                    ("%#x: %d, fFlags=%d\n", hType, pTypeR3->fKeepPgmLock, fFlags),
+                    VERR_INVALID_HANDLE);
+    AssertMsgReturn(pTypeR3->fRing0DevInsIdx == RT_BOOL(fFlags & PGMPHYSHANDLER_F_R0_DEVINS_IDX),
+                    ("%#x: %d, fFlags=%d\n", hType, pTypeR3->fRing0DevInsIdx, fFlags),
+                    VERR_INVALID_HANDLE);
+
+    /*
+     * Update the entry.
+     */
+    pTypeR0->enmKind          = enmKind;
+    pTypeR0->uState           = enmKind == PGMPHYSHANDLERKIND_WRITE
+                              ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
+    pTypeR0->fKeepPgmLock     = RT_BOOL(fFlags & PGMPHYSHANDLER_F_KEEP_PGM_LOCK);
+    pTypeR0->fRing0DevInsIdx  = RT_BOOL(fFlags & PGMPHYSHANDLER_F_R0_DEVINS_IDX);
+    pTypeR0->pfnHandler       = pfnHandler;
+    pTypeR0->pfnPfHandler     = pfnPfHandler;
+    pTypeR0->pszDesc          = pszDesc;
+
+    pTypeR3->fRing0Enabled    = true;
+
+    LogFlow(("PGMR0HandlerPhysicalTypeRegister: hType=%#x: enmKind=%d fFlags=%#x pfnHandler=%p pfnPfHandler=%p pszDesc=%s\n",
+             hType, enmKind, fFlags, pfnHandler, pfnPfHandler, pszDesc));
+    return VINF_SUCCESS;
 }
 
@@ -965 +1156 @@
      */
     PGM_LOCK_VOID(pGVM);
-    PPGMPHYSHANDLER         pHandler     = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
-    PPGMPHYSHANDLERTYPEINT  pHandlerType = RT_LIKELY(pHandler) ? PGMPHYSHANDLER_GET_TYPE(pGVM, pHandler) : NULL;
+    PPGMPHYSHANDLER          pHandler     = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
+    PCPGMPHYSHANDLERTYPEINT  pHandlerType = RT_LIKELY(pHandler) ? PGMPHYSHANDLER_GET_TYPE_NO_NULL(pGVM, pHandler) : NULL;
     if (RT_LIKELY(pHandler && pHandlerType->enmKind != PGMPHYSHANDLERKIND_WRITE))
     {
@@ -988 +1179 @@
         else
         {
-            if (pHandlerType->CTX_SUFF(pfnPfHandler))
+            if (pHandlerType->pfnPfHandler)
             {
                 uint64_t const uUser = !pHandlerType->fRing0DevInsIdx ? pHandler->uUser
@@ -995 +1186 @@
                 PGM_UNLOCK(pGVM);
 
-                Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->CTX_SUFF(pfnPfHandler), uErr, GCPhysFault, uUser));
-                rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pGVM, pGVCpu, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
-                                                          GCPhysFault, GCPhysFault, uUser);
+                Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->pfnPfHandler, uErr, GCPhysFault, uUser));
+                rc = pHandlerType->pfnPfHandler(pGVM, pGVCpu, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
+                                                GCPhysFault, GCPhysFault, uUser);
 
 #ifdef VBOX_WITH_STATISTICS

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

@@ -32 +32 @@
 #include <iprt/mem.h>
 #include <iprt/memobj.h>
+
+
+/**
+ * Called by PGMR0InitVM to complete the page pool setup for ring-0.
+ *
+ * @returns VBox status code.
+ * @param   pGVM    Pointer to the global VM structure.
+ */
+int pgmR0PoolInitVM(PGVM pGVM)
+{
+    PPGMPOOL pPool = pGVM->pgm.s.pPoolR0;
+    AssertPtrReturn(pPool, VERR_PGM_POOL_IPE);
+
+    int rc = PGMR0HandlerPhysicalTypeSetUpContext(pGVM, PGMPHYSHANDLERKIND_WRITE, PGMPHYSHANDLER_F_KEEP_PGM_LOCK,
+                                                  pgmPoolAccessHandler, pgmRZPoolAccessPfHandler,
+                                                  "Guest Paging Access Handler", pPool->hAccessHandlerType);
+    AssertLogRelRCReturn(rc, rc);
+
+    return VINF_SUCCESS;
+}
 
 

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

@@ -23 +23 @@
 #include <VBox/vmm/vmm.h>
 #include <VBox/sup.h>
+#include <VBox/vmm/iem.h>
 #include <VBox/vmm/iom.h>
 #include <VBox/vmm/trpm.h>
@@ -55 +56 @@
 #include <iprt/assert.h>
 #include <iprt/crc.h>
+#include <iprt/initterm.h>
 #include <iprt/mem.h>
 #include <iprt/memobj.h>
@@ -282 +284 @@
 
     vmmTermFormatTypes();
+    RTTermRunCallbacks(RTTERMREASON_UNLOAD, 0);
 
     LogFlow(("ModuleTerm: returns\n"));
@@ -436 +439 @@
     {
         /*
-         * Init HM, CPUM and PGM (Darwin only).
+         * Init HM, CPUM and PGM.
          */
         rc = HMR0InitVM(pGVM);
@@ -450 +453 @@
                     if (RT_SUCCESS(rc))
                     {
-#ifdef VBOX_WITH_PCI_PASSTHROUGH
-                        rc = PciRawR0InitVM(pGVM);
-#endif
+                        rc = IEMR0InitVM(pGVM);
                         if (RT_SUCCESS(rc))
                         {
-                            rc = GIMR0InitVM(pGVM);
+                            rc = IOMR0InitVM(pGVM);
                             if (RT_SUCCESS(rc))
                             {
-                                GVMMR0DoneInitVM(pGVM);
-
-                                /*
-                                 * Collect a bit of info for the VM release log.
-                                 */
-                                pGVM->vmm.s.fIsPreemptPendingApiTrusty = RTThreadPreemptIsPendingTrusty();
-                                pGVM->vmm.s.fIsPreemptPossible         = RTThreadPreemptIsPossible();;
-                                return rc;
-
-                                /* bail out*/
-                                //GIMR0TermVM(pGVM);
+#ifdef VBOX_WITH_PCI_PASSTHROUGH
+                                rc = PciRawR0InitVM(pGVM);
+#endif
+                                if (RT_SUCCESS(rc))
+                                {
+                                    rc = GIMR0InitVM(pGVM);
+                                    if (RT_SUCCESS(rc))
+                                    {
+                                        GVMMR0DoneInitVM(pGVM);
+                                        PGMR0DoneInitVM(pGVM);
+
+                                        /*
+                                         * Collect a bit of info for the VM release log.
+                                         */
+                                        pGVM->vmm.s.fIsPreemptPendingApiTrusty = RTThreadPreemptIsPendingTrusty();
+                                        pGVM->vmm.s.fIsPreemptPossible         = RTThreadPreemptIsPossible();;
+                                        return rc;
+
+                                        /* bail out*/
+                                        //GIMR0TermVM(pGVM);
+                                    }
+#ifdef VBOX_WITH_PCI_PASSTHROUGH
+                                    PciRawR0TermVM(pGVM);
+#endif
+                                }
                             }
-#ifdef VBOX_WITH_PCI_PASSTHROUGH
-                            PciRawR0TermVM(pGVM);
-#endif
                         }
                     }

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

@@ -171 +171 @@
     if (pVM->cpum.ro.GuestFeatures.fVmx)
     {
-        PVMCPU pVCpu0 = pVM->apCpusR3[0];
         int rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_ALL, 0 /*fFlags*/,
                                                   iemVmxApicAccessPageHandler,
-                                                  NULL /* pszModR0 */,
-                                                  "iemVmxApicAccessPageHandler", NULL /* pszPfHandlerR0 */,
-                                                  NULL /* pszModRC */,
-                                                  NULL /* pszHandlerRC */, NULL /* pszPfHandlerRC */,
-                                                  "VMX APIC-access page", &pVCpu0->iem.s.hVmxApicAccessPage);
+                                                  "VMX APIC-access page", &pVM->iem.s.hVmxApicAccessPage);
         AssertLogRelRCReturn(rc, rc);
     }

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

@@ -160 +160 @@
      */
     rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_MMIO, 0 /*fFlags*/,
-                                          iomMmioHandlerNew,
-                                          NULL, "iomMmioHandlerNew", "iomMmioPfHandlerNew",
-                                          NULL, "iomMmioHandlerNew", "iomMmioPfHandlerNew",
-                                          "MMIO New", &pVM->iom.s.hNewMmioHandlerType);
+                                          iomMmioHandlerNew, "MMIO", &pVM->iom.s.hNewMmioHandlerType);
     AssertRCReturn(rc, rc);
 

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

@@ -860 +860 @@
 /** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalTypeRegister} */
 static DECLCALLBACK(int) pdmR3DevHlp_PGMHandlerPhysicalTypeRegister(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
-                                                                    R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
-                                                                    const char *pszHandlerR0, const char *pszPfHandlerR0,
-                                                                    const char *pszHandlerRC, const char *pszPfHandlerRC,
-                                                                    const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
+                                                                    PFNPGMPHYSHANDLER pfnHandlerR3, const char *pszDesc,
+                                                                    PPGMPHYSHANDLERTYPE phType)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
     PVM  pVM = pDevIns->Internal.s.pVMR3;
-    LogFlow(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: enmKind=%d pfnHandlerR3=%p pszHandlerR0=%p:{%s} pszPfHandlerR0=%p:{%s} pszHandlerRC=%p:{%s} pszPfHandlerRC=%p:{%s} pszDesc=%p:{%s} phType=%p\n",
-             pDevIns->pReg->szName, pDevIns->iInstance, enmKind, pfnHandlerR3,
-             pszHandlerR0, pszHandlerR0, pszPfHandlerR0, pszPfHandlerR0,
-             pszHandlerRC, pszHandlerRC, pszPfHandlerRC, pszPfHandlerRC,
-             pszDesc, pszDesc, phType));
+    LogFlow(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: enmKind=%d pfnHandlerR3=%p pszDesc=%p:{%s} phType=%p\n",
+             pDevIns->pReg->szName, pDevIns->iInstance, enmKind, pfnHandlerR3, pszDesc, pszDesc, phType));
 
     int rc = PGMR3HandlerPhysicalTypeRegister(pVM, enmKind,
                                               pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_R0_ENABLED
                                               ? PGMPHYSHANDLER_F_R0_DEVINS_IDX : 0,
-                                              pfnHandlerR3,
-                                              pDevIns->pReg->pszR0Mod, pszHandlerR0, pszPfHandlerR0,
-                                              pDevIns->pReg->pszRCMod, pszHandlerRC, pszPfHandlerRC,
-                                              pszDesc, phType);
+                                              pfnHandlerR3, pszDesc, phType);
 
     Log(("pdmR3DevHlp_PGMHandlerPhysicalTypeRegister: caller='%s'/%d: returns %Rrc\n",
@@ -5764 +5756 @@
 /** @interface_method_impl{PDMDEVHLPR3,pfnPGMHandlerPhysicalTypeRegister} */
 static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_PGMHandlerPhysicalTypeRegister(PPDMDEVINS pDevIns, PGMPHYSHANDLERKIND enmKind,
-                                                                              R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
-                                                                              const char *pszHandlerR0, const char *pszPfHandlerR0,
-                                                                              const char *pszHandlerRC, const char *pszPfHandlerRC,
+                                                                              PFNPGMPHYSHANDLER pfnHandler,
                                                                               const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    RT_NOREF(enmKind, pfnHandlerR3, pszHandlerR0, pszPfHandlerR0, pszHandlerRC, pszPfHandlerRC, pszDesc, phType);
+    RT_NOREF(pDevIns, enmKind, pfnHandler, pszDesc);
     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
                             pDevIns->pReg->szName, pDevIns->iInstance));
+    *phType = NIL_PGMPHYSHANDLERTYPE;
     return VERR_ACCESS_DENIED;
 }

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

@@ -618 +618 @@
 #include <iprt/assert.h>
 #include <iprt/env.h>
+#include <iprt/file.h>
 #include <iprt/mem.h>
-#include <iprt/file.h>
+#include <iprt/rand.h>
 #include <iprt/string.h>
 #include <iprt/thread.h>
@@ -794 +795 @@
         pVM->pgm.s.aLargeHandyPage[i].idPage        = NIL_GMM_PAGEID;
         pVM->pgm.s.aLargeHandyPage[i].idSharedPage  = NIL_GMM_PAGEID;
+    }
+
+    AssertReleaseReturn(pVM->pgm.s.cPhysHandlerTypes == 0, VERR_WRONG_ORDER);
+    for (size_t i = 0; i < RT_ELEMENTS(pVM->pgm.s.aPhysHandlerTypes); i++)
+    {
+        if (fDriverless)
+            pVM->pgm.s.aPhysHandlerTypes[i].hType  = i | (RTRandU64() & ~(uint64_t)PGMPHYSHANDLERTYPE_IDX_MASK);
+        pVM->pgm.s.aPhysHandlerTypes[i].enmKind    = PGMPHYSHANDLERKIND_INVALID;
+        pVM->pgm.s.aPhysHandlerTypes[i].pfnHandler = pgmR3HandlerPhysicalHandlerInvalid;
     }
 
@@ -954 +964 @@
     if (RT_SUCCESS(rc))
         /** @todo why isn't pgmPhysRomWriteHandler registered for ring-0?   */
-        rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, 0 /*fFlags*/,
-                                              pgmPhysRomWriteHandler,
-                                              NULL, NULL, "pgmPhysRomWritePfHandler",
-                                              NULL, NULL, "pgmPhysRomWritePfHandler",
-                                              "ROM write protection",
-                                              &pVM->pgm.s.hRomPhysHandlerType);
+        rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, 0 /*fFlags*/, pgmPhysRomWriteHandler,
+                                              "ROM write protection", &pVM->pgm.s.hRomPhysHandlerType);
 
     /*
@@ -966 +972 @@
     if (RT_SUCCESS(rc))
         rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, PGMPHYSHANDLER_F_KEEP_PGM_LOCK,
-                                              pgmPhysMmio2WriteHandler,
-                                              NULL, "pgmPhysMmio2WriteHandler", "pgmPhysMmio2WritePfHandler",
-                                              NULL, "pgmPhysMmio2WriteHandler", "pgmPhysMmio2WritePfHandler",
-                                              "MMIO2 dirty page tracing",
+                                              pgmPhysMmio2WriteHandler, "MMIO2 dirty page tracing",
                                               &pVM->pgm.s.hMmio2DirtyPhysHandlerType);
 

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

@@ -58 +58 @@
 
 
-
-/**
- * Register a physical page access handler type, extended version.
+/**
+ * @callback_method_impl{FNPGMPHYSHANDLER,
+ * Invalid callback entry triggering guru mediation}
+ */
+DECLCALLBACK(VBOXSTRICTRC) pgmR3HandlerPhysicalHandlerInvalid(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, void *pvPhys,
+                                                              void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType,
+                                                              PGMACCESSORIGIN enmOrigin, uint64_t uUser)
+{
+    RT_NOREF(pVM, pVCpu, GCPhys, pvPhys, pvBuf, cbBuf, enmAccessType, enmOrigin, uUser);
+    LogRel(("GCPhys=%RGp cbBuf=%#zx enmAccessType=%d uUser=%#RX64\n", GCPhys, cbBuf, enmAccessType, uUser));
+    return VERR_PGM_HANDLER_IPE_1;
+}
+
+
+/**
+ * Register a physical page access handler type.
  *
  * @returns VBox status code.
- * @param   pVM             The cross context VM structure.
- * @param   enmKind         The kind of access handler.
- * @param   fFlags          PGMPHYSHANDLER_F_XXX
- * @param   pfnHandlerR3    Pointer to the ring-3 handler callback.
- * @param   pfnHandlerR0    Pointer to the ring-0 handler callback.
- * @param   pfnPfHandlerR0  Pointer to the ring-0 \#PF handler callback.
- *                          callback.
- * @param   pszDesc         The type description.
- * @param   phType          Where to return the type handle (cross context
- *                          safe).
- */
-VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegisterEx(PVM pVM, PGMPHYSHANDLERKIND enmKind, uint32_t fFlags,
-                                                       PFNPGMPHYSHANDLER pfnHandlerR3,
-                                                       R0PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR0,
-                                                       R0PTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerR0,
-                                                       const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
-{
-    AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
-    AssertReturn(pfnHandlerR0   != NIL_RTR0PTR || SUPR3IsDriverless(), VERR_INVALID_POINTER);
-    AssertReturn(pfnPfHandlerR0 != NIL_RTR0PTR || SUPR3IsDriverless(), VERR_INVALID_POINTER);
+ * @param   pVM         The cross context VM structure.
+ * @param   enmKind     The kind of access handler.
+ * @param   fFlags      PGMPHYSHANDLER_F_XXX
+ * @param   pfnHandler  Pointer to the ring-3 handler callback.
+ * @param   pszDesc     The type description.
+ * @param   phType      Where to return the type handle (cross context safe).
+ */
+VMMR3_INT_DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, uint32_t fFlags,
+                                                     PFNPGMPHYSHANDLER pfnHandler, const char *pszDesc,
+                                                     PPGMPHYSHANDLERTYPE phType)
+{
+    /*
+     * Validate input.
+     */
+    AssertPtrReturn(phType, VERR_INVALID_POINTER);
+    *phType = NIL_PGMPHYSHANDLERTYPE;
+
+    AssertPtrReturn(pfnHandler, VERR_INVALID_POINTER);
     AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
     AssertReturn(   enmKind == PGMPHYSHANDLERKIND_WRITE
@@ -90 +101 @@
     AssertMsgReturn(!(fFlags & ~PGMPHYSHANDLER_F_VALID_MASK), ("%#x\n", fFlags), VERR_INVALID_FLAGS);
 
-    PPGMPHYSHANDLERTYPEINT pType;
-    int rc = MMHyperAlloc(pVM, sizeof(*pType), 0, MM_TAG_PGM_HANDLER_TYPES, (void **)&pType);
-    if (RT_SUCCESS(rc))
-    {
-        pType->u32Magic         = PGMPHYSHANDLERTYPEINT_MAGIC;
-        pType->cRefs            = 1;
-        pType->enmKind          = enmKind;
-        pType->uState           = enmKind == PGMPHYSHANDLERKIND_WRITE
-                                ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
-        pType->fKeepPgmLock     = RT_BOOL(fFlags & PGMPHYSHANDLER_F_KEEP_PGM_LOCK);
-        pType->fRing0DevInsIdx  = RT_BOOL(fFlags & PGMPHYSHANDLER_F_R0_DEVINS_IDX);
-        pType->pfnHandlerR3     = pfnHandlerR3;
-        pType->pfnHandlerR0     = pfnHandlerR0;
-        pType->pfnPfHandlerR0   = pfnPfHandlerR0;
-        pType->pszDesc          = pszDesc;
-
-        PGM_LOCK_VOID(pVM);
-        RTListOff32Append(&pVM->pgm.s.CTX_SUFF(pTrees)->HeadPhysHandlerTypes, &pType->ListNode);
-        PGM_UNLOCK(pVM);
-
-        *phType = MMHyperHeapPtrToOffset(pVM, pType);
-        LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pszDesc=%s\n",
-                 pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pszDesc));
-        return VINF_SUCCESS;
-    }
-    *phType = NIL_PGMPHYSHANDLERTYPE;
-    return rc;
-}
-
-
-/**
- * Register a physical page access handler type.
- *
- * @returns VBox status code.
- * @param   pVM             The cross context VM structure.
- * @param   enmKind         The kind of access handler.
- * @param   fFlags          PGMPHYSHANDLER_F_XXX
- * @param   pfnHandlerR3    Pointer to the ring-3 handler callback.
- * @param   pszModR0        The name of the ring-0 module, NULL is an alias for
- *                          the main ring-0 module.
- * @param   pszHandlerR0    The name of the ring-0 handler, NULL if the ring-3
- *                          handler should be called.
- * @param   pszPfHandlerR0  The name of the ring-0 \#PF handler, NULL if the
- *                          ring-3 handler should be called.
- * @param   pszModRC        The name of the raw-mode context module, NULL is an
- *                          alias for the main RC module.
- * @param   pszHandlerRC    The name of the raw-mode context handler, NULL if
- *                          the ring-3 handler should be called.
- * @param   pszPfHandlerRC  The name of the raw-mode context \#PF handler, NULL
- *                          if the ring-3 handler should be called.
- * @param   pszDesc         The type description.
- * @param   phType          Where to return the type handle (cross context
- *                          safe).
- */
-VMMR3DECL(int) PGMR3HandlerPhysicalTypeRegister(PVM pVM, PGMPHYSHANDLERKIND enmKind, uint32_t fFlags,
-                                                R3PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR3,
-                                                const char *pszModR0, const char *pszHandlerR0, const char *pszPfHandlerR0,
-                                                const char *pszModRC, const char *pszHandlerRC, const char *pszPfHandlerRC,
-                                                const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
-{
-    LogFlow(("PGMR3HandlerPhysicalTypeRegister: enmKind=%d pfnHandlerR3=%RHv pszModR0=%s pszHandlerR0=%s pszPfHandlerR0=%s pszModRC=%s pszHandlerRC=%s pszPfHandlerRC=%s pszDesc=%s\n",
-             enmKind, pfnHandlerR3, pszModR0, pszHandlerR0, pszPfHandlerR0, pszModRC, pszHandlerRC, pszPfHandlerRC, pszDesc));
-
-    /*
-     * Validate input.
-     */
-    AssertPtrReturn(pfnHandlerR3, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszModR0, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszHandlerR0, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszPfHandlerR0, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszModRC, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszHandlerRC, VERR_INVALID_POINTER);
-    AssertPtrNullReturn(pszPfHandlerRC, VERR_INVALID_POINTER);
-
-    /*
-     * Resolve the R0 handlers.
-     */
-    R0PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR0 = NIL_RTR0PTR;
-    R0PTRTYPE(PFNPGMR0PHYSPFHANDLER) pfnPfHandlerR0 = NIL_RTR0PTR;
-    int rc = VINF_SUCCESS;
-    if (!SUPR3IsDriverless())
-    {
-        rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszHandlerR0 ? pszModR0 : NULL, NULL /*pszSearchPath*/,
-                                         pszHandlerR0 ? pszHandlerR0 : "pgmPhysHandlerRedirectToHC", &pfnHandlerR0);
-        if (RT_SUCCESS(rc))
-        {
-            rc = PDMR3LdrGetSymbolR0Lazy(pVM, pszPfHandlerR0 ? pszModR0 : NULL, NULL /*pszSearchPath*/,
-                                         pszPfHandlerR0 ? pszPfHandlerR0 : "pgmPhysPfHandlerRedirectToHC", &pfnPfHandlerR0);
-            AssertMsgRC(rc, ("Failed to resolve %s.%s, rc=%Rrc.\n", pszPfHandlerR0 ? pszModR0 : VMMR0_MAIN_MODULE_NAME,
-                             pszPfHandlerR0 ? pszPfHandlerR0 : "pgmPhysHandlerRedirectToHC", rc));
-        }
-        else
-            AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszHandlerR0 ? pszModR0 : VMMR0_MAIN_MODULE_NAME,
-                             pszHandlerR0 ? pszHandlerR0 : "pgmPhysHandlerRedirectToHC", rc));
-    }
-    if (RT_SUCCESS(rc))
-    {
-        /*
-         * Resolve the GC handler.
-         */
-        RTRCPTR pfnHandlerRC   = NIL_RTRCPTR;
-        RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR;
-        if (VM_IS_RAW_MODE_ENABLED(pVM))
-        {
-            rc = PDMR3LdrGetSymbolRCLazy(pVM, pszHandlerRC ? pszModRC : NULL, NULL /*pszSearchPath*/,
-                                         pszHandlerRC ? pszHandlerRC : "pgmPhysHandlerRedirectToHC", &pfnHandlerRC);
-            if (RT_SUCCESS(rc))
-            {
-                rc = PDMR3LdrGetSymbolRCLazy(pVM, pszPfHandlerRC ? pszModRC : NULL, NULL /*pszSearchPath*/,
-                                             pszPfHandlerRC ? pszPfHandlerRC : "pgmPhysPfHandlerRedirectToHC", &pfnPfHandlerRC);
-                AssertMsgRC(rc, ("Failed to resolve %s.%s, rc=%Rrc.\n", pszPfHandlerRC ? pszModRC : VMMRC_MAIN_MODULE_NAME,
-                                 pszPfHandlerRC ? pszPfHandlerRC : "pgmPhysPfHandlerRedirectToHC", rc));
-            }
-            else
-                AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszHandlerRC ? pszModRC : VMMRC_MAIN_MODULE_NAME,
-                                 pszHandlerRC ? pszHandlerRC : "pgmPhysHandlerRedirectToHC", rc));
-
-        }
-        if (RT_SUCCESS(rc))
-            return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, fFlags, pfnHandlerR3,
-                                                      pfnHandlerR0, pfnPfHandlerR0, pszDesc, phType);
-    }
-
-    return rc;
+    VM_ASSERT_EMT0_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
+    VM_ASSERT_STATE_RETURN(pVM, VMSTATE_CREATING, VERR_VM_INVALID_VM_STATE);
+
+    /*
+     * Do the allocating.
+     */
+    PGMPHYSHANDLERTYPE hType = pVM->pgm.s.cPhysHandlerTypes;
+    AssertLogRelReturn(hType < RT_ELEMENTS(pVM->pgm.s.aPhysHandlerTypes), VERR_OUT_OF_RESOURCES);
+    PPGMPHYSHANDLERTYPEINTR3 const pType = &pVM->pgm.s.aPhysHandlerTypes[hType];
+    AssertReturn(pType->enmKind == PGMPHYSHANDLERKIND_INVALID, VERR_PGM_HANDLER_IPE_1);
+    pVM->pgm.s.cPhysHandlerTypes++;
+
+    pType->enmKind          = enmKind;
+    pType->uState           = enmKind == PGMPHYSHANDLERKIND_WRITE
+                            ? PGM_PAGE_HNDL_PHYS_STATE_WRITE : PGM_PAGE_HNDL_PHYS_STATE_ALL;
+    pType->fKeepPgmLock     = RT_BOOL(fFlags & PGMPHYSHANDLER_F_KEEP_PGM_LOCK);
+    pType->fRing0DevInsIdx  = RT_BOOL(fFlags & PGMPHYSHANDLER_F_R0_DEVINS_IDX);
+    pType->pfnHandler       = pfnHandler;
+    pType->pszDesc          = pszDesc;
+
+    *phType = pType->hType;
+    LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: hType=%#x: enmKind=%d fFlags=%#x pfnHandler=%p pszDesc=%s\n",
+             hType, enmKind, fFlags, pfnHandler, pszDesc));
+    return VINF_SUCCESS;
 }
 
@@ -294 +205 @@
     PVM                     pVM       = (PVM)pvUser;
     PPGMPHYSHANDLER         pCur      = (PPGMPHYSHANDLER)pNode;
-    PPGMPHYSHANDLERTYPEINT  pCurType  = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
+    PCPGMPHYSHANDLERTYPEINT pCurType  = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pVM, pCur);
     unsigned                uState    = pCurType->uState;
     PPGMRAMRANGE            pRamHint  = NULL;
@@ -365 +276 @@
     pHlp->pfnPrintf(pHlp,
                     "Physical handlers: (PhysHandlers=%d (%#x))\n"
-                    "%*s %*s %*s %*s uUser              Type     Description\n",
+                    "%*s %*s %*s uUser             Type     Description\n",
                     pVM->pgm.s.pTreesR3->PhysHandlers, pVM->pgm.s.pTreesR3->PhysHandlers,
                     - (int)sizeof(RTGCPHYS) * 2,     "From",
                     - (int)sizeof(RTGCPHYS) * 2 - 3, "- To (incl)",
-                    - (int)sizeof(RTHCPTR)  * 2 - 1, "HandlerR3",
-                    - (int)sizeof(RTHCPTR)  * 2 - 1, "HandlerR0");
+                    - (int)sizeof(RTHCPTR)  * 2 - 1, "Handler (R3)");
     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers, true, pgmR3InfoHandlersPhysicalOne, &Args);
 }
@@ -384 +294 @@
 static DECLCALLBACK(int) pgmR3InfoHandlersPhysicalOne(PAVLROGCPHYSNODECORE pNode, void *pvUser)
 {
-    PPGMPHYSHANDLER        pCur     = (PPGMPHYSHANDLER)pNode;
-    PPGMHANDLERINFOARG     pArgs    = (PPGMHANDLERINFOARG)pvUser;
-    PCDBGFINFOHLP          pHlp     = pArgs->pHlp;
-    PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pArgs->pVM, pCur);
+    PPGMPHYSHANDLER         pCur     = (PPGMPHYSHANDLER)pNode;
+    PPGMHANDLERINFOARG      pArgs    = (PPGMHANDLERINFOARG)pvUser;
+    PCDBGFINFOHLP           pHlp     = pArgs->pHlp;
+    PCPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE_NO_NULL(pArgs->pVM, pCur);
     const char *pszType;
     switch (pCurType->enmKind)
@@ -394 +304 @@
         case PGMPHYSHANDLERKIND_WRITE:  pszType = "Write  "; break;
         case PGMPHYSHANDLERKIND_ALL:    pszType = "All    "; break;
-        default:                        pszType = "????"; break;
+        default:                        pszType = "???????"; break;
     }
+
+    char   szFlags[80];
+    size_t cchFlags = 0;
+    if (pCurType->fKeepPgmLock)
+        cchFlags = RTStrPrintf(szFlags, sizeof(szFlags), "(keep-pgm-lock");
+    if (pCurType->fRing0DevInsIdx)
+        cchFlags += RTStrPrintf(&szFlags[cchFlags], sizeof(szFlags) - cchFlags, cchFlags ? ", keep-pgm-lock" : "(keep-pgm-lock");
+    if (pCurType->fRing0Enabled)
+        cchFlags += RTStrPrintf(&szFlags[cchFlags], sizeof(szFlags) - cchFlags, cchFlags ? ", r0-enabled)" : "(r0-enabled)");
+    else
+        cchFlags += RTStrPrintf(&szFlags[cchFlags], sizeof(szFlags) - cchFlags, cchFlags ? ", r3-only)" : "(r3-only)");
+
     pHlp->pfnPrintf(pHlp,
-                    "%RGp - %RGp  %RHv  %RHv  %#018RX64  %s  %s\n",
-                    pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCurType->pfnPfHandlerR0, pCur->uUser,
-                    pszType, pCur->pszDesc);
+                    "%RGp - %RGp  %p  %016RX64  %s  %s  %s\n",
+                    pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandler, pCur->uUser, pszType, pCur->pszDesc, szFlags);
 #ifdef VBOX_WITH_STATISTICS
     if (pArgs->fStats)

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

@@ -2271 +2271 @@
     AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
     AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
-    Assert(((PPGMPHYSHANDLERTYPEINT)MMHyperHeapOffsetToPtr(pVM, hType))->enmKind == PGMPHYSHANDLERKIND_MMIO);
+#ifdef VBOX_STRICT
+    PCPGMPHYSHANDLERTYPEINT pType = pgmHandlerPhysicalTypeHandleToPtr(pVM, hType);
+    Assert(pType);
+    Assert(pType->enmKind == PGMPHYSHANDLERKIND_MMIO);
+#endif
 
     int rc = PGM_LOCK(pVM);

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

@@ -284 +284 @@
     pPool->hAccessHandlerType = NIL_PGMPHYSHANDLERTYPE;
     rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_WRITE, PGMPHYSHANDLER_F_KEEP_PGM_LOCK,
-                                          pgmPoolAccessHandler,
-                                          NULL, "pgmPoolAccessHandler", "pgmRZPoolAccessPfHandler",
-                                          NULL, "pgmPoolAccessHandler", "pgmRZPoolAccessPfHandler",
-                                          "Guest Paging Access Handler",
-                                          &pPool->hAccessHandlerType);
+                                          pgmPoolAccessHandler, "Guest Paging Access Handler", &pPool->hAccessHandlerType);
     AssertLogRelRCReturn(rc, rc);
 

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

@@ -51 +51 @@
     /** Physical access handler type for semi-read-only MMIO2 memory. Lazy creation. */
     PGMPHYSHANDLERTYPE              hSemiReadOnlyMmio2Handler;
-    /** Alignment padding. */
-    uint32_t                        u32Padding;
 
     /** Pointer to the GIM device - R3 ptr. */

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

@@ -552 +552 @@
     /** The error code for the current exception / interrupt. */
     uint32_t                uCurXcptErr;
-    /** The VMX APIC-access page handler type. */
-    PGMPHYSHANDLERTYPE      hVmxApicAccessPage;
 
     /** @name Statistics
@@ -725 +723 @@
 # define IEM_GET_INSTR_LEN(a_pVCpu)     ((a_pVCpu)->iem.s.offOpcode)
 #endif
+
+
+/**
+ * Shared per-VM IEM data.
+ */
+typedef struct IEM
+{
+    /** The VMX APIC-access page handler type. */
+    PGMPHYSHANDLERTYPE      hVmxApicAccessPage;
+} IEM;
+
 
 

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

@@ -571 +571 @@
 
 #ifndef IN_RING3
-DECLEXPORT(FNPGMRZPHYSPFHANDLER)    iomMmioPfHandlerNew;
-#endif
-PGM_ALL_CB2_PROTO(FNPGMPHYSHANDLER) iomMmioHandlerNew;
+DECLCALLBACK(FNPGMRZPHYSPFHANDLER)  iomMmioPfHandlerNew;
+#endif
+DECLCALLBACK(FNPGMPHYSHANDLER)      iomMmioHandlerNew;
 
 /* IOM locking helpers. */

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

@@ -992 +992 @@
 
 /**
+ * Converts a handle to a pointer.
+ *
+ * @returns Pointer on success, NULL on failure (asserted).
+ * @param   pVM     The cross context VM structure.
+ * @param   hType   Physical access handler type handle.
+ */
+DECLINLINE(PCPGMPHYSHANDLERTYPEINT) pgmHandlerPhysicalTypeHandleToPtr(PVMCC pVM, PGMPHYSHANDLERTYPE hType)
+{
+#ifdef IN_RING0
+    PPGMPHYSHANDLERTYPEINT pType = &pVM->pgmr0.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+#elif defined(IN_RING3)
+    PPGMPHYSHANDLERTYPEINT pType = &pVM->pgm.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+#else
+# error "Invalid context"
+#endif
+    AssertReturn(pType->hType == hType, NULL);
+    return pType;
+}
+
+
+/**
+ * Converts a handle to a pointer, never returns NULL.
+ *
+ * @returns Pointer on success, dummy on failure (asserted).
+ * @param   pVM     The cross context VM structure.
+ * @param   hType   Physical access handler type handle.
+ */
+DECLINLINE(PCPGMPHYSHANDLERTYPEINT) pgmHandlerPhysicalTypeHandleToPtr2(PVMCC pVM, PGMPHYSHANDLERTYPE hType)
+{
+#ifdef IN_RING0
+    PPGMPHYSHANDLERTYPEINT pType = &pVM->pgmr0.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+#elif defined(IN_RING3)
+    PPGMPHYSHANDLERTYPEINT pType = &pVM->pgm.s.aPhysHandlerTypes[hType & PGMPHYSHANDLERTYPE_IDX_MASK];
+#else
+# error "Invalid context"
+#endif
+    AssertReturn(pType->hType == hType, &g_pgmHandlerPhysicalDummyType);
+    return pType;
+}
+
+
+/**
  * Internal worker for finding a 'in-use' shadow page give by it's physical address.
  *

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

@@ -483 +483 @@
 
 
-/**
- * Physical page access handler type registration.
- */
-typedef struct PGMPHYSHANDLERTYPEINT
-{
-    /** Number of references.   */
-    uint32_t volatile                   cRefs;
-    /** Magic number (PGMPHYSHANDLERTYPEINT_MAGIC). */
-    uint32_t                            u32Magic;
-    /** Link of handler types anchored in PGMTREES::HeadPhysHandlerTypes.   */
-    RTLISTOFF32NODE                     ListNode;
+/** The physical access handler type handle count (power of two). */
+#define PGMPHYSHANDLERTYPE_COUNT        0x20
+/** Mask for getting the array index from an access handler type handle.
+ * The other handle bits are random and non-zero to avoid mixups due to zero
+ * initialized fields. */
+#define PGMPHYSHANDLERTYPE_IDX_MASK     0x1f
+
+/**
+ * Physical page access handler type registration, ring-0 part.
+ */
+typedef struct PGMPHYSHANDLERTYPEINTR0
+{
+    /** The handle value for verfication.  */
+    PGMPHYSHANDLERTYPE                  hType;
     /** The kind of accesses we're handling. */
     PGMPHYSHANDLERKIND                  enmKind;
@@ -506 +509 @@
     bool                                fRing0DevInsIdx;
     bool                                afPadding[1];
-    /** Pointer to R3 callback function. */
-    R3PTRTYPE(PFNPGMPHYSHANDLER)        pfnHandlerR3;
-    /** Pointer to R0 callback function. */
-    R0PTRTYPE(PFNPGMPHYSHANDLER)        pfnHandlerR0;
-    /** Pointer to R0 callback function for \#PFs. */
-    R0PTRTYPE(PFNPGMRZPHYSPFHANDLER)    pfnPfHandlerR0;
+    /** Pointer to the ring-0 callback function. */
+    R0PTRTYPE(PFNPGMPHYSHANDLER)        pfnHandler;
+    /** Pointer to the ring-9 callback function for \#PFs. */
+    R0PTRTYPE(PFNPGMRZPHYSPFHANDLER)    pfnPfHandler;
+    /** Description / Name. For easing debugging. */
+    R0PTRTYPE(const char *)             pszDesc;
+} PGMPHYSHANDLERTYPEINTR0;
+/** Pointer to a physical access handler type registration. */
+typedef PGMPHYSHANDLERTYPEINTR0 *PPGMPHYSHANDLERTYPEINTR0;
+
+/**
+ * Physical page access handler type registration, shared/ring-3 part.
+ */
+typedef struct PGMPHYSHANDLERTYPEINTR3
+{
+    /** The handle value for verfication.  */
+    PGMPHYSHANDLERTYPE                  hType;
+    /** The kind of accesses we're handling. */
+    PGMPHYSHANDLERKIND                  enmKind;
+    /** The PGM_PAGE_HNDL_PHYS_STATE_XXX value corresponding to enmKind. */
+    uint8_t                             uState;
+    /** Whether to keep the PGM lock when calling the handler.
+     * @sa PGMPHYSHANDLER_F_KEEP_PGM_LOCK  */
+    bool                                fKeepPgmLock;
+    /** Set if this is registered by a device instance and uUser should be
+     * translated from a device instance ID to a pointer.
+     * @sa PGMPHYSHANDLER_F_R0_DEVINS_IDX  */
+    bool                                fRing0DevInsIdx;
+    /** Set by ring-0 if the handler is ring-0 enabled (for debug). */
+    bool                                fRing0Enabled : 1;
+    /** Pointer to the ring-3 callback function. */
+    R3PTRTYPE(PFNPGMPHYSHANDLER)        pfnHandler;
     /** Description / Name. For easing debugging. */
     R3PTRTYPE(const char *)             pszDesc;
-} PGMPHYSHANDLERTYPEINT;
+} PGMPHYSHANDLERTYPEINTR3;
 /** Pointer to a physical access handler type registration. */
-typedef PGMPHYSHANDLERTYPEINT *PPGMPHYSHANDLERTYPEINT;
-/** Magic value for the physical handler callbacks (Robert A. Heinlein). */
-#define PGMPHYSHANDLERTYPEINT_MAGIC        UINT32_C(0x19070707)
-/** Magic value for the physical handler callbacks. */
-#define PGMPHYSHANDLERTYPEINT_MAGIC_DEAD   UINT32_C(0x19880508)
-
-/**
- * Converts a handle to a pointer.
- * @returns PPGMPHYSHANDLERTYPEINT
- * @param   a_pVM           The cross context VM structure.
- * @param   a_hType         Physical access handler type handle.
- */
-#define PGMPHYSHANDLERTYPEINT_FROM_HANDLE(a_pVM, a_hType) ((PPGMPHYSHANDLERTYPEINT)MMHyperHeapOffsetToPtr(a_pVM, a_hType))
+typedef PGMPHYSHANDLERTYPEINTR3 *PPGMPHYSHANDLERTYPEINTR3;
+
+/** Pointer to a physical access handler type record for the current context. */
+typedef CTX_SUFF(PPGMPHYSHANDLERTYPEINT) PPGMPHYSHANDLERTYPEINT;
+/** Pointer to a const physical access handler type record for the current context. */
+typedef CTX_SUFF(PGMPHYSHANDLERTYPEINT) const *PCPGMPHYSHANDLERTYPEINT;
+/** Dummy physical access handler type record. */
+extern CTX_SUFF(PGMPHYSHANDLERTYPEINT) const g_pgmHandlerPhysicalDummyType;
 
 
@@ -546 +570 @@
     /** Set if we have pages that have temporarily been disabled. */
     uint32_t                            cTmpOffPages;
-    /** Registered handler type handle (heap offset). */
-    PGMPHYSHANDLERTYPE                  hType;
+    uint32_t                            u32Padding;
+    /** Registered handler type handle.
+     * @note Marked volatile to prevent re-reading after validation. */
+    PGMPHYSHANDLERTYPE volatile         hType;
     /** User argument for the handlers. */
     uint64_t                            uUser;
@@ -562 +588 @@
 /**
  * Gets the type record for a physical handler (no reference added).
- * @returns PPGMPHYSHANDLERTYPEINT
+ * @returns PCPGMPHYSHANDLERTYPEINT, can be NULL
  * @param   a_pVM           The cross context VM structure.
  * @param   a_pPhysHandler  Pointer to the physical handler structure
  *                          (PGMPHYSHANDLER).
  */
-#define PGMPHYSHANDLER_GET_TYPE(a_pVM, a_pPhysHandler) PGMPHYSHANDLERTYPEINT_FROM_HANDLE(a_pVM, (a_pPhysHandler)->hType)
+#define PGMPHYSHANDLER_GET_TYPE(a_pVM, a_pPhysHandler) \
+    pgmHandlerPhysicalTypeHandleToPtr(a_pVM, (a_pPhysHandler) ? (a_pPhysHandler)->hType : NIL_PGMPHYSHANDLERTYPE)
+
+/**
+ * Gets the type record for a physical handler, never returns NULL.
+ *
+ * @returns PCPGMPHYSHANDLERTYPEINT, never NULL.
+ * @param   a_pVM           The cross context VM structure.
+ * @param   a_pPhysHandler  Pointer to the physical handler structure
+ *                          (PGMPHYSHANDLER).
+ */
+#define PGMPHYSHANDLER_GET_TYPE_NO_NULL(a_pVM, a_pPhysHandler) \
+    pgmHandlerPhysicalTypeHandleToPtr2(a_pVM, (a_pPhysHandler) ? (a_pPhysHandler)->hType : NIL_PGMPHYSHANDLERTYPE)
 
 
@@ -2034 +2072 @@
     /** The current number of modified pages. */
     uint16_t                    cModifiedPages;
+    /** Alignment padding. */
+    uint32_t                    u32Padding2;
     /** Physical access handler type registration handle. */
     PGMPHYSHANDLERTYPE          hAccessHandlerType;
@@ -2330 +2370 @@
 typedef struct PGMTREES
 {
-    /** List of physical access handler types (offset pointers) of type
-     * PGMPHYSHANDLERTYPEINT.  This is needed for relocations. */
-    RTLISTOFF32ANCHOR               HeadPhysHandlerTypes;
     /** Physical access handlers (AVL range+offsetptr tree). */
     AVLROGCPHYSTREE                 PhysHandlers;
+    uint32_t                        u32PaddingTo8Bytes;
 } PGMTREES;
 /** Pointer to PGM trees. */
@@ -2954 +2992 @@
      *  owner via pgmPhysGCPhys2CCPtrInternalDepr. */
     uint32_t                        cDeprecatedPageLocks;
-    /** Alignment padding. */
-    uint32_t                        au32Alignment2[1+2];
+
+    /** Registered physical access handler types. */
+    uint32_t                        cPhysHandlerTypes;
+    /** Physical access handler types.
+     * Initialized to callback causing guru meditations and invalid enmKind. */
+    PGMPHYSHANDLERTYPEINTR3         aPhysHandlerTypes[PGMPHYSHANDLERTYPE_COUNT];
 
     /** PGM critical section.
@@ -3537 +3579 @@
      * @{ */
     /** Critical section for serializing pool growth. */
-    RTCRITSECT  PoolGrowCritSect;
+    RTCRITSECT                      PoolGrowCritSect;
     /** The memory objects for the pool pages. */
-    RTR0MEMOBJ  ahPoolMemObjs[(PGMPOOL_IDX_LAST + PGMPOOL_CFG_MAX_GROW - 1) / PGMPOOL_CFG_MAX_GROW];
+    RTR0MEMOBJ                      ahPoolMemObjs[(PGMPOOL_IDX_LAST + PGMPOOL_CFG_MAX_GROW - 1) / PGMPOOL_CFG_MAX_GROW];
     /** The ring-3 mapping objects for the pool pages. */
-    RTR0MEMOBJ  ahPoolMapObjs[(PGMPOOL_IDX_LAST + PGMPOOL_CFG_MAX_GROW - 1) / PGMPOOL_CFG_MAX_GROW];
+    RTR0MEMOBJ                      ahPoolMapObjs[(PGMPOOL_IDX_LAST + PGMPOOL_CFG_MAX_GROW - 1) / PGMPOOL_CFG_MAX_GROW];
     /** @} */
+
+    /** Physical access handler types for ring-0.
+     * Initialized to callback causing return to ring-3 and invalid enmKind. */
+    PGMPHYSHANDLERTYPEINTR0         aPhysHandlerTypes[PGMPHYSHANDLERTYPE_COUNT];
 } PGMR0PERVM;
 
@@ -3583 +3629 @@
 DECLHIDDEN(int) pgmHandlerPhysicalResetMmio2WithBitmap(PVMCC pVM, RTGCPHYS GCPhys, void *pvBitmap, uint32_t offBitmap);
 DECLCALLBACK(void) pgmR3InfoHandlers(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
+DECLCALLBACK(FNPGMPHYSHANDLER)      pgmR3HandlerPhysicalHandlerInvalid;
+#ifndef IN_RING3
+DECLCALLBACK(FNPGMPHYSHANDLER)      pgmR0HandlerPhysicalHandlerToRing3;
+DECLCALLBACK(FNPGMRZPHYSPFHANDLER)  pgmR0HandlerPhysicalPfHandlerToRing3;
+#endif
+
 int             pgmR3InitSavedState(PVM pVM, uint64_t cbRam);
 
@@ -3606 +3658 @@
 int             pgmPhysGCPhys2CCPtrInternalReadOnly(PVMCC pVM, PPGMPAGE pPage, RTGCPHYS GCPhys, const void **ppv, PPGMPAGEMAPLOCK pLock);
 void            pgmPhysReleaseInternalPageMappingLock(PVMCC pVM, PPGMPAGEMAPLOCK pLock);
-PGM_ALL_CB2_PROTO(FNPGMPHYSHANDLER) pgmPhysRomWriteHandler;
-PGM_ALL_CB2_PROTO(FNPGMPHYSHANDLER) pgmPhysMmio2WriteHandler;
+DECLCALLBACK(FNPGMPHYSHANDLER)      pgmPhysRomWriteHandler;
+DECLCALLBACK(FNPGMPHYSHANDLER)      pgmPhysMmio2WriteHandler;
 #ifndef IN_RING3
-DECLEXPORT(FNPGMPHYSHANDLER)        pgmPhysHandlerRedirectToHC;
-DECLEXPORT(FNPGMRZPHYSPFHANDLER)    pgmPhysPfHandlerRedirectToHC;
-DECLEXPORT(FNPGMRZPHYSPFHANDLER)    pgmPhysRomWritePfHandler;
-DECLEXPORT(FNPGMRZPHYSPFHANDLER)    pgmPhysMmio2WritePfHandler;
+DECLCALLBACK(FNPGMRZPHYSPFHANDLER)  pgmPhysRomWritePfHandler;
+DECLCALLBACK(FNPGMRZPHYSPFHANDLER)  pgmPhysMmio2WritePfHandler;
 #endif
 int             pgmPhysFreePage(PVM pVM, PGMMFREEPAGESREQ pReq, uint32_t *pcPendingPages, PPGMPAGE pPage, RTGCPHYS GCPhys,
@@ -3648 +3698 @@
 
 #endif /* IN_RING3 */
+#ifdef IN_RING0
+int             pgmR0PoolInitVM(PGVM pGVM);
+#endif
 int             pgmPoolAlloc(PVMCC pVM, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, PGMPOOLACCESS enmAccess, bool fA20Enabled,
                              uint16_t iUser, uint32_t iUserTable, bool fLockPage, PPPGMPOOLPAGE ppPage);