Index: /trunk/include/VBox/vmm/pgm.h
===================================================================
--- /trunk/include/VBox/vmm/pgm.h	(revision 55894)
+++ /trunk/include/VBox/vmm/pgm.h	(revision 55895)
@@ -178,16 +178,18 @@
  *
  * @returns VBox status code (appropriate for GC return).
- * @param   pVM         VM Handle.
- * @param   uErrorCode   CPU Error code.
- * @param   pRegFrame   Trap register frame.
- * @param   pvFault     The fault address (cr2).
- * @param   pvRange     The base address of the handled virtual range.
- * @param   offRange    The offset of the access into this range.
- *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
+ * @param   pVM             VM Handle.
+ * @param   uErrorCode      CPU Error code (X86_TRAP_PF_XXX).
+ * @param   pRegFrame       Trap register frame.
+ * @param   pvFault         The fault address (cr2).
+ * @param   pvRange         The base address of the handled virtual range.
+ * @param   offRange        The offset of the access into this range.
+ *                          (If it's a EIP range this is the EIP, if not it's pvFault.)
+ * @param   pvUser          User argument.
  * @todo    Add pVCpu, possibly replacing pVM.
  */
-typedef DECLCALLBACK(int) FNPGMRCVIRTHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+typedef DECLCALLBACK(int) FNPGMRCVIRTPFHANDLER(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                               RTGCPTR pvRange, uintptr_t offRange, void *pvUser);
 /** Pointer to PGM access callback. */
-typedef FNPGMRCVIRTHANDLER *PFNPGMRCVIRTHANDLER;
+typedef FNPGMRCVIRTPFHANDLER *PFNPGMRCVIRTPFHANDLER;
 
 /**
@@ -208,5 +210,6 @@
  * @todo    Add pVCpu, possibly replacing pVM.
  */
-typedef DECLCALLBACK(int) FNPGMR3VIRTHANDLER(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 FNPGMR3VIRTHANDLER *PFNPGMR3VIRTHANDLER;
@@ -218,6 +221,7 @@
  * @param   pVM             VM Handle.
  * @param   GCPtr           The virtual address the guest has changed.
- */
-typedef DECLCALLBACK(int) FNPGMR3VIRTINVALIDATE(PVM pVM, RTGCPTR GCPtr);
+ * @param   pvUser          User argument.
+ */
+typedef DECLCALLBACK(int) FNPGMR3VIRTINVALIDATE(PVM pVM, RTGCPTR GCPtr, void *pvUser);
 /** Pointer to PGM invalidation callback. */
 typedef FNPGMR3VIRTINVALIDATE *PFNPGMR3VIRTINVALIDATE;
@@ -546,10 +550,10 @@
                                                       PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
                                                       PFNPGMR3VIRTHANDLER pfnHandlerR3,
-                                                      RCPTRTYPE(PFNPGMRCVIRTHANDLER) pfnHandlerRC,
+                                                      RCPTRTYPE(FNPGMRCVIRTPFHANDLER) pfnPfHandlerRC,
                                                       const char *pszDesc, PPGMVIRTHANDLERTYPE phType);
 VMMR3_INT_DECL(int) PGMR3HandlerVirtualTypeRegister(PVM pVM, PGMVIRTHANDLERKIND enmKind, bool fRelocUserRC,
                                                     PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
                                                     PFNPGMR3VIRTHANDLER pfnHandlerR3,
-                                                    const char *pszHandlerRC, const char *pszModRC, const char *pszDesc,
+                                                    const char *pszPfHandlerRC, const char *pszModRC, const char *pszDesc,
                                                     PPGMVIRTHANDLERTYPE phType);
 VMMR3_INT_DECL(int) PGMR3HandlerVirtualRegister(PVM pVM, PVMCPU pVCpu, PGMVIRTHANDLERTYPE hType, RTGCPTR GCPtr,
Index: /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h
===================================================================
--- /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMAll/PGMAllBth.h	(revision 55895)
@@ -334,10 +334,10 @@
 #   ifdef IN_RC
                 STAM_PROFILE_START(&pCur->Stat, h);
-                RTGCPTR                     GCPtrStart = pCur->Core.Key;
-                CTX_MID(PFNPGM,VIRTHANDLER) pfnHandler = pCurType->CTX_SUFF(pfnHandler);
+                RTGCPTR GCPtrStart = pCur->Core.Key;
                 pgmUnlock(pVM);
                 *pfLockTaken = false;
 
-                rc = pfnHandler(pVM, uErr, pRegFrame, pvFault, GCPtrStart, pvFault - GCPtrStart);
+                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPtrStart, pvFault - GCPtrStart,
+                                                      pCur->pvUserRC);
 
 #    ifdef VBOX_WITH_STATISTICS
@@ -374,6 +374,5 @@
 #   ifdef IN_RC
                     STAM_PROFILE_START(&pCur->Stat, h);
-                    RTGCPTR                     GCPtrStart = pCur->Core.Key;
-                    CTX_MID(PFNPGM,VIRTHANDLER) pfnHandler = pCurType->CTX_SUFF(pfnHandler);
+                    RTGCPTR GCPtrStart = pCur->Core.Key;
                     pgmUnlock(pVM);
                     *pfLockTaken = false;
@@ -383,5 +382,5 @@
                                 - (GCPtrStart & PAGE_OFFSET_MASK);
                     Assert(off < pCur->cb);
-                    rc = pfnHandler(pVM, uErr, pRegFrame, pvFault, GCPtrStart, off);
+                    rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, GCPtrStart, off, pCur->pvUserRC);
 
 #    ifdef VBOX_WITH_STATISTICS
@@ -718,5 +717,6 @@
                  * Check if the fault address is in a virtual page access handler range.
                  */
-                PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->HyperVirtHandlers, pvFault);
+                PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)RTAvlroGCPtrRangeGet(&pVM->pgm.s.CTX_SUFF(pTrees)->HyperVirtHandlers,
+                                                                             pvFault);
                 if (    pCur
                     &&  pvFault - pCur->Core.Key < pCur->cb
@@ -727,5 +727,6 @@
                     PPGMVIRTHANDLERTYPEINT pCurType = PGMVIRTANDLER_GET_TYPE(pVM, pCur);
                     pgmUnlock(pVM);
-                    rc = pCurType->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key);
+                    rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key,
+                                                          pCur->pvUserRC);
                     pgmLock(pVM);
                     STAM_PROFILE_STOP(&pCur->Stat, h);
@@ -821,5 +822,6 @@
                 STAM_PROFILE_START(&pCur->Stat, h);
                 pgmUnlock(pVM);
-                rc = pCurType->CTX_SUFF(pfnHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key);
+                rc = pCurType->CTX_SUFF(pfnPfHandler)(pVM, uErr, pRegFrame, pvFault, pCur->Core.Key, pvFault - pCur->Core.Key,
+                                                      pCur->pvUserRC);
                 pgmLock(pVM);
                 STAM_PROFILE_STOP(&pCur->Stat, h);
Index: /trunk/src/VBox/VMM/VMMR3/CSAM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/CSAM.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/CSAM.cpp	(revision 55895)
@@ -70,8 +70,8 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static DECLCALLBACK(int) csamr3Save(PVM pVM, PSSMHANDLE pSSM);
-static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
-static DECLCALLBACK(int) CSAMCodePageWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-static DECLCALLBACK(int) CSAMCodePageInvalidate(PVM pVM, RTGCPTR GCPtr);
+static DECLCALLBACK(int) csamR3Save(PVM pVM, PSSMHANDLE pSSM);
+static DECLCALLBACK(int) csamR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+static FNPGMR3VIRTHANDLER    csamR3CodePageWriteHandler;
+static FNPGMR3VIRTINVALIDATE csamR3CodePageInvalidate;
 
 bool                csamIsCodeScanned(PVM pVM, RTRCPTR pInstr, PCSAMPAGE *pPage);
@@ -84,6 +84,6 @@
                                           PFN_CSAMR3ANALYSE pfnCSAMR3Analyse, void *pUserData, PCSAMP2GLOOKUPREC pCacheRec);
 
-/** @todo Temporary for debugging. */
-static bool fInCSAMCodePageInvalidate = false;
+/** @todo "Temporary" for debugging. */
+static bool g_fInCsamR3CodePageInvalidate = false;
 
 #ifdef VBOX_WITH_DEBUGGER
@@ -255,13 +255,13 @@
     rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
                                          NULL /*pfnInvalidateR3 */,
-                                         CSAMCodePageWriteHandler,
-                                         "CSAMGCCodePageWriteHandler", NULL /*pszModRC*/,
+                                         csamR3CodePageWriteHandler,
+                                         "csamRCCodePageWritePfHandler", NULL /*pszModRC*/,
                                          "CSAM code page write handler",
                                          &pVM->csam.s.hCodePageWriteType);
     AssertLogRelRCReturn(rc, rc);
     rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
-                                         CSAMCodePageInvalidate,
-                                         CSAMCodePageWriteHandler,
-                                         "CSAMGCCodePageWriteHandler", NULL /*pszModRC*/,
+                                         csamR3CodePageInvalidate,
+                                         csamR3CodePageWriteHandler,
+                                         "csamRCCodePageWritePfHandler", NULL /*pszModRC*/,
                                          "CSAM code page write and invlpg handler",
                                          &pVM->csam.s.hCodePageWriteAndInvPgType);
@@ -273,6 +273,6 @@
     rc = SSMR3RegisterInternal(pVM, "CSAM", 0, CSAM_SAVED_STATE_VERSION, sizeof(pVM->csam.s) + PAGE_SIZE*16,
                                NULL, NULL, NULL,
-                               NULL, csamr3Save, NULL,
-                               NULL, csamr3Load, NULL);
+                               NULL, csamR3Save, NULL,
+                               NULL, csamR3Load, NULL);
     AssertRCReturn(rc, rc);
 
@@ -540,5 +540,5 @@
  * @param   pSSM            SSM operation handle.
  */
-static DECLCALLBACK(int) csamr3Save(PVM pVM, PSSMHANDLE pSSM)
+static DECLCALLBACK(int) csamR3Save(PVM pVM, PSSMHANDLE pSSM)
 {
     CSAM csamInfo = pVM->csam.s;
@@ -562,5 +562,5 @@
     AssertRCReturn(rc, rc);
 
-    for (unsigned i=0;i<CSAM_PGDIRBMP_CHUNKS;i++)
+    for (unsigned i = 0; i < CSAM_PGDIRBMP_CHUNKS; i++)
     {
         if(csamInfo.pPDBitmapHC[i])
@@ -592,5 +592,5 @@
  * @param   uPass           The data pass.
  */
-static DECLCALLBACK(int) csamr3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+static DECLCALLBACK(int) csamR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
     int  rc;
@@ -1867,5 +1867,5 @@
 
 #ifdef CSAM_MONITOR_CODE_PAGES
-    AssertRelease(!fInCSAMCodePageInvalidate);
+    AssertRelease(!g_fInCsamR3CodePageInvalidate);
 
     switch (enmTag)
@@ -2112,5 +2112,5 @@
              * if this happens often, then reuse it instead!!!
              */
-            Assert(!fInCSAMCodePageInvalidate);
+            Assert(!g_fInCsamR3CodePageInvalidate);
             STAM_COUNTER_DEC(&pVM->csam.s.StatPageMonitor);
             PGMHandlerVirtualDeregister(pVM, pVCpu, GCPtr, false /*fHypervisor*/);
@@ -2179,10 +2179,11 @@
  * @param   pvUser          User argument.
  */
-static DECLCALLBACK(int) CSAMCodePageWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser)
+static DECLCALLBACK(int) csamR3CodePageWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf,
+                                                    PGMACCESSTYPE enmAccessType, void *pvUser)
 {
     int rc;
 
     Assert(enmAccessType == PGMACCESSTYPE_WRITE); NOREF(enmAccessType);
-    Log(("CSAMCodePageWriteHandler: write to %RGv size=%zu\n", GCPtr, cbBuf));
+    Log(("csamR3CodePageWriteHandler: write to %RGv size=%zu\n", GCPtr, cbBuf));
     NOREF(pvUser);
 
@@ -2190,5 +2191,5 @@
          && !memcmp(pvPtr, pvBuf, cbBuf))
     {
-        Log(("CSAMCodePageWriteHandler: dummy write -> ignore\n"));
+        Log(("csamR3CodePageWriteHandler: dummy write -> ignore\n"));
         return VINF_PGM_HANDLER_DO_DEFAULT;
     }
@@ -2202,5 +2203,5 @@
          *        (if it writes the same data as the patch jump and we replace it with obsolete opcodes)
          */
-        Log(("CSAMCodePageWriteHandler: delayed write!\n"));
+        Log(("csamR3CodePageWriteHandler: delayed write!\n"));
         AssertCompileSize(RTRCPTR, 4);
         rc = VMR3ReqCallVoidNoWait(pVM, VMCPUID_ANY, (PFNRT)CSAMDelayedWriteHandler, 3, pVM, (RTRCPTR)GCPtr, cbBuf);
@@ -2217,11 +2218,11 @@
  * @param   GCPtr           The virtual address the guest has changed.
  */
-static DECLCALLBACK(int) CSAMCodePageInvalidate(PVM pVM, RTGCPTR GCPtr)
-{
-    fInCSAMCodePageInvalidate = true;
-    LogFlow(("CSAMCodePageInvalidate %RGv\n", GCPtr));
+static DECLCALLBACK(int) csamR3CodePageInvalidate(PVM pVM, RTGCPTR GCPtr, void *pvUser)
+{
+    g_fInCsamR3CodePageInvalidate = true;
+    LogFlow(("csamR3CodePageInvalidate %RGv\n", GCPtr));
     /** @todo We can't remove the page (which unregisters the virtual handler) as we are called from a DoWithAll on the virtual handler tree. Argh. */
     csamFlushPage(pVM, GCPtr, false /* don't remove page! */);
-    fInCSAMCodePageInvalidate = false;
+    g_fInCsamR3CodePageInvalidate = false;
     return VINF_SUCCESS;
 }
Index: /trunk/src/VBox/VMM/VMMR3/PATM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/PATM.cpp	(revision 55895)
@@ -92,4 +92,5 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
+static FNPGMR3VIRTHANDLER patmR3VirtPageHandler;
 
 static int          patmDisableUnusablePatch(PVM pVM, RTRCPTR pInstrGC, RTRCPTR pConflictAddr, PPATCHINFO pPatch);
@@ -217,4 +218,14 @@
     if (RT_FAILURE(rc))
         return rc;
+
+    /*
+     * Register the virtual page access handler type.
+     */
+    rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_ALL, false /*fRelocUserRC*/,
+                                         NULL /*pfnInvalidateR3*/,
+                                         patmR3VirtPageHandler,
+                                         "patmRCVirtPagePfHandler", NULL /*pszModRC*/,
+                                         "PATMMonitorPatchJump", &pVM->patm.s.hMonitorPageType);
+    AssertRCReturn(rc, rc);
 
     /*
@@ -368,14 +379,4 @@
                           VERR_INTERNAL_ERROR_4);
 
-
-    /*
-     * Register the virtual page access handler type.
-     */
-    rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_ALL, false /*fRelocUserRC*/,
-                                         NULL /*pfnInvalidateR3*/,
-                                         patmVirtPageHandler,
-                                         "PATMGCMonitorPage", NULL /*pszModRC*/,
-                                         "PATMMonitorPatchJump", &pVM->patm.s.hMonitorPageType);
-    AssertRCReturn(rc, rc);
 
     return VINF_SUCCESS;
@@ -990,6 +991,6 @@
  * @param   pvUser          User argument.
  */
-DECLCALLBACK(int) patmVirtPageHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf,
-                                      PGMACCESSTYPE enmAccessType, void *pvUser)
+static DECLCALLBACK(int) patmR3VirtPageHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf,
+                                               PGMACCESSTYPE enmAccessType, void *pvUser)
 {
     Assert(enmAccessType == PGMACCESSTYPE_WRITE); NOREF(enmAccessType);
Index: /trunk/src/VBox/VMM/VMMR3/PGM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PGM.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/PGM.cpp	(revision 55895)
@@ -2440,6 +2440,6 @@
     RTListOff32ForEach(&pVM->pgm.s.pTreesR3->HeadVirtHandlerTypes, pCurVirtType, PGMVIRTHANDLERTYPEINT, ListNode)
     {
-        if (pCurVirtType->pfnHandlerRC != NIL_RTRCPTR)
-            pCurVirtType->pfnHandlerRC += offDelta;
+        if (pCurVirtType->pfnPfHandlerRC != NIL_RTRCPTR)
+            pCurVirtType->pfnPfHandlerRC += offDelta;
     }
 
Index: /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp	(revision 55895)
@@ -291,5 +291,5 @@
                                                       PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
                                                       PFNPGMR3VIRTHANDLER pfnHandlerR3,
-                                                      RCPTRTYPE(PFNPGMRCVIRTHANDLER) pfnHandlerRC,
+                                                      RCPTRTYPE(FNPGMRCVIRTPFHANDLER) pfnPfHandlerRC,
                                                       const char *pszDesc, PPGMVIRTHANDLERTYPE phType)
 {
@@ -297,5 +297,5 @@
     AssertReturn(RT_VALID_PTR(pfnHandlerR3) || enmKind == PGMVIRTHANDLERKIND_HYPERVISOR, VERR_INVALID_POINTER);
     AssertPtrNullReturn(pfnInvalidateR3, VERR_INVALID_POINTER);
-    AssertReturn(pfnHandlerRC != NIL_RTRCPTR, VERR_INVALID_POINTER);
+    AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR, VERR_INVALID_POINTER);
     AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
     AssertReturn(   enmKind == PGMVIRTHANDLERKIND_WRITE
@@ -316,5 +316,5 @@
         pType->pfnInvalidateR3  = pfnInvalidateR3;
         pType->pfnHandlerR3     = pfnHandlerR3;
-        pType->pfnHandlerRC     = pfnHandlerRC;
+        pType->pfnPfHandlerRC   = pfnPfHandlerRC;
         pType->pszDesc          = pszDesc;
 
@@ -324,6 +324,6 @@
 
         *phType = MMHyperHeapPtrToOffset(pVM, pType);
-        LogFlow(("PGMR3HandlerVirtualTypeRegisterEx: %p/%#x: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pfnHandlerRC=%RRv pszDesc=%s\n",
-                 pType, *phType, enmKind, pfnInvalidateR3, pfnHandlerR3, pfnHandlerRC, pszDesc));
+        LogFlow(("PGMR3HandlerVirtualTypeRegisterEx: %p/%#x: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pfnPfHandlerRC=%RRv pszDesc=%s\n",
+                 pType, *phType, enmKind, pfnInvalidateR3, pfnHandlerR3, pfnPfHandlerRC, pszDesc));
         return VINF_SUCCESS;
     }
@@ -346,5 +346,5 @@
  * @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
+ * @param   pszPfHandlerRC  The name of the raw-mode context handler, NULL if
  *                          the ring-3 handler should be called.
  * @param   pszDesc         The type description.
@@ -356,9 +356,9 @@
                                                     PFNPGMR3VIRTINVALIDATE pfnInvalidateR3,
                                                     PFNPGMR3VIRTHANDLER pfnHandlerR3,
-                                                    const char *pszHandlerRC, const char *pszModRC, const char *pszDesc,
+                                                    const char *pszPfHandlerRC, const char *pszModRC, const char *pszDesc,
                                                     PPGMVIRTHANDLERTYPE phType)
 {
-    LogFlow(("PGMR3HandlerVirtualTypeRegister: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pszModRC=%s pszHandlerRC=%s pszDesc=%s\n",
-             enmKind, pfnInvalidateR3, pfnHandlerR3, pszHandlerRC, pszModRC, pszDesc));
+    LogFlow(("PGMR3HandlerVirtualTypeRegister: enmKind=%d pfnInvalidateR3=%RHv pfnHandlerR3=%RHv pszModRC=%s pszPfHandlerRC=%s pszDesc=%s\n",
+             enmKind, pfnInvalidateR3, pfnHandlerR3, pszPfHandlerRC, pszModRC, pszDesc));
 
     /*
@@ -367,20 +367,18 @@
     if (!pszModRC)
         pszModRC = VMMGC_MAIN_MODULE_NAME;
-    if (!pszHandlerRC)
-        pszHandlerRC = "pgmVirtHandlerRedirectToHC";
-    AssertPtrReturn(pszHandlerRC, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPfHandlerRC, VERR_INVALID_POINTER);
 
     /*
      * Resolve the GC handler.
      */
-    RTRCPTR pfnHandlerRC = NIL_RTRCPTR;
-    int rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszHandlerRC, &pfnHandlerRC);
+    RTRCPTR pfnPfHandlerRC = NIL_RTRCPTR;
+    int rc = PDMR3LdrGetSymbolRCLazy(pVM, pszModRC, NULL /*pszSearchPath*/, pszPfHandlerRC, &pfnPfHandlerRC);
     if (RT_SUCCESS(rc))
         return PGMR3HandlerVirtualTypeRegisterEx(pVM, enmKind, fRelocUserRC,
                                                  pfnInvalidateR3, pfnHandlerR3,
-                                                 pfnHandlerRC,
+                                                 pfnPfHandlerRC,
                                                  pszDesc, phType);
 
-    AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszHandlerRC, rc));
+    AssertMsgFailed(("Failed to resolve %s.%s, rc=%Rrc.\n", pszModRC, pszPfHandlerRC, rc));
     return rc;
 }
@@ -756,5 +754,5 @@
     }
     pHlp->pfnPrintf(pHlp, "%RGv - %RGv  %RHv  %RRv  %s  %s\n",
-        pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCurType->pfnHandlerRC, pszType, pCur->pszDesc);
+        pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCurType->pfnPfHandlerRC, pszType, pCur->pszDesc);
 #ifdef VBOX_WITH_STATISTICS
     if (pArgs->fStats)
Index: /trunk/src/VBox/VMM/VMMR3/SELM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/SELM.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/SELM.cpp	(revision 55895)
@@ -95,7 +95,7 @@
 static DECLCALLBACK(int)  selmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
 static DECLCALLBACK(int)  selmR3LoadDone(PVM pVM, PSSMHANDLE pSSM);
-static DECLCALLBACK(int)  selmR3GuestGDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-static DECLCALLBACK(int)  selmR3GuestLDTWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-static DECLCALLBACK(int)  selmR3GuestTSSWriteHandler(PVM pVM, RTGCPTR GCPtr, void *pvPhys, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
+static FNPGMR3VIRTHANDLER selmR3GuestGDTWriteHandler;
+static FNPGMR3VIRTHANDLER selmR3GuestLDTWriteHandler;
+static FNPGMR3VIRTHANDLER selmR3GuestTSSWriteHandler;
 static DECLCALLBACK(void) selmR3InfoGdt(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 static DECLCALLBACK(void) selmR3InfoGdtGuest(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
@@ -203,5 +203,5 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_HYPERVISOR, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, NULL /*pfnHandlerR3*/,
-                                             "selmRCShadowGDTWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCShadowGDTWritePfHandler", NULL /*pszModRC*/,
                                              "Shadow GDT write access handler", &pVM->selm.s.hShadowGdtWriteHandlerType);
         AssertRCReturn(rc, rc);
@@ -210,5 +210,5 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_HYPERVISOR, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, NULL /*pfnHandlerR3*/,
-                                             "selmRCShadowTSSWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCShadowTSSWritePfHandler", NULL /*pszModRC*/,
                                              "Shadow TSS write access handler", &pVM->selm.s.hShadowTssWriteHandlerType);
         AssertRCReturn(rc, rc);
@@ -217,5 +217,5 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_HYPERVISOR, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, NULL /*pfnHandlerR3*/,
-                                             "selmRCShadowLDTWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCShadowLDTWritePfHandler", NULL /*pszModRC*/,
                                              "Shadow LDT write access handler", &pVM->selm.s.hShadowLdtWriteHandlerType);
         AssertRCReturn(rc, rc);
@@ -223,15 +223,15 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, selmR3GuestGDTWriteHandler,
-                                             "selmRCGuestGDTWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCGuestGDTWritePfHandler", NULL /*pszModRC*/,
                                              "Guest GDT write access handler", &pVM->selm.s.hGuestGdtWriteHandlerType);
         AssertRCReturn(rc, rc);
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, selmR3GuestLDTWriteHandler,
-                                             "selmRCGuestLDTWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCGuestLDTWritePfHandler", NULL /*pszModRC*/,
                                              "Guest LDT write access handler", &pVM->selm.s.hGuestLdtWriteHandlerType);
         AssertRCReturn(rc, rc);
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, selmR3GuestTSSWriteHandler,
-                                             "selmRCGuestTSSWriteHandler", NULL /*pszModRC*/,
+                                             "selmRCGuestTSSWritePfHandler", NULL /*pszModRC*/,
                                              "Guest TSS write access handler", &pVM->selm.s.hGuestTssWriteHandlerType);
         AssertRCReturn(rc, rc);
Index: /trunk/src/VBox/VMM/VMMR3/TRPM.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMR3/TRPM.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMR3/TRPM.cpp	(revision 55895)
@@ -518,5 +518,5 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_HYPERVISOR, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, NULL /*pfnHandlerR3*/,
-                                             "trpmRCShadowIDTWriteHandler", NULL /*pszModRC*/,
+                                             "trpmRCShadowIDTWritePfHandler", NULL /*pszModRC*/,
                                              "Shadow IDT write access handler", &pVM->trpm.s.hShadowIdtWriteHandlerType);
         AssertRCReturn(rc, rc);
@@ -524,5 +524,5 @@
         rc = PGMR3HandlerVirtualTypeRegister(pVM, PGMVIRTHANDLERKIND_WRITE, false /*fRelocUserRC*/,
                                              NULL /*pfnInvalidateR3*/, trpmR3GuestIDTWriteHandler,
-                                             "trpmRCGuestIDTWriteHandler", NULL /*pszModRC*/,
+                                             "trpmRCGuestIDTWritePfHandler", NULL /*pszModRC*/,
                                              "Guest IDT write access handler", &pVM->trpm.s.hGuestIdtWriteHandlerType);
         AssertRCReturn(rc, rc);
Index: /trunk/src/VBox/VMM/VMMRC/CSAMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/CSAMRC.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMRC/CSAMRC.cpp	(revision 55895)
@@ -46,4 +46,6 @@
 #include <iprt/string.h>
 
+
+
 /**
  * \#PF Handler callback for virtual access handler ranges. (CSAM self-modifying
@@ -61,6 +63,8 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
+ * @param   pvUser      Ignored.
  */
-VMMRCDECL(int) CSAMGCCodePageWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+DECLEXPORT(int) csamRCCodePageWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                             RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     PPATMGCSTATE pPATMGCState;
@@ -81,8 +85,8 @@
 
     Assert(pPATMGCState->fPIF || fPatchCode);
-    /** When patch code is executing instructions that must complete, then we must *never* interrupt it. */
+    /* When patch code is executing instructions that must complete, then we must *never* interrupt it. */
     if (!pPATMGCState->fPIF && fPatchCode)
     {
-        Log(("CSAMGCCodePageWriteHandler: fPIF=0 -> stack fault in patch generated code at %08RX32!\n", pRegFrame->eip));
+        Log(("csamRCCodePageWriteHandler: fPIF=0 -> stack fault in patch generated code at %08RX32!\n", pRegFrame->eip));
         /** @note there are cases when pages previously used for code are now used for stack; patch generated code will fault (pushf))
          *  Just make the page r/w and continue.
@@ -104,5 +108,5 @@
         cpl = (pRegFrame->ss.Sel & X86_SEL_RPL);
 
-    Log(("CSAMGCCodePageWriteHandler: code page write at %RGv original address %RGv (cpl=%d)\n", pvFault, (RTGCUINTPTR)pvRange + offRange, cpl));
+    Log(("csamRCCodePageWriteHandler: code page write at %RGv original address %RGv (cpl=%d)\n", pvFault, (RTGCUINTPTR)pvRange + offRange, cpl));
 
     /* If user code is modifying one of our monitored pages, then we can safely make it r/w as it's no longer being used for supervisor code. */
@@ -131,5 +135,5 @@
      * Make this particular page R/W. The VM_FF_CSAM_FLUSH_DIRTY_PAGE handler will reset it to readonly again.
      */
-    Log(("CSAMGCCodePageWriteHandler: enabled r/w for page %RGv\n", pvFault));
+    Log(("csamRCCodePageWriteHandler: enabled r/w for page %RGv\n", pvFault));
     rc = PGMShwMakePageWritable(pVCpu, pvFault, PGM_MK_PG_IS_WRITE_FAULT);
     AssertMsgRC(rc, ("PGMShwModifyPage -> rc=%Rrc\n", rc));
Index: /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMRC/PATMRC.cpp	(revision 55895)
@@ -57,5 +57,6 @@
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) PATMGCMonitorPage(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+DECLEXPORT(int) patmRCVirtPagePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                        RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange);
Index: /trunk/src/VBox/VMM/VMMRC/SELMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/SELMRC.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMRC/SELMRC.cpp	(revision 55895)
@@ -223,5 +223,4 @@
 
 
-
 /**
  * \#PF Virtual Handler callback for Guest write access to the Guest's own GDT.
@@ -236,9 +235,10 @@
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
  */
-VMMRCDECL(int) selmRCGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+DECLEXPORT(int) selmRCGuestGDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                             RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     PVMCPU pVCpu = VMMGetCpu0(pVM);
-    LogFlow(("selmRCGuestGDTWriteHandler errcode=%x fault=%RGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
-    NOREF(pvRange);
+    LogFlow(("selmRCGuestGDTWritePfHandler errcode=%x fault=%RGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
+    NOREF(pvRange); NOREF(pvUser);
 
     /*
@@ -328,10 +328,12 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) selmRCGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+ * @param   pvUser      Unused.
+ */
+DECLEXPORT(int) selmRCGuestLDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                             RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     /** @todo To be implemented. */
     ////LogCom(("selmRCGuestLDTWriteHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
-    NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange);
+    NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange); NOREF(pvUser);
 
     VMCPU_FF_SET(VMMGetCpu0(pVM), VMCPU_FF_SELM_SYNC_LDT);
@@ -381,10 +383,12 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) selmRCGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+ * @param   pvUser      Unused.
+ */
+DECLEXPORT(int) selmRCGuestTSSWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                             RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     PVMCPU pVCpu = VMMGetCpu0(pVM);
-    LogFlow(("selmRCGuestTSSWriteHandler errcode=%x fault=%RGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
-    NOREF(pvRange);
+    LogFlow(("selmRCGuestTSSWritePfHandler errcode=%x fault=%RGv offRange=%08x\n", (uint32_t)uErrorCode, pvFault, offRange));
+    NOREF(pvRange); NOREF(pvUser);
 
     /*
@@ -409,5 +413,5 @@
            )
         {
-            Log(("selmRCGuestTSSWriteHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
+            Log(("selmRCGuestTSSWritePfHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
                  (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), (RTGCPTR)pVM->selm.s.Tss.esp1, (RTSEL)pGuestTss->ss0, (RTGCPTR)pGuestTss->esp0));
             pVM->selm.s.Tss.esp1 = pGuestTss->esp0;
@@ -423,5 +427,5 @@
                 )
         {
-            Log(("selmRCGuestTSSWriteHandler: R1 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
+            Log(("selmRCGuestTSSWritePfHandler: R1 stack: %RTsel:%RGv -> %RTsel:%RGv\n",
                  (RTSEL)((pVM->selm.s.Tss.ss2 & ~2) | 1), (RTGCPTR)pVM->selm.s.Tss.esp2, (RTSEL)pGuestTss->ss1, (RTGCPTR)pGuestTss->esp1));
             pVM->selm.s.Tss.esp2 = pGuestTss->esp1;
@@ -447,5 +451,5 @@
                )
             {
-                Log(("selmRCGuestTSSWriteHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv [x-page]\n",
+                Log(("selmRCGuestTSSWritePfHandler: R0 stack: %RTsel:%RGv -> %RTsel:%RGv [x-page]\n",
                      (RTSEL)(pVM->selm.s.Tss.ss1 & ~1), (RTGCPTR)pVM->selm.s.Tss.esp1, (RTSEL)s.ss0, (RTGCPTR)s.esp0));
                 pVM->selm.s.Tss.esp1 = s.esp0;
@@ -534,9 +538,11 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) selmRCShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmRCShadowGDTWriteHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
-    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange);
+ * @param   pvUser      Unused.
+ */
+DECLEXPORT(int) selmRCShadowGDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                              RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
+{
+    LogRel(("FATAL ERROR: selmRCShadowGDTWritePfHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
+    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange); NOREF(pvUser);
     return VERR_SELM_SHADOW_GDT_WRITE;
 }
@@ -556,10 +562,12 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) selmRCShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmRCShadowLDTWriteHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
+ * @param   pvUser      Unused.
+ */
+DECLEXPORT(int) selmRCShadowLDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                              RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
+{
+    LogRel(("FATAL ERROR: selmRCShadowLDTWritePfHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
     Assert(pvFault - (uintptr_t)pVM->selm.s.pvLdtRC < (unsigned)(65536U + PAGE_SIZE));
-    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange);
+    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange); NOREF(pvUser);
     return VERR_SELM_SHADOW_LDT_WRITE;
 }
@@ -579,9 +587,11 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) selmRCShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
-{
-    LogRel(("FATAL ERROR: selmRCShadowTSSWriteHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
-    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange);
+ * @param   pvUser      Unused.
+ */
+DECLEXPORT(int) selmRCShadowTSSWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                              RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
+{
+    LogRel(("FATAL ERROR: selmRCShadowTSSWritePfHandler: eip=%08X pvFault=%RGv pvRange=%RGv\r\n", pRegFrame->eip, pvFault, pvRange));
+    NOREF(pVM); NOREF(uErrorCode); NOREF(pRegFrame); NOREF(pvFault); NOREF(pvRange); NOREF(offRange); NOREF(pvUser);
     return VERR_SELM_SHADOW_TSS_WRITE;
 }
Index: /trunk/src/VBox/VMM/VMMRC/TRPMRC.cpp
===================================================================
--- /trunk/src/VBox/VMM/VMMRC/TRPMRC.cpp	(revision 55894)
+++ /trunk/src/VBox/VMM/VMMRC/TRPMRC.cpp	(revision 55895)
@@ -101,6 +101,8 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
+ * @param   pvUser      Unused.
  */
-VMMRCDECL(int) trpmRCGuestIDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+DECLEXPORT(int) trpmRCGuestIDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                             RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     PVMCPU      pVCpu = VMMGetCpu0(pVM);
@@ -114,5 +116,5 @@
     AssertMsg(offRange < (uint32_t)cbIDT+1, ("pvFault=%RGv GCPtrIDT=%RGv-%RGv pvRange=%RGv\n", pvFault, GCPtrIDT, GCPtrIDTEnd, pvRange));
     Assert((RTGCPTR)(RTRCUINTPTR)pvRange == GCPtrIDT);
-    NOREF(uErrorCode);
+    NOREF(uErrorCode); NOREF(pvUser);
 
 #if 0
@@ -143,5 +145,5 @@
 #endif
 
-    Log(("trpmRCGuestIDTWriteHandler: eip=%RGv write to gate %x offset %x\n", pRegFrame->eip, iGate, offRange));
+    Log(("trpmRCGuestIDTWritePfHandler: eip=%RGv write to gate %x offset %x\n", pRegFrame->eip, iGate, offRange));
 
     /** @todo Check which IDT entry and keep the update cost low in TRPMR3SyncIDT() and CSAMCheckGates(). */
@@ -164,10 +166,12 @@
  * @param   offRange    The offset of the access into this range.
  *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
+ * @param   pvUser      Unused.
  */
-VMMRCDECL(int) trpmRCShadowIDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange)
+DECLEXPORT(int) trpmRCShadowIDTWritePfHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault,
+                                              RTGCPTR pvRange, uintptr_t offRange, void *pvUser)
 {
     PVMCPU pVCpu = VMMGetCpu0(pVM);
-    LogRel(("FATAL ERROR: trpmRCShadowIDTWriteHandler: eip=%08X pvFault=%RGv pvRange=%08RGv\r\n", pRegFrame->eip, pvFault, pvRange));
-    NOREF(uErrorCode); NOREF(offRange);
+    LogRel(("FATAL ERROR: trpmRCShadowIDTWritePfHandler: eip=%08X pvFault=%RGv pvRange=%08RGv\r\n", pRegFrame->eip, pvFault, pvRange));
+    NOREF(uErrorCode); NOREF(offRange); NOREF(pvUser);
 
     /*
Index: /trunk/src/VBox/VMM/include/CSAMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/CSAMInternal.h	(revision 55894)
+++ /trunk/src/VBox/VMM/include/CSAMInternal.h	(revision 55895)
@@ -283,5 +283,5 @@
 
 RT_C_DECLS_BEGIN
-VMMRCDECL(int) CSAMGCCodePageWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) csamRCCodePageWritePfHandler;
 RT_C_DECLS_END
 
Index: /trunk/src/VBox/VMM/include/PATMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/PATMInternal.h	(revision 55894)
+++ /trunk/src/VBox/VMM/include/PATMInternal.h	(revision 55895)
@@ -599,6 +599,4 @@
 
 
-DECLCALLBACK(int) patmVirtPageHandler(PVM pVM, RTGCPTR GCPtr, void *pvPtr, void *pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
-
 DECLCALLBACK(int) patmR3Save(PVM pVM, PSSMHANDLE pSSM);
 DECLCALLBACK(int) patmR3Load(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
@@ -639,18 +637,5 @@
 
 RT_C_DECLS_BEGIN
-/**
- * #PF Virtual Handler callback for Guest access a page monitored by PATM
- *
- * @returns VBox status code (appropriate for trap handling and GC return).
- * @param   pVM         Pointer to the VM.
- * @param   uErrorCode   CPU Error code.
- * @param   pRegFrame   Trap register frame.
- * @param   pvFault     The fault address (cr2).
- * @param   pvRange     The base address of the handled virtual range.
- * @param   offRange    The offset of the access into this range.
- *                      (If it's a EIP range this is the EIP, if not it's pvFault.)
- */
-VMMRCDECL(int) PATMGCMonitorPage(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) patmRCVirtPagePfHandler;
 RT_C_DECLS_END
 
Index: /trunk/src/VBox/VMM/include/PGMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/PGMInternal.h	(revision 55894)
+++ /trunk/src/VBox/VMM/include/PGMInternal.h	(revision 55895)
@@ -711,5 +711,5 @@
     bool                                afPadding[3];
     /** Pointer to RC callback function. */
-    RCPTRTYPE(PFNPGMRCVIRTHANDLER)      pfnHandlerRC;
+    RCPTRTYPE(PFNPGMRCVIRTPFHANDLER)    pfnPfHandlerRC;
     /** Pointer to the R3 callback function for invalidation. */
     R3PTRTYPE(PFNPGMR3VIRTINVALIDATE)   pfnInvalidateR3;
Index: /trunk/src/VBox/VMM/include/SELMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/SELMInternal.h	(revision 55894)
+++ /trunk/src/VBox/VMM/include/SELMInternal.h	(revision 55895)
@@ -230,11 +230,10 @@
 RT_C_DECLS_BEGIN
 
-VMMRCDECL(int) selmRCGuestGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmRCGuestLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmRCGuestTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-
-VMMRCDECL(int) selmRCShadowGDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmRCShadowLDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) selmRCShadowTSSWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCGuestGDTWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCGuestLDTWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCGuestTSSWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCShadowGDTWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCShadowLDTWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) selmRCShadowTSSWritePfHandler;
 
 void           selmSetRing1Stack(PVM pVM, uint32_t ss, RTGCPTR32 esp);
Index: /trunk/src/VBox/VMM/include/TRPMInternal.h
===================================================================
--- /trunk/src/VBox/VMM/include/TRPMInternal.h	(revision 55894)
+++ /trunk/src/VBox/VMM/include/TRPMInternal.h	(revision 55895)
@@ -249,6 +249,6 @@
 
 
-VMMRCDECL(int) trpmRCGuestIDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
-VMMRCDECL(int) trpmRCShadowIDTWriteHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPTR pvRange, uintptr_t offRange);
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) trpmRCGuestIDTWritePfHandler;
+DECLEXPORT(FNPGMRCVIRTPFHANDLER) trpmRCShadowIDTWritePfHandler;
 
 /**
Index: /trunk/src/VBox/VMM/testcase/tstVMStruct.h
===================================================================
--- /trunk/src/VBox/VMM/testcase/tstVMStruct.h	(revision 55894)
+++ /trunk/src/VBox/VMM/testcase/tstVMStruct.h	(revision 55895)
@@ -811,5 +811,5 @@
     GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, uState);
     GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, fRelocUserRC);
-    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerRC);
+    GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnPfHandlerRC);
     GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnInvalidateR3);
     GEN_CHECK_OFF(PGMVIRTHANDLERTYPEINT, pfnHandlerR3);