Changeset 6927

Timestamp:

02/12/08 21:44:35 (10 months ago)

Author:

vboxsync

Message:

Converted MM_RAM_FLAGS_VIRTUAL_HANDLER, MM_RAM_FLAGS_VIRTUAL_WRITE
and MM_RAM_FLAGS_VIRTUAL_ALL into a two bit state variable in PGMPAGE.
I've checked this trice because, like last time, bugs may have odd
sideeffects and hide for a while before showing up. Hope I got this
right (unlike for phys).

Fixed a regression from the MM_RAM_FLAGS_PHYSICAL in the physical read/write code.

Files:

• trunk/include/VBox/mm.h (modified) (1 diff)
• trunk/src/VBox/VMM/PGM.cpp (modified) (1 diff)
• trunk/src/VBox/VMM/PGMInternal.h (modified) (10 diffs)
• trunk/src/VBox/VMM/VMMAll/PGMAllBth.h (modified) (5 diffs)
• trunk/src/VBox/VMM/VMMAll/PGMAllGst.h (modified) (1 diff)
• trunk/src/VBox/VMM/VMMAll/PGMAllHandler.cpp (modified) (14 diffs)
• trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp (modified) (9 diffs)

trunk/include/VBox/mm.h

@@ -77 +77 @@
-#define MM_RAM_FLAGS_MMIO2              RT_BIT(3)
-
-/** PGM has virtual page access handler(s) defined for pages with this flag. */
-#define MM_RAM_FLAGS_VIRTUAL_HANDLER    RT_BIT(4)
-/** PGM has virtual page access handler(s) for write access. */
-#define MM_RAM_FLAGS_VIRTUAL_WRITE      RT_BIT(5)
-/** PGM has virtual page access handler(s) for all access. */
-#define MM_RAM_FLAGS_VIRTUAL_ALL        RT_BIT(6)
-#ifndef VBOX_WITH_NEW_PHYS_CODE
-/** Physical backing memory is allocated dynamically. Not set implies a one time static allocation. */

trunk/src/VBox/VMM/PGM.cpp

@@ -2150 +2150 @@
-            uint16_t    u16 = 0;
-            SSMR3GetU16(pSSM, &u16);
-MM_RAM_FLAGS_VIRTUAL_HANDLER | MM_RAM_FLAGS_VIRTUAL_WRITE | MM_RAM_FLAGS_VIRTUAL_ALL
+RT_BIT(4) | RT_BIT(5) | RT_BIT(6)
-                                        | RT_BIT(7) | RT_BIT(8) | RT_BIT(9) | RT_BIT(10) );
-                   // &= MM_RAM_FLAGS_DYNAMIC_ALLOC | MM_RAM_FLAGS_RESERVED | MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO | MM_RAM_FLAGS_MMIO2

trunk/src/VBox/VMM/PGMInternal.h

@@ -405 +405 @@
-    AVLROGCPHYSNODECORE                 Core;
-    /** Offset from this struct to the PGMVIRTHANDLER structure. */
-RTGCINTPTR
-r
+int32_t   
+
-     * Bit 0 is used for indicating whether we're in the tree.
-     * Bit 1 is used for indicating that we're the head node.
@@ -530 +530 @@
-    /** The physical handler state (PGM_PAGE_HNDL_PHYS_STATE*) */
-    uint32_t    u2HandlerPhysStateX : 2;
-
+
+
+
-} PGMPAGE;
-AssertCompileSize(PGMPAGE, 16);
@@ -791 +793 @@
-
-/**
- * Checks if the page has any access handlers, including temporarily disabled ones.
- * @returns true/false
- * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-#define PGM_PAGE_HAVE_ANY_HANDLERS(pPage) \
-    (   (pPage)->u2HandlerPhysStateX != PGM_PAGE_HNDL_PHYS_STATE_NONE \
-     || ((pPage)->HCPhys & MM_RAM_FLAGS_VIRTUAL_HANDLER) )
-
-/**
- * Checks if the page has any active access handlers.
- * @returns true/false
- * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-#define PGM_PAGE_HAVE_ACTIVE_HANDLERS(pPage) \
-    (   (pPage)->u2HandlerPhysStateX >= PGM_PAGE_HNDL_PHYS_STATE_WRITE \
-     || ((pPage)->HCPhys & MM_RAM_FLAGS_VIRTUAL_HANDLER) )
-
-/**
- * Checks if the page has any active access handlers catching all accesses.
- * @returns true/false
- * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-#define PGM_PAGE_HAVE_ACTIVE_ALL_HANDLERS(pPage) \
-    (   (pPage)->u2HandlerPhysStateX == PGM_PAGE_HNDL_PHYS_STATE_ALL \
-     || ((pPage)->HCPhys & MM_RAM_FLAGS_VIRTUAL_ALL) )
-
-/**
- * Checks if the page has any physical access handlers, including temporariliy disabled ones.
- * @returns true/false
@@ -831 +806 @@
-#define PGM_PAGE_HAVE_ACTIVE_PHYSICAL_HANDLERS(pPage)   ( (pPage)->u2HandlerPhysStateX >= PGM_PAGE_HNDL_PHYS_STATE_WRITE )
-
+
+/** @name Virtual Access Handler State values (PGMPAGE::u2HandlerVirtStateX).
+ *
+ * @remarks The values are assigned in order of priority, so we can calculate
+ *          the correct state for a page with different handlers installed.
+ * @{ */
+/** No handler installed. */
+#define PGM_PAGE_HNDL_VIRT_STATE_NONE       0
+/* 1 is reserved so the lineup is identical with the physical ones. */
+/** Write access is monitored. */
+#define PGM_PAGE_HNDL_VIRT_STATE_WRITE      2
+/** All access is monitored. */
+#define PGM_PAGE_HNDL_VIRT_STATE_ALL        3
+/** @} */
+
+/**
+ * Gets the virtual access handler state of a page.
+ * @returns PGM_PAGE_HNDL_VIRT_STATE_* value.
+ * @param   pPage       Pointer to the physical guest page tracking structure.
+ */
+#define PGM_PAGE_GET_HNDL_VIRT_STATE(pPage)     ( (pPage)->u2HandlerVirtStateX )
+
+/**
+ * Sets the virtual access handler state of a page.
+ * @param   pPage       Pointer to the physical guest page tracking structure.
+ * @param   _uState     The new state value.
+ */
+#define PGM_PAGE_SET_HNDL_VIRT_STATE(pPage, _uState) \
+    do { (pPage)->u2HandlerVirtStateX = (_uState); } while (0)
+
-/**
- * Checks if the page has any virtual access handlers.
@@ -836 +841 @@
- * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-HCPhys & MM_RAM_FLAGS_VIRTUAL_HANDLER
+u2HandlerVirtStateX != PGM_PAGE_HNDL_VIRT_STATE_NONE
-
-/**
@@ -845 +850 @@
- */
-#define PGM_PAGE_HAVE_ACTIVE_VIRTUAL_HANDLERS(pPage) PGM_PAGE_HAVE_ANY_VIRTUAL_HANDLERS(pPage)
+
+
+
+/**
+ * Checks if the page has any access handlers, including temporarily disabled ones.
+ * @returns true/false
+ * @param   pPage       Pointer to the physical guest page tracking structure.
+ */
+#define PGM_PAGE_HAVE_ANY_HANDLERS(pPage) \
+    (   (pPage)->u2HandlerPhysStateX != PGM_PAGE_HNDL_PHYS_STATE_NONE \
+     || (pPage)->u2HandlerVirtStateX != PGM_PAGE_HNDL_VIRT_STATE_NONE )
+
+/**
+ * Checks if the page has any active access handlers.
+ * @returns true/false
+ * @param   pPage       Pointer to the physical guest page tracking structure.
+ */
+#define PGM_PAGE_HAVE_ACTIVE_HANDLERS(pPage) \
+    (   (pPage)->u2HandlerPhysStateX >= PGM_PAGE_HNDL_PHYS_STATE_WRITE \
+     || (pPage)->u2HandlerVirtStateX >= PGM_PAGE_HNDL_VIRT_STATE_WRITE )
+
+/**
+ * Checks if the page has any active access handlers catching all accesses.
+ * @returns true/false
+ * @param   pPage       Pointer to the physical guest page tracking structure.
+ */
+#define PGM_PAGE_HAVE_ACTIVE_ALL_HANDLERS(pPage) \
+    (   (pPage)->u2HandlerPhysStateX == PGM_PAGE_HNDL_PHYS_STATE_ALL \
+     || (pPage)->u2HandlerVirtStateX == PGM_PAGE_HNDL_VIRT_STATE_ALL )
-
-
@@ -2455 +2489 @@
- * @{
- */
-MM_RAM_FLAGS_VIRTUAL_HANDLER page bit
+virtual access handler state bit in PGMPAGE
-#define PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL        RT_BIT(0)
-/** Always sync CR3. */
@@ -3250 +3284 @@
-
-/**
+ * Gets the page state for a virtual handler.
+ *
+ * @returns The virtual handler page state.
+ * @param   pCur    The virtual handler in question.
+ * @remarks This should never be used on a hypervisor access handler.
+ */
+DECLINLINE(unsigned) pgmHandlerVirtualCalcState(PPGMVIRTHANDLER pCur)
+{
+    switch (pCur->enmType)
+    {
+        case PGMVIRTHANDLERTYPE_WRITE:
+            return PGM_PAGE_HNDL_VIRT_STATE_WRITE;
+        case PGMVIRTHANDLERTYPE_ALL:
+            return PGM_PAGE_HNDL_VIRT_STATE_ALL;
+        default:
+            AssertFatalMsgFailed(("Invalid type %d\n", pCur->enmType));
+    }
+}
+
+
+/**
- * Clears one physical page of a virtual handler
- *
@@ -3255 +3310 @@
- * @param   pCur    Virtual handler structure
- * @param   iPage   Physical page index
+ *
+ * @remark  Only used when PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL is being set, so no
+ *          need to care about other handlers in the same page.
- */
-DECLINLINE(void) pgmHandlerVirtualClearPage(PPGM pPGM, PPGMVIRTHANDLER pCur, unsigned iPage)
@@ -3345 +3403 @@
-     * Clear the ram flags for this page.
-     */
-int rc = pgmRamFlagsClearByGCPhys(pPGM, pPhys2Virt->Core.Key,
-                                  MM_RAM_FLAGS_VIRTUAL_HANDLER | MM_RAM_FLAGS_VIRTUAL_ALL | MM_RAM_FLAGS_VIRTUAL_WRITE
-AssertRC(rc
+PPGMPAGE pPage = pgmPhysGetPage(pPGM, pPhys2Virt->Core.Key);
+AssertReturnVoid(pPage
+PGM_PAGE_SET_HNDL_VIRT_STATE(pPage, PGM_PAGE_HNDL_VIRT_STATE_NONE
-}
-

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

@@ -93 +93 @@
-
-# if PGM_WITH_PAGING(PGM_GST_TYPE)
-    /* Determine current privilege level */
-    uint32_t cpl = CPUMGetGuestCPL(pVM, pRegFrame);
-
-#  ifdef PGM_SYNC_DIRTY_BIT
-    /*
@@ -345 +342 @@
-                         * In case of write access continue to the GC write handler.
-                         */
-(pPage->HCPhys & (MM_RAM_FLAGS_VIRTUAL_WRITE | MM_RAM_FLAGS_VIRTUAL_ALL)) == MM_RAM_FLAGS_VIRTUAL_WRITE /** @todo PAGE FLAGS */
+PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) < PGM_PAGE_HNDL_PHYS_STATE_ALL
-                            && !(uErr & X86_TRAP_PF_P))
-                        {
@@ -439 +436 @@
-                    STAM_COUNTER_INC(&pVM->pgm.s.StatHandlersUnhandled);
-
-
-
+
-                        &&  !(uErr & X86_TRAP_PF_P))
-                    {
@@ -539 +535 @@
-
-#  if PGM_WITH_PAGING(PGM_GST_TYPE) && !defined(IN_RING0)
-cpl
+CPUMGetGuestCPL(pVM, pRegFrame)
-                {
-                    uint64_t fPageGst;
@@ -1128 +1124 @@
-            const RTHCPHYS HCPhys = pPage->HCPhys; /** @todo FLAGS */
-            SHWPTE PteDst;
-
-
+
-            {
-                /** @todo r=bird: Are we actually handling dirty and access bits for pages with access handlers correctly? No. */
-
-
+
-                    PteDst.u = (PteSrc.u & ~(X86_PTE_PAE_PG_MASK | X86_PTE_AVL_MASK | X86_PTE_PAT | X86_PTE_PCD | X86_PTE_PWT | X86_PTE_RW))
-                             | (HCPhys & X86_PTE_PAE_PG_MASK);

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

@@ -657 +657 @@
-#endif
-
-    unsigned    fFlags;
-    switch (pCur->enmType)
-    {
-        case PGMVIRTHANDLERTYPE_WRITE:      fFlags = MM_RAM_FLAGS_VIRTUAL_HANDLER | MM_RAM_FLAGS_VIRTUAL_WRITE; break;
-        case PGMVIRTHANDLERTYPE_ALL:        fFlags = MM_RAM_FLAGS_VIRTUAL_HANDLER | MM_RAM_FLAGS_VIRTUAL_ALL; break;
-        /* hypervisor handlers need no flags and wouldn't have nowhere to put them in any case. */
-        case PGMVIRTHANDLERTYPE_HYPERVISOR:
-            return 0;
-    }
-
-    unsigned    offPage = GCPtr & PAGE_OFFSET_MASK;
-    unsigned    iPage = 0;

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

@@ -1026 +1026 @@
-        *piPage = pCur - &(*ppVirt)->aPhysToVirt[0];
-
-
-
+
-        STAM_PROFILE_STOP(CTXSUFF(&pVM->pgm.s.StatVirtHandleSearchByPhys), a);
-        return VINF_SUCCESS;
@@ -1041 +1040 @@
- * Deal with aliases in phys2virt.
- *
+ * As pointed out by the various todos, this currently only deals with
+ * aliases where the two ranges match 100%.
+ *
- * @param   pVM             The VM handle.
- * @param   pPhys2Virt      The node we failed insert.
@@ -1050 +1052 @@
-     */
-    /** @todo Deal with partial overlapping. (Unlikly situation, so I'm too lazy to do anything about it now.) */
+    /** @todo check if the current head node covers the ground we do. This is highly unlikely
+     * and I'm too lazy to implement this now as it will require sorting the list and stuff like that. */
-    PPGMPHYS2VIRTHANDLER pHead = (PPGMPHYS2VIRTHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTXSUFF(pTrees)->PhysToVirtHandlers, pPhys2Virt->Core.Key);
-    if (!pHead)
-    {
-        /** @todo do something clever here... */
-#ifdef IN_RING3
-        LogRel(("pgmHandlerVirtualInsertAliased: %VGp-%VGp\n", pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast));
-#endif
-        pPhys2Virt->offNextAlias = 0;
-        return;
-    }
-#ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
-    AssertReleaseMsg(pHead != pPhys2Virt, ("%VGp-%VGp offVirtHandler=%#RX32\n",
-                                           pPhys2Virt->Core.Key, pPhys2Virt->Core.KeyLast, pPhys2Virt->offVirtHandler));
-#endif
-
-
-
+
+
+
+
+
+
+
-
-    /*
@@ -1088 +1087 @@
- * Resets one virtual handler range.
- *
+ * This is called by HandlerVirtualUpdate when it has detected some kind of
+ * problem and have started clearing the virtual handler page states (or
+ * when there have been registration/deregistrations). For this reason this
+ * function will only update the page status if it's lower than desired.
+ *
- * @returns 0
- * @param   pNode   Pointer to a PGMVIRTHANDLER.
@@ -1098 +1102 @@
-
-    /*
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-    PPGMRAMRANGE    pRamHint = NULL;
-    RTGCUINTPTR     offPage  = ((RTGCUINTPTR)pCur->GCPtr & PAGE_OFFSET_MASK);
@@ -1125 +1113 @@
-        if (pPhys2Virt->Core.Key != NIL_RTGCPHYS)
-        {
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            if (pPhys2Virt->Core.KeyLast == NIL_RTGCPHYS)
-            {
@@ -1200 +1197 @@
-typedef struct PGMAHAFIS
-{
+    /** The current physical address. */
+    RTGCPHYS    GCPhys;
+    /** The state we've calculated. */
+    unsigned    uVirtStateFound;
+    /** The state we're matching up to. */
+    unsigned    uVirtState;
+    /** Number of errors. */
+    unsigned    cErrors;
-    /** The VM handle. */
-    PVM         pVM;
-    /** Number of errors. */
-    unsigned    cErrors;
-    /** The flags we've found. */
-    unsigned    fFlagsFound;
-    /** The flags we're matching up to.
-     * This is also on the stack as a const, thus only valid during enumeration. */
-    unsigned    fFlags;
-    /** The current physical address. */
-    RTGCPHYS    GCPhys;
-} PGMAHAFIS, *PPGMAHAFIS;
-
+
+#if 0 /* unused */
-/**
- * Verify virtual handler by matching physical address.
@@ -1220 +1218 @@
- * @param   pvUser  Pointer to user parameter.
- */
-VirtHandler
+HandlerVirtual
-{
-    PPGMVIRTHANDLER pCur = (PPGMVIRTHANDLER)pNode;
@@ -1229 +1227 @@
-        if ((pCur->aPhysToVirt[iPage].Core.Key & X86_PTE_PAE_PG_MASK) == pState->GCPhys)
-        {
-
+
+
-            {
-
-
-
-
-
+
-            }
-
-    ==  pState->fFlagsFound
-
+
+if (pState->uVirtState == uState
+ //??
-        }
-    }
-    return 0;
-}
-
-
-
-
+
+
+
+
+
+
+
+
- *
- * @returns 0
- * @param   pNode   Pointer to a PGMVIRTHANDLER.
-user parameter
-
-VirtHandler
+a PPGMAHAFIS structure
+
+HandlerVirtual
-{
-    PPGMVIRTHANDLER pVirt   = (PPGMVIRTHANDLER)pNode;
-
+ 
-    PVM             pVM     = pState->pVM;
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                         pVirt->aPhysToVirt[0].Core.Key, pVirt->GCPtr, HCSTRING(pVirt->pszDesc)));
-        pState->cErrors++;
-    }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-     */
-    RTGCUINTPTR   GCPtr = (RTGCUINTPTR)pVirt->GCPtr;
@@ -1322 +1331 @@
-        }
-
-(pPage->HCPhys & fFlags) != fFlags) /** @todo PAGE FLAGS */
-
-flags mismatch. HCPhys=%VHp fFlags=%#x GCPhysGst=%VGp iPage=%#x %VGv
-fFlags, GCPhysGst, iPage, GCPtr
+PGM_PAGE_GET_HNDL_VIRT_STATE(pPage) < uState)
+
+state mismatch. HCPhys=%VHp GCPhysGst=%VGp iPage=%#x %VGv state=%d expected>=%d
+GCPhysGst, iPage, GCPtr, PGM_PAGE_GET_HNDL_VIRT_STATE(pPage), uState
-            pState->cErrors++;
-            continue;
@@ -1346 +1355 @@
-    PPGM        pPGM = &pVM->pgm.s;
-    PGMAHAFIS   State;
+    State.GCPhys = 0;
+    State.uVirtState = 0;
+    State.uVirtStateFound = 0;
-    State.cErrors = 0;
-    
+
-
-    /*
@@ -1361 +1373 @@
-            {
-                State.GCPhys = pRam->GCPhys + (iPage << PAGE_SHIFT);
-                State.fFlagsFound = 0; /* build flags and compare. */
-
-                /*
@@ -1424 +1435 @@
-                }
-
-
+
+
+
-                if (PGM_PAGE_HAVE_ACTIVE_VIRTUAL_HANDLERS(pPage))
-                {
-
-
-
+
+
+
+
+
+
-                    {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        State.cErrors++;
-                    }
-
-                }
-            }
@@ -1442 +1488 @@
-
-    /*
-
-
-
+
+
+
+
-
-    /*

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

@@ -1179 +1179 @@
-                        {
-                            memcpy(pvBuf, pvSrc, cbRead);
-break
+goto end
-                        }
-                        memcpy(pvBuf, pvSrc, cb);
-                    }
-                    else if (cb >= cbRead)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                else
-                {
-VIRTUAL_ALL | MM_RAM_FLAGS_
+
-                    {
-                        /*
@@ -1198 +1246 @@
-                        //case MM_RAM_FLAGS_ROM | MM_RAM_FLAGS_MMIO2: /* = shadow */ - //MMIO2 isn't in the mask.
-                        case MM_RAM_FLAGS_MMIO2: // MMIO2 isn't in the mask.
-                        case MM_RAM_FLAGS_VIRTUAL_WRITE:
-                        {
-#ifdef IN_GC
@@ -1234 +1281 @@
-                            break;
-
-                        case MM_RAM_FLAGS_VIRTUAL_ALL:
-                        {
-                            int rc = VINF_PGM_HANDLER_DO_DEFAULT;
-                            cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
-#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
-                            /* Search the whole tree for matching physical addresses (rather expensive!) */
-                            PPGMVIRTHANDLER pNode;
-                            unsigned iPage;
-                            int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pNode, &iPage);
-                            if (VBOX_SUCCESS(rc2) && pNode->pfnHandlerHC)
-                            {
-                                size_t cbRange = pNode->Core.KeyLast - GCPhys + 1;
-                                if (cbRange < cb)
-                                    cb = cbRange;
-                                if (cb > cbRead)
-                                    cb = cbRead;
-                                RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pNode->GCPtr & PAGE_BASE_GC_MASK)
-                                                  + (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
-
-                                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);
-                            }
-#endif /* IN_RING3 */
-                            if (rc == VINF_PGM_HANDLER_DO_DEFAULT)
-                            {
-#ifdef IN_GC
-                                void *pvSrc = NULL;
-                                PGMGCDynMapHCPage(pVM, PGM_PAGE_GET_HCPHYS(pPage), &pvSrc);
-                                pvSrc = (char *)pvSrc + (off & PAGE_OFFSET_MASK);
-#else
-                                void *pvSrc = PGMRAMRANGE_GETHCPTR(pRam, off)
-#endif
-                                if (cb >= cbRead)
-                                {
-                                    memcpy(pvBuf, pvSrc, cbRead);
-                                    goto end;
-                                }
-                                memcpy(pvBuf, pvSrc, cb);
-                            }
-                            else if (cb >= cbRead)
-                                goto end;
-                            break;
-                        }
-
-                        /*
-                         * The rest needs to be taken more carefully.
@@ -1293 +1294 @@
-                            AssertReleaseMsgFailed(("Unknown read at %VGp size %d implement the complex physical reading case %x\n",
-                                                    GCPhys, cbRead,
-VIRTUAL_ALL | MM_RAM_FLAGS_
+
-                            cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
-                            break;
@@ -1410 +1411 @@
-                /* temporary hack, will reogranize is later. */
-                /*
+                 * Virtual handlers
+                 */
+                if (    PGM_PAGE_HAVE_ACTIVE_VIRTUAL_HANDLERS(pPage)
+                    && !(pPage->HCPhys & MM_RAM_FLAGS_MMIO)) /// @todo PAGE FLAGS
+                {
+                    if (PGM_PAGE_HAVE_ACTIVE_PHYSICAL_HANDLERS(pPage))
+                    {
+                        /*
+                         * Physical write handler + virtual write handler.
+                         * Consider this a quick workaround for the CSAM + shadow caching problem.
+                         *
+                         * We hand it to the shadow caching first since it requires the unchanged
+                         * data. CSAM will have to put up with it already being changed.
+                         */
+                        int rc = VINF_PGM_HANDLER_DO_DEFAULT;
+                        cb = PAGE_SIZE - (off & PAGE_OFFSET_MASK);
+#ifdef IN_RING3 /** @todo deal with this in GC and R0! */
+                        /* 1. The physical handler */
+                        PPGMPHYSHANDLER pPhysNode = (PPGMPHYSHANDLER)RTAvlroGCPhysRangeGet(&pVM->pgm.s.pTreesHC->PhysHandlers, GCPhys);
+                        if (pPhysNode && pPhysNode->pfnHandlerR3)
+                        {
+                            size_t cbRange = pPhysNode->Core.KeyLast - GCPhys + 1;
+                            if (cbRange < cb)
+                                cb = cbRange;
+                            if (cb > cbWrite)
+                                cb = cbWrite;
+
+                            void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
+
+                            /** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
+                            rc = pPhysNode->pfnHandlerR3(pVM, GCPhys, pvDst, (void *)pvBuf, cb, PGMACCESSTYPE_WRITE, pPhysNode->pvUserR3);
+                        }
+
+                        /* 2. The virtual handler (will see incorrect data) */
+                        PPGMVIRTHANDLER pVirtNode;
+                        unsigned iPage;
+                        int rc2 = pgmHandlerVirtualFindByPhysAddr(pVM, GCPhys, &pVirtNode, &iPage);
+                        if (VBOX_SUCCESS(rc2) && pVirtNode->pfnHandlerHC)
+                        {
+                            size_t cbRange = pVirtNode->Core.KeyLast - GCPhys + 1;
+                            if (cbRange < cb)
+                                cb = cbRange;
+                            if (cb > cbWrite)
+                                cb = cbWrite;
+                            RTGCUINTPTR GCPtr = ((RTGCUINTPTR)pVirtNode->GCPtr & PAGE_BASE_GC_MASK)
+                                              + (iPage << PAGE_SHIFT) + (off & PAGE_OFFSET_MASK);
+
+                            void *pvDst = PGMRAMRANGE_GETHCPTR(pRam, off)
+
+                            /** @note Dangerous assumption that HC handlers don't do anything that really requires an EMT lock! */
+                            rc2 = pVirtNode->pfnHand