Changeset 13045 in vbox

Timestamp:

Oct 7, 2008 1:04:43 PM (16 years ago)

Author:

vboxsync

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

37500

Message:

#1865: More PGM changes.

Location:

trunk

Files:

• include/VBox/pgm.h (modified) (5 diffs)
• src/VBox/VMM/PGM.cpp (modified) (2 diffs)
• src/VBox/VMM/PGMHandler.cpp (modified) (10 diffs)
• src/VBox/VMM/PGMInternal.h (modified) (2 diffs)
• src/VBox/VMM/VMMAll/PGMAllBth.h (modified) (4 diffs)
• src/VBox/VMM/VMMAll/PGMAllPhys.cpp (modified) (7 diffs)
• src/VBox/VMM/testcase/tstVMStructGC.cpp (modified) (1 diff)

trunk/include/VBox/pgm.h

@@ -183 +183 @@
 
 /**
- * \#PF Handler callback for virtual access handler ranges.
+ * \#PF Handler callback for virtual access handler ranges, RC.
  *
  * Important to realize that a physical page in a range can have aliases, and
@@ -197 +197 @@
  *                      (If it's a EIP range this's the EIP, if not it's pvFault.)
  */
-typedef DECLCALLBACK(int) FNPGMGCVIRTHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+typedef DECLCALLBACK(int) FNPGMRCVIRTHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
 /** Pointer to PGM access callback. */
-typedef FNPGMGCVIRTHANDLER *PFNPGMGCVIRTHANDLER;
-
-/**
- * \#PF Handler callback for virtual access handler ranges.
+typedef FNPGMRCVIRTHANDLER *PFNPGMRCVIRTHANDLER;
+
+/**
+ * \#PF Handler callback for virtual access handler ranges, R3.
  *
  * Important to realize that a physical page in a range can have aliases, and
@@ -217 +217 @@
  * @param   pvUser          User argument.
  */
-typedef DECLCALLBACK(int) FNPGMHCVIRTHANDLER(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
+typedef DECLCALLBACK(int) FNPGMR3VIRTHANDLER(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
 /** Pointer to PGM access callback. */
-typedef FNPGMHCVIRTHANDLER *PFNPGMHCVIRTHANDLER;
+typedef FNPGMR3VIRTHANDLER *PFNPGMR3VIRTHANDLER;
 
 
@@ -228 +228 @@
  * @param   GCPtr           The virtual address the guest has changed.
  */
-typedef DECLCALLBACK(int) FNPGMHCVIRTINVALIDATE(PVM pVM, RTGCPTR GCPtr);
+typedef DECLCALLBACK(int) FNPGMR3VIRTINVALIDATE(PVM pVM, RTGCPTR GCPtr);
 /** Pointer to PGM invalidation callback. */
-typedef FNPGMHCVIRTINVALIDATE *PFNPGMHCVIRTINVALIDATE;
+typedef FNPGMR3VIRTINVALIDATE *PFNPGMR3VIRTINVALIDATE;
 
 /**
@@ -532 +532 @@
                                              const char *pszModRC, const char *pszHandlerRC, RTRCPTR pvUserRC, const char *pszDesc);
 VMMDECL(int)    PGMHandlerVirtualRegisterEx(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
-                                            PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
-                                            PFNPGMHCVIRTHANDLER pfnHandlerHC, RTGCPTR pfnHandlerGC,
+                                            R3PTRTYPE(PFNPGMR3VIRTINVALIDATE) pfnInvalidateR3,
+                                            R3PTRTYPE(PFNPGMR3VIRTHANDLER) pfnHandlerR3,
+                                            RCPTRTYPE(PFNPGMRCVIRTHANDLER) pfnHandlerRC,
                                             R3PTRTYPE(const char *) pszDesc);
 VMMR3DECL(int)  PGMR3HandlerVirtualRegister(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
-                                            PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
-                                            PFNPGMHCVIRTHANDLER pfnHandlerHC,
-                                            const char *pszHandlerGC, const char *pszModGC, const char *pszDesc);
-VMMDECL(int)    PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, PFNPGMHCVIRTINVALIDATE pfnInvalidateHC);
+                                            PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
+                                            PFNPGMR3VIRTHANDLER pfnHandlerR3,
+                                            const char *pszHandlerRC, const char *pszModRC, const char *pszDesc);
+VMMDECL(int)    PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, R3PTRTYPE(PFNPGMR3VIRTINVALIDATE) pfnInvalidateR3);
 VMMDECL(int)    PGMHandlerVirtualDeregister(PVM pVM, RTGCPTR GCPtr);
 VMMR3DECL(int)  PGMR3PoolGrow(PVM pVM);

trunk/src/VBox/VMM/PGM.cpp

@@ -1955 +1955 @@
     Assert(     pHandler->enmType == PGMVIRTHANDLERTYPE_ALL
            ||   pHandler->enmType == PGMVIRTHANDLERTYPE_WRITE);
-    Assert(pHandler->pfnHandlerGC);
-    pHandler->pfnHandlerGC  += offDelta;
+    Assert(pHandler->pfnHandlerRC);
+    pHandler->pfnHandlerRC += offDelta;
     return 0;
 }
@@ -1974 +1974 @@
     RTGCINTPTR      offDelta = *(PRTGCINTPTR)pvUser;
     Assert(pHandler->enmType == PGMVIRTHANDLERTYPE_HYPERVISOR);
-    Assert(pHandler->pfnHandlerGC);
-    pHandler->pfnHandlerGC  += offDelta;
+    Assert(pHandler->pfnHandlerRC);
+    pHandler->pfnHandlerRC  += offDelta;
     return 0;
 }

trunk/src/VBox/VMM/PGMHandler.cpp

@@ -229 +229 @@
 /** @todo rename this function to PGMR3HandlerVirtualRegister */
 VMMR3DECL(int) PGMR3HandlerVirtualRegister(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
-                                           PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
-                                           PFNPGMHCVIRTHANDLER pfnHandlerHC,
+                                           PFNPGMR3VIRTINVALIDATE pfnInvalidateHC,
+                                           PFNPGMR3VIRTHANDLER pfnHandlerHC,
                                            const char *pszHandlerGC, const char *pszModGC,
                                            const char *pszDesc)
@@ -269 +269 @@
  * @param   GCPtr           Start address.
  * @param   GCPtrLast       Last address (inclusive).
- * @param   pfnInvalidateHC The HC invalidate callback (can be 0)
- * @param   pfnHandlerHC    The HC handler.
- * @param   pfnHandlerGC    The GC handler.
+ * @param   pfnInvalidateR3 The R3 invalidate callback (can be 0)
+ * @param   pfnHandlerR3    The R3 handler.
+ * @param   pfnHandlerRC    The RC handler.
  * @param   pszDesc         Pointer to description string. This must not be freed.
  * @thread  EMT
@@ -279 +279 @@
  * duplicating the function pointers now. (Or we will once we add the missing callbacks.) */
 VMMDECL(int) PGMHandlerVirtualRegisterEx(PVM pVM, PGMVIRTHANDLERTYPE enmType, RTGCPTR GCPtr, RTGCPTR GCPtrLast,
-                                         PFNPGMHCVIRTINVALIDATE pfnInvalidateHC,
-                                         PFNPGMHCVIRTHANDLER pfnHandlerHC, RTGCPTR pfnHandlerGC,
+                                         R3PTRTYPE(PFNPGMR3VIRTINVALIDATE) pfnInvalidateR3,
+                                         R3PTRTYPE(PFNPGMR3VIRTHANDLER) pfnHandlerR3,
+                                         RCPTRTYPE(PFNPGMRCVIRTHANDLER) pfnHandlerRC,
                                          R3PTRTYPE(const char *) pszDesc)
 {
-    Log(("PGMR3HandlerVirtualRegister: enmType=%d GCPtr=%RGv GCPtrLast=%RGv pfnHandlerGC=%RGv pszDesc=%s\n", enmType, GCPtr, GCPtrLast, pfnHandlerGC, pszDesc));
+    Log(("PGMR3HandlerVirtualRegister: enmType=%d GCPtr=%RGv GCPtrLast=%RGv pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pfnHandlerRC=%RGv pszDesc=%s\n",
+         enmType, GCPtr, GCPtrLast, pfnInvalidateR3, pfnHandlerR3, pfnHandlerRC, pszDesc));
 
     /*
@@ -292 +294 @@
         case PGMVIRTHANDLERTYPE_ALL:
         case PGMVIRTHANDLERTYPE_WRITE:
-            if (!pfnHandlerHC)
+            if (!pfnHandlerR3)
             {
                 AssertMsgFailed(("No HC handler specified!!\n"));
@@ -300 +302 @@
 
         case PGMVIRTHANDLERTYPE_HYPERVISOR:
-            if (pfnHandlerHC)
+            if (pfnHandlerR3)
             {
-                AssertMsgFailed(("HC handler specified for hypervisor range!?!\n"));
+                AssertMsgFailed(("R3 handler specified for hypervisor range!?!\n"));
                 return VERR_INVALID_PARAMETER;
             }
@@ -315 +317 @@
         return VERR_INVALID_PARAMETER;
     }
-    if (!pfnHandlerGC)
-    {
-        AssertMsgFailed(("pfnHandlerGC is missing\n"));
+    if (!pfnHandlerRC)
+    {
+        AssertMsgFailed(("pfnHandlerRC is missing\n"));
         return VERR_INVALID_PARAMETER;
     }
@@ -334 +336 @@
 
     pNew->enmType       = enmType;
-    pNew->pfnInvalidateHC = pfnInvalidateHC;
-    pNew->pfnHandlerGC  = pfnHandlerGC;
-    pNew->pfnHandlerHC  = pfnHandlerHC;
+    pNew->pfnInvalidateR3 = pfnInvalidateR3;
+    pNew->pfnHandlerRC  = pfnHandlerRC;
+    pNew->pfnHandlerR3  = pfnHandlerR3;
     pNew->pszDesc       = pszDesc;
     pNew->GCPtr         = GCPtr;
@@ -416 +418 @@
  * @param   pVM             VM handle.
  * @param   GCPtr           Start address.
- * @param   pfnInvalidateHC The HC invalidate callback (can be 0)
+ * @param   pfnInvalidateR3 The R3 invalidate callback (can be 0)
  * @remarks Doesn't work with the hypervisor access handler type.
  */
-VMMDECL(int) PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, PFNPGMHCVIRTINVALIDATE pfnInvalidateHC)
+VMMDECL(int) PGMHandlerVirtualChangeInvalidateCallback(PVM pVM, RTGCPTR GCPtr, PFNPGMR3VIRTINVALIDATE pfnInvalidateR3)
 {
     pgmLock(pVM);
@@ -425 +427 @@
     if (pCur)
     {
-        pCur->pfnInvalidateHC = pfnInvalidateHC;
+        pCur->pfnInvalidateR3 = pfnInvalidateR3;
         pgmUnlock(pVM);
         return VINF_SUCCESS;
@@ -616 +618 @@
         default:                            pszType = "????"; break;
     }
-    pHlp->pfnPrintf(pHlp, "%VGv - %VGv  %VHv  %VRv  %s  %s\n",
-        pCur->GCPtr, pCur->GCPtrLast, pCur->pfnHandlerHC, pCur->pfnHandlerGC, pszType, pCur->pszDesc);
+    pHlp->pfnPrintf(pHlp, "%RGv - %RGv  %RHv  %RRv  %s  %s\n",
+        pCur->GCPtr, pCur->GCPtrLast, pCur->pfnHandlerR3, pCur->pfnHandlerRC, pszType, pCur->pszDesc);
 #ifdef VBOX_WITH_STATISTICS
     if (pArgs->fStats)

trunk/src/VBox/VMM/PGMInternal.h

@@ -444 +444 @@
     /** Core node for the tree based on virtual ranges. */
     AVLROGCPTRNODECORE                  Core;
-    /** Number of cache pages. */
+#if GC_ARCH_BITS == 32
+    /** Alignment padding. */
     uint32_t                            u32Padding;
+#endif
     /** Access type. */
     PGMVIRTHANDLERTYPE                  enmType;
     /** Number of cache pages. */
     uint32_t                            cPages;
-#if GC_ARCH_BITS == 64
-    uint32_t                            padding0;
-#endif
+
 /** @todo The next two members are redundant. It adds some readability though. */
     /** Start of the range. */
@@ -458 +458 @@
     /** End of the range (exclusive). */
     RTGCPTR                             GCPtrLast;
+
     /** Size of the range (in bytes). */
     RTGCUINTPTR                         cb;
-    /** Pointer to the GC callback function. */
-    RCPTRTYPE(PFNPGMGCVIRTHANDLER)      pfnHandlerGC;
+    /** Pointer to the RC callback function. */
+    RCPTRTYPE(PFNPGMRCVIRTHANDLER)      pfnHandlerRC;
 #if GC_ARCH_BITS == 64
     RTRCPTR                             padding1;
 #endif
-    /** Pointer to the HC callback function for invalidation. */
-    R3PTRTYPE(PFNPGMHCVIRTINVALIDATE)   pfnInvalidateHC;
-    /** Pointer to the HC callback function. */
-    R3PTRTYPE(PFNPGMHCVIRTHANDLER)      pfnHandlerHC;
+    /** Pointer to the R3 callback function for invalidation. */
+    R3PTRTYPE(PFNPGMR3VIRTINVALIDATE)   pfnInvalidateR3;
+    /** Pointer to the R3 callback function. */
+    R3PTRTYPE(PFNPGMR3VIRTHANDLER)      pfnHandlerR3;
     /** Description / Name. For easing debugging. */
     R3PTRTYPE(const char *)             pszDesc;

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

@@ -280 +280 @@
 #  ifdef IN_GC
                     STAM_PROFILE_START(&pCur->Stat, h);
-                    rc = CTXSUFF(pCur->pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
+                    rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
                     STAM_PROFILE_STOP(&pCur->Stat, h);
 #  else
@@ -460 +460 @@
 #  ifdef IN_GC
                                 STAM_PROFILE_START(&pCur->Stat, h);
-                                rc = CTXSUFF(pCur->pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
+                                rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
                                 STAM_PROFILE_STOP(&pCur->Stat, h);
 #  else
@@ -489 +489 @@
                                 Assert(off < pCur->cb);
                                 STAM_PROFILE_START(&pCur->Stat, h);
-                                rc = CTXSUFF(pCur->pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, off);
+                                rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, off);
                                 STAM_PROFILE_STOP(&pCur->Stat, h);
 #  else
@@ -567 +567 @@
 #  ifdef IN_GC
                             STAM_PROFILE_START(&pCur->Stat, h);
-                            rc = CTXSUFF(pCur->pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
+                            rc = pCur->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->GCPtr, (RTGCUINTPTR)pvFault - (RTGCUINTPTR)pCur->GCPtr);
                             STAM_PROFILE_STOP(&pCur->Stat, h);
 #  else

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

@@ -1250 +1250 @@
                     unsigned iPage;
                     int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
-                    if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerHC)
+                    if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerR3)
                     {
                         size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
@@ -1262 +1262 @@
                         void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
 
-                        /** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
-                        rc = pNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, 0);
+                        /* Note: Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
+                        rc = pNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, 0);
                     }
 #endif /* IN_RING3 */
@@ -1491 +1491 @@
                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
 
-                            /** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
+                            /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
                             rc = pPhysNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pPhysNode->pvUserR3);
                         }
@@ -1499 +1499 @@
                         unsigned iPage;
                         int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirtNode, &iPage);
-                        if (VBOX_SUCCESS(rc2) && pVirtNode->pfnHandlerHC)
+                        if (VBOX_SUCCESS(rc2) && pVirtNode->pfnHandlerR3)
                         {
                             size_t cbRange = pVirtNode->Core.KeyLast - GCPhys + 1;
@@ -1511 +1511 @@
                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
 
-                            /** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
-                            rc2 = pVirtNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
+                            /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
+                            rc2 = pVirtNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
                             if (    (   rc2 != VINF_PGM_HANDLER_DO_DEFAULT
                                      && rc == VINF_PGM_HANDLER_DO_DEFAULT)
@@ -1549 +1549 @@
                         unsigned iPage;
                         int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
-                        if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerHC)
+                        if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerR3)
                         {
                             size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
@@ -1561 +1561 @@
                             void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
 
-                            /** @tode Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
-                            rc = pNode->pfnHandlerHC(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
+                            /* Note! Dangerous assumption that R3 handlers don't do anything that really requires an EMT lock! */
+                            rc = pNode->pfnHandlerR3(pVM, (RTGCPTR)GCPtr, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, 0);
                         }
 #endif /* IN_RING3 */

trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

@@ -558 +558 @@
     GEN_CHECK_OFF(PGMVIRTHANDLER, GCPtrLast);
     GEN_CHECK_OFF(PGMVIRTHANDLER, cb);
-    GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerHC);
-    GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerGC);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerR3);
+    GEN_CHECK_OFF(PGMVIRTHANDLER, pfnHandlerRC);
     GEN_CHECK_OFF(PGMVIRTHANDLER, pszDesc);
     GEN_CHECK_OFF(PGMVIRTHANDLER, cPages);