Changeset 80182 in vbox for trunk/src

Timestamp:

Aug 7, 2019 11:17:11 AM (5 years ago)

Author:

vboxsync

Message:

VMM: Kicking out raw-mode - Eliminated more RCPTRTYPE use in PGM. bugref:9517

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/PGMAllHandler.cpp (modified) (5 diffs)
• VMMAll/PGMAllPool.cpp (modified) (1 diff)
• VMMR3/PGM.cpp (modified) (3 diffs)
• VMMR3/PGMHandler.cpp (modified) (6 diffs)
• VMMR3/PGMPhys.cpp (modified) (17 diffs)
• include/PGMInternal.h (modified) (8 diffs)

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

@@ -179 +179 @@
         pNew->pvUserR3      = pvUserR3;
         pNew->pvUserR0      = pvUserR0;
-        pNew->pvUserRC      = pvUserRC;
         pNew->hType         = hType;
         pNew->pszDesc       = pszDesc != NIL_RTR3PTR ? pszDesc : pType->pszDesc;
@@ -208 +207 @@
                                       pPhysHandlerSrc->pvUserR3,
                                       pPhysHandlerSrc->pvUserR0,
-                                      pPhysHandlerSrc->pvUserRC,
+                                      NIL_RTR0PTR,
                                       pPhysHandlerSrc->pszDesc,
                                       ppPhysHandler);
@@ -951 +950 @@
 
 /**
- * Changes the user callback arguments associated with a physical access
- * handler.
+ * Changes the user callback arguments associated with a physical access handler.
  *
  * @returns VBox status code.
@@ -959 +957 @@
  * @param   pvUserR3        User argument to the R3 handler.
  * @param   pvUserR0        User argument to the R0 handler.
- * @param   pvUserRC        User argument to the RC handler. Values larger or
- *                          equal to 0x10000 will be relocated automatically.
- */
-VMMDECL(int) PGMHandlerPhysicalChangeUserArgs(PVM pVM, RTGCPHYS GCPhys, RTR3PTR pvUserR3, RTR0PTR pvUserR0, RTRCPTR pvUserRC)
+ */
+VMMDECL(int) PGMHandlerPhysicalChangeUserArgs(PVM pVM, RTGCPHYS GCPhys, RTR3PTR pvUserR3, RTR0PTR pvUserR0)
 {
     /*
@@ -977 +973 @@
         pCur->pvUserR3 = pvUserR3;
         pCur->pvUserR0 = pvUserR0;
-        pCur->pvUserRC = pvUserRC;
     }
     else

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

@@ -2590 +2590 @@
             PPGMPOOLPAGE pNewHead = &pPool->aPages[pPage->iMonitoredNext];
             pNewHead->iMonitoredPrev = NIL_PGMPOOL_IDX;
-            rc = PGMHandlerPhysicalChangeUserArgs(pVM, pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK, MMHyperCCToR3(pVM, pNewHead),
-                                                  MMHyperCCToR0(pVM, pNewHead), MMHyperCCToRC(pVM, pNewHead));
+            rc = PGMHandlerPhysicalChangeUserArgs(pVM, pPage->GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK,
+                                                  MMHyperCCToR3(pVM, pNewHead), MMHyperCCToR0(pVM, pNewHead));
 
             AssertFatalRCSuccess(rc);

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

@@ -673 +673 @@
 static DECLCALLBACK(void) pgmR3InfoMode(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 static DECLCALLBACK(void) pgmR3InfoCr3(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
-static DECLCALLBACK(int)  pgmR3RelocatePhysHandler(PAVLROGCPHYSNODECORE pNode, void *pvUser);
 #ifdef VBOX_STRICT
 static FNVMATSTATE        pgmR3ResetNoMorePhysWritesFlag;
@@ -1868 +1867 @@
      */
     if (pVM->pgm.s.pRamRangesXR3)
-    {
-        /* Update the pSelfRC pointers and relink them. */
-        for (PPGMRAMRANGE pCur = pVM->pgm.s.pRamRangesXR3; pCur; pCur = pCur->pNextR3)
-            if (!(pCur->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING))
-                pCur->pSelfRC = MMHyperCCToRC(pVM, pCur);
         pgmR3PhysRelinkRamRanges(pVM);
-    }
-
-    /*
-     * Update the pSelfRC pointer of the MMIO2 ram ranges since they might not
-     * be mapped and thus not included in the above exercise.
-     */
-    for (PPGMREGMMIORANGE pCur = pVM->pgm.s.pRegMmioRangesR3; pCur; pCur = pCur->pNextR3)
-        if (!(pCur->RamRange.fFlags & PGM_RAM_RANGE_FLAGS_FLOATING))
-            pCur->RamRange.pSelfRC = MMHyperCCToRC(pVM, &pCur->RamRange);
 
 #ifndef PGM_WITHOUT_MAPPINGS
@@ -1936 +1921 @@
 
     /*
-     * Physical and virtual handlers.
-     */
-    PGMRELOCHANDLERARGS Args = { offDelta, pVM };
-    RTAvlroGCPhysDoWithAll(&pVM->pgm.s.pTreesR3->PhysHandlers,     true, pgmR3RelocatePhysHandler,      &Args);
-
-    PPGMPHYSHANDLERTYPEINT pCurPhysType;
-    RTListOff32ForEach(&pVM->pgm.s.pTreesR3->HeadPhysHandlerTypes, pCurPhysType, PGMPHYSHANDLERTYPEINT, ListNode)
-    {
-        if (pCurPhysType->pfnHandlerRC != NIL_RTRCPTR)
-            pCurPhysType->pfnHandlerRC += offDelta;
-        if (pCurPhysType->pfnPfHandlerRC != NIL_RTRCPTR)
-            pCurPhysType->pfnPfHandlerRC += offDelta;
-    }
-
-    /*
      * The page pool.
      */
     pgmR3PoolRelocate(pVM);
-}
-
-
-/**
- * Callback function for relocating a physical access handler.
- *
- * @returns 0 (continue enum)
- * @param   pNode       Pointer to a PGMPHYSHANDLER node.
- * @param   pvUser      Pointer to a PGMRELOCHANDLERARGS.
- */
-static DECLCALLBACK(int) pgmR3RelocatePhysHandler(PAVLROGCPHYSNODECORE pNode, void *pvUser)
-{
-    PPGMPHYSHANDLER         pHandler = (PPGMPHYSHANDLER)pNode;
-    PCPGMRELOCHANDLERARGS   pArgs    = (PCPGMRELOCHANDLERARGS)pvUser;
-    if (pHandler->pvUserRC >= 0x10000)
-        pHandler->pvUserRC += pArgs->offDelta;
-    return 0;
 }
 

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

@@ -84 +84 @@
                                                        R0PTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerR0,
                                                        R0PTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerR0,
-                                                       RCPTRTYPE(PFNPGMPHYSHANDLER) pfnHandlerRC,
-                                                       RCPTRTYPE(PFNPGMRZPHYSPFHANDLER) pfnPfHandlerRC,
                                                        const char *pszDesc, PPGMPHYSHANDLERTYPE phType)
 {
@@ -91 +89 @@
     AssertReturn(pfnHandlerR0   != NIL_RTR0PTR, VERR_INVALID_POINTER);
     AssertReturn(pfnPfHandlerR0 != NIL_RTR0PTR, VERR_INVALID_POINTER);
-    AssertReturn(pfnHandlerRC   != NIL_RTRCPTR || !VM_IS_RAW_MODE_ENABLED(pVM), VERR_INVALID_POINTER);
-    AssertReturn(pfnPfHandlerRC != NIL_RTRCPTR || !VM_IS_RAW_MODE_ENABLED(pVM), VERR_INVALID_POINTER);
     AssertPtrReturn(pszDesc, VERR_INVALID_POINTER);
     AssertReturn(   enmKind == PGMPHYSHANDLERKIND_WRITE
@@ -111 +107 @@
         pType->pfnHandlerR0     = pfnHandlerR0;
         pType->pfnPfHandlerR0   = pfnPfHandlerR0;
-        pType->pfnHandlerRC     = pfnHandlerRC;
-        pType->pfnPfHandlerRC   = pfnPfHandlerRC;
         pType->pszDesc          = pszDesc;
 
@@ -120 +114 @@
 
         *phType = MMHyperHeapPtrToOffset(pVM, pType);
-        LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pfnHandlerRC=%RRv pszDesc=%s\n",
-                 pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pfnPfHandlerRC, pszDesc));
+        LogFlow(("PGMR3HandlerPhysicalTypeRegisterEx: %p/%#x: enmKind=%d pfnHandlerR3=%RHv pfnHandlerR0=%RHv pszDesc=%s\n",
+                 pType, *phType, enmKind, pfnHandlerR3, pfnPfHandlerR0, pszDesc));
         return VINF_SUCCESS;
     }
@@ -208 +202 @@
             if (RT_SUCCESS(rc))
                 return PGMR3HandlerPhysicalTypeRegisterEx(pVM, enmKind, pfnHandlerR3,
-                                                          pfnHandlerR0, pfnPfHandlerR0,
-                                                          pfnHandlerRC, pfnPfHandlerRC,
-                                                          pszDesc, phType);
+                                                          pfnHandlerR0, pfnPfHandlerR0, pszDesc, phType);
         }
         else
@@ -397 +389 @@
     }
     pHlp->pfnPrintf(pHlp,
-        "%RGp - %RGp  %RHv  %RHv  %RRv  %RRv  %s  %s\n",
-        pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3, pCurType->pfnPfHandlerRC, pCur->pvUserRC,
-                    pszType, pCur->pszDesc);
+                    "%RGp - %RGp  %RHv  %RHv  %RHv  %RHv  %s  %s\n",
+                    pCur->Core.Key, pCur->Core.KeyLast, pCurType->pfnHandlerR3, pCur->pvUserR3,
+                    pCurType->pfnPfHandlerR0, pCur->pvUserR0, pszType, pCur->pszDesc);
 #ifdef VBOX_WITH_STATISTICS
     if (pArgs->fStats)

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

@@ -884 +884 @@
         (a_pNode)->pLeftR0  = NIL_RTR0PTR; \
         (a_pNode)->pRightR0 = NIL_RTR0PTR; \
-        (a_pNode)->pLeftRC  = NIL_RTRCPTR; \
-        (a_pNode)->pRightRC = NIL_RTRCPTR; \
     } while (0)
 
@@ -892 +890 @@
         (a_pParent)->pLeftR3 = (a_pNode); \
         (a_pParent)->pLeftR0 = (a_pNode)->pSelfR0; \
-        (a_pParent)->pLeftRC = (a_pNode)->pSelfRC; \
     } while (0)
 #define INSERT_RIGHT(a_pParent, a_pNode) \
@@ -898 +895 @@
         (a_pParent)->pRightR3 = (a_pNode); \
         (a_pParent)->pRightR0 = (a_pNode)->pSelfR0; \
-        (a_pParent)->pRightRC = (a_pNode)->pSelfRC; \
     } while (0)
 
@@ -1032 +1028 @@
     {
         Assert((pCur->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pCur->pSelfR0 == MMHyperCCToR0(pVM, pCur));
-        Assert((pCur->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pCur->pSelfRC == MMHyperCCToRC(pVM, pCur));
         Assert((pCur->GCPhys     & PAGE_OFFSET_MASK) == 0);
         Assert((pCur->GCPhysLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
@@ -1049 +1044 @@
 
         for (; pCur->pNextR3; pCur = pCur->pNextR3)
-        {
             pCur->pNextR0 = pCur->pNextR3->pSelfR0;
-            pCur->pNextRC = pCur->pNextR3->pSelfRC;
-        }
 
         Assert(pCur->pNextR0 == NIL_RTR0PTR);
-        Assert(pCur->pNextRC == NIL_RTRCPTR);
     }
     else
@@ -1078 +1069 @@
     AssertMsg(pNew->pszDesc, ("%RGp-%RGp\n", pNew->GCPhys, pNew->GCPhysLast));
     Assert((pNew->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pNew->pSelfR0 == MMHyperCCToR0(pVM, pNew));
-    Assert((pNew->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pNew->pSelfRC == MMHyperCCToRC(pVM, pNew));
 
     pgmLock(pVM);
@@ -1085 +1075 @@
     pNew->pNextR3 = pRam;
     pNew->pNextR0 = pRam ? pRam->pSelfR0 : NIL_RTR0PTR;
-    pNew->pNextRC = pRam ? pRam->pSelfRC : NIL_RTRCPTR;
 
     if (pPrev)
@@ -1091 +1080 @@
         pPrev->pNextR3 = pNew;
         pPrev->pNextR0 = pNew->pSelfR0;
-        pPrev->pNextRC = pNew->pSelfRC;
     }
     else
@@ -1116 +1104 @@
     Assert(pPrev ? pPrev->pNextR3 == pRam : pVM->pgm.s.pRamRangesXR3 == pRam);
     Assert((pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pRam->pSelfR0 == MMHyperCCToR0(pVM, pRam));
-    Assert((pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pRam->pSelfRC == MMHyperCCToRC(pVM, pRam));
 
     pgmLock(pVM);
@@ -1125 +1112 @@
         pPrev->pNextR3 = pNext;
         pPrev->pNextR0 = pNext ? pNext->pSelfR0 : NIL_RTR0PTR;
-        pPrev->pNextRC = pNext ? pNext->pSelfRC : NIL_RTRCPTR;
     }
     else
@@ -1666 +1652 @@
      */
     pNew->pSelfR0       = R0PtrNew != NIL_RTR0PTR ? R0PtrNew : MMHyperCCToR0(pVM, pNew);
-    pNew->pSelfRC       = RCPtrNew != NIL_RTRCPTR ? RCPtrNew : MMHyperCCToRC(pVM, pNew);
     pNew->GCPhys        = GCPhys;
     pNew->GCPhysLast    = GCPhysLast;
@@ -2446 +2431 @@
         /* Initialize the range. */
         pNew->pSelfR0       = MMHyperCCToR0(pVM, pNew);
-        pNew->pSelfRC       = MMHyperCCToRC(pVM, pNew);
         pNew->GCPhys        = GCPhys;
         pNew->GCPhysLast    = GCPhysLast;
@@ -2789 +2773 @@
             pNew->RamRange.pSelfR0  = R0PtrChunk + RT_UOFFSETOF(PGMREGMMIORANGE, RamRange);
 
-            /*
-             * If we might end up in raw-mode, make a HMA mapping of the range,
-             * just like we do for memory above 4GB.
-             */
-            if (!VM_IS_RAW_MODE_ENABLED(pVM))
-                pNew->RamRange.pSelfRC  = NIL_RTRCPTR;
-            else
-            {
-                RTGCPTR         GCPtrChunkMap = pVM->pgm.s.GCPtrPrevRamRangeMapping - RT_ALIGN_Z(cbChunk, _4M);
-                RTGCPTR const   GCPtrChunk    = GCPtrChunkMap + PAGE_SIZE;
-#ifndef PGM_WITHOUT_MAPPINGS
-                rc = PGMR3MapPT(pVM, GCPtrChunkMap, (uint32_t)cbChunk, 0 /*fFlags*/, pgmR3PhysMMIOExRangeRelocate, pNew, pszDesc);
-                if (RT_SUCCESS(rc))
-                {
-#endif /* !PGM_WITHOUT_MAPPINGS */
-                    pVM->pgm.s.GCPtrPrevRamRangeMapping = GCPtrChunkMap;
-#ifndef PGM_WITHOUT_MAPPINGS
-                    RTGCPTR GCPtrPage  = GCPtrChunk;
-                    for (uint32_t iPage = 0; iPage < cChunkPages && RT_SUCCESS(rc); iPage++, GCPtrPage += PAGE_SIZE)
-                        rc = PGMMap(pVM, GCPtrPage, paChunkPages[iPage].Phys, PAGE_SIZE, 0);
-                }
-                if (RT_FAILURE(rc))
-                {
-                    SUPR3PageFreeEx(pvChunk, cChunkPages);
-                    RTMemTmpFree(paChunkPages);
-                    break;
-                }
-#endif /* !PGM_WITHOUT_MAPPINGS */
-                pNew->RamRange.pSelfRC  = GCPtrChunk + RT_UOFFSETOF(PGMREGMMIORANGE, RamRange);
-            }
             RTMemTmpFree(paChunkPages);
         }
@@ -2834 +2788 @@
             //pNew->RamRange.fFlags = 0;
             pNew->RamRange.pSelfR0  = MMHyperCCToR0(pVM, &pNew->RamRange);
-            pNew->RamRange.pSelfRC  = MMHyperCCToRC(pVM, &pNew->RamRange);
         }
 
@@ -4242 +4195 @@
             {
                 pRamNew->pSelfR0       = MMHyperCCToR0(pVM, pRamNew);
-                pRamNew->pSelfRC       = MMHyperCCToRC(pVM, pRamNew);
                 pRamNew->GCPhys        = GCPhys;
                 pRamNew->GCPhysLast    = GCPhysLast;
@@ -4394 +4346 @@
                         pRomNew->pNextR3 = pRom;
                         pRomNew->pNextR0 = pRom ? MMHyperCCToR0(pVM, pRom) : NIL_RTR0PTR;
-                        pRomNew->pNextRC = pRom ? MMHyperCCToRC(pVM, pRom) : NIL_RTRCPTR;
 
                         if (pRomPrev)
@@ -4400 +4351 @@
                             pRomPrev->pNextR3 = pRomNew;
                             pRomPrev->pNextR0 = MMHyperCCToR0(pVM, pRomNew);
-                            pRomPrev->pNextRC = MMHyperCCToRC(pVM, pRomNew);
                         }
                         else

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

@@ -535 +535 @@
     /** Pointer to next entry. */
     R0PTRTYPE(struct PGMMAPPING *)      pNextR0;
-    /** Pointer to next entry. */
-    RCPTRTYPE(struct PGMMAPPING *)      pNextRC;
     /** Indicate whether this entry is finalized. */
     bool                                fFinalized;
+    bool                                afPadding[7];
     /** Start Virtual address. */
     RTGCPTR                             GCPtr;
@@ -574 +573 @@
         /** The HC virtual address of the two PAE page table. (i.e 1024 entries instead of 512) */
         R3PTRTYPE(PPGMSHWPTPAE)         paPaePTsR3;
-        /** The RC virtual address of the 32-bit page table. */
-        RCPTRTYPE(PX86PT)               pPTRC;
-        /** The RC virtual address of the two PAE page table. */
-        RCPTRTYPE(PPGMSHWPTPAE)         paPaePTsRC;
         /** The R0 virtual address of the 32-bit page table. */
         R0PTRTYPE(PX86PT)               pPTR0;
@@ -605 +600 @@
     /** The PGM_PAGE_HNDL_PHYS_STATE_XXX value corresponding to enmKind. */
     uint32_t                            uState;
-    /** Pointer to RC callback function. */
-    RCPTRTYPE(PFNPGMPHYSHANDLER)        pfnHandlerRC;
-    /** Pointer to RC callback function for \#PFs. */
-    RCPTRTYPE(PFNPGMRZPHYSPFHANDLER)    pfnPfHandlerRC;
     /** Pointer to R3 callback function. */
     R3PTRTYPE(PFNPGMPHYSHANDLER)        pfnHandlerR3;
@@ -651 +642 @@
     /** Registered handler type handle (heap offset). */
     PGMPHYSHANDLERTYPE                  hType;
-    /** User argument for RC handlers. */
-    RCPTRTYPE(void *)                   pvUserRC;
-#if HC_ARCH_BITS == 64
-    RTRCPTR                             Padding0; /**< Explicit alignment padding. */
-#endif
     /** User argument for R3 handlers. */
     R3PTRTYPE(void *)                   pvUserR3;
@@ -1298 +1284 @@
     /** Pointer to the next RAM range - for R0. */
     R0PTRTYPE(struct PGMRAMRANGE *)     pNextR0;
-    /** Pointer to the next RAM range - for RC. */
-    RCPTRTYPE(struct PGMRAMRANGE *)     pNextRC;
     /** PGM_RAM_RANGE_FLAGS_* flags. */
     uint32_t                            fFlags;
+    uint32_t                            fPadding1;
     /** Last address in the range (inclusive). Page aligned (-1). */
     RTGCPHYS                            GCPhysLast;
@@ -1312 +1297 @@
     /** Pointer to self - R0 pointer. */
     R0PTRTYPE(struct PGMRAMRANGE *)     pSelfR0;
-    /** Pointer to self - RC pointer. */
-    RCPTRTYPE(struct PGMRAMRANGE *)     pSelfRC;
-
-    /** Alignment padding. */
-    RTRCPTR                             Alignment0;
+
     /** Pointer to the left search three node - ring-3 context. */
     R3PTRTYPE(struct PGMRAMRANGE *)     pLeftR3;
@@ -1325 +1306 @@
     /** Pointer to the right search three node - ring-0 context. */
     R0PTRTYPE(struct PGMRAMRANGE *)     pRightR0;
-    /** Pointer to the left search three node - raw-mode context. */
-    RCPTRTYPE(struct PGMRAMRANGE *)     pLeftRC;
-    /** Pointer to the right search three node - raw-mode context. */
-    RCPTRTYPE(struct PGMRAMRANGE *)     pRightRC;
 
     /** Padding to make aPage aligned on sizeof(PGMPAGE). */
@@ -1424 +1401 @@
     /** Pointer to the next range - R0. */
     R0PTRTYPE(struct PGMROMRANGE *)     pNextR0;
-    /** Pointer to the next range - RC. */
-    RCPTRTYPE(struct PGMROMRANGE *)     pNextRC;
-    /** Pointer alignment */
-    RTRCPTR                             RCPtrAlignment;
     /** Address of the range. */
     RTGCPHYS                            GCPhys;