Changeset 4917 in vbox

Timestamp:

Sep 20, 2007 10:06:48 AM (18 years ago)

Author:

vboxsync

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

24659

Message:

Don't trigger breakpoints in ring 0. (AssertRelease & co)

Location:

trunk

Files:

• include/VBox/vmm.h (modified) (1 diff)
• include/iprt/assert.h (modified) (2 diffs)
• src/VBox/VMM/PGMHandler.cpp (modified) (2 diffs)
• src/VBox/VMM/PGMInternal.h (modified) (4 diffs)
• src/VBox/VMM/VMM.cpp (modified) (1 diff)
• src/VBox/VMM/VMMAll/PGMAllBth.h (modified) (2 diffs)
• src/VBox/VMM/VMMAll/PGMAllGst.h (modified) (5 diffs)
• src/VBox/VMM/VMMAll/PGMAllHandler.cpp (modified) (4 diffs)
• src/VBox/VMM/VMMAll/PGMAllPool.cpp (modified) (41 diffs)
• src/VBox/VMM/VMMAll/TMAll.cpp (modified) (6 diffs)
• src/VBox/VMM/VMMR0/VMMR0.cpp (modified) (1 diff)

trunk/include/VBox/vmm.h

@@ -91 +91 @@
     /** Set the VM runtime error message. */
     VMMCALLHOST_VM_SET_RUNTIME_ERROR,
+    /** Signal a ring 0 hypervisor assertion. */
+    VMMCALLHOST_VM_R0_HYPER_ASSERTION,
     /** The usual 32-bit hack. */
     VMMCALLHOST_32BIT_HACK = 0x7fffffff

trunk/include/iprt/assert.h

@@ -496 +496 @@
 # endif
 #elif defined(_MSC_VER)
-# define AssertReleaseBreakpoint()      __debugbreak()
+# ifdef IN_VMM_R0
+#  define AssertReleaseBreakpoint()      RTR0AssertBreakpoint(pVM)
+# else
+#  define AssertReleaseBreakpoint()      __debugbreak()
+# endif
 #else
 # error "Unknown compiler"
@@ -1184 +1188 @@
 
 
+/**
+ * Ring 0 VMM breakpoint function.
+ * 
+ * Generates a guru meditation 
+ * 
+ * @remark does not return
+ */
+RTDECL(void)    RTR0AssertBreakpoint(void *pVM);
+
 /** The last assert message, 1st part. */
 extern RTDATADECL(char) g_szRTAssertMsg1[1024];

trunk/src/VBox/VMM/PGMHandler.cpp

@@ -180 +180 @@
 {
     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)pNode;
-    unsigned        fFlags = pgmHandlerPhysicalCalcFlags(pCur);
+    unsigned        fFlags = pgmHandlerPhysicalCalcFlags((PVM)pvUser, pCur);
     PPGMRAMRANGE    pRamHint = NULL;
     RTGCPHYS        GCPhys = pCur->Core.Key;
@@ -434 +434 @@
         for (unsigned iPage = 0; iPage < pCur->cPages; iPage++)
             if (pCur->aPhysToVirt[iPage].offNextAlias & PGMPHYS2VIRTHANDLER_IN_TREE)
-                pgmHandlerVirtualClearPage(pPGM, pCur, iPage);
+                pgmHandlerVirtualClearPage(pVM, pPGM, pCur, iPage);
 
         /*

trunk/src/VBox/VMM/PGMInternal.h

@@ -2872 +2872 @@
  *
  * @returns The ram flags.
- * @param   pCur        The physical handler in question.
- */
-DECLINLINE(unsigned) pgmHandlerPhysicalCalcFlags(PPGMPHYSHANDLER pCur)
+ * @param   pVM     The VM handle.
+ * @param   pCur    The physical handler in question.
+ */
+DECLINLINE(unsigned) pgmHandlerPhysicalCalcFlags(PVM pVM, PPGMPHYSHANDLER pCur)
 {
     switch (pCur->enmType)
@@ -2897 +2898 @@
  * Clears one physical page of a virtual handler
  *
- * @param   pPGM    Pointer to the PGM instance.
+ * @param   pVM     The VM handle.
  * @param   pCur    Virtual handler structure
  * @param   iPage   Physical page index
  */
-DECLINLINE(void) pgmHandlerVirtualClearPage(PPGM pPGM, PPGMVIRTHANDLER pCur, unsigned iPage)
+DECLINLINE(void) pgmHandlerVirtualClearPage(PVM pVM, PPGM pPGM, PPGMVIRTHANDLER pCur, unsigned iPage)
 {
     const PPGMPHYS2VIRTHANDLER pPhys2Virt = &pCur->aPhysToVirt[iPage];
@@ -3000 +3001 @@
  *
  * @returns Pointer to the shadow page structure.
+ * @param   pVM         The VM handle.
  * @param   pPool       The pool.
  * @param   HCPhys      The HC physical address of the shadow page.
  */
-DECLINLINE(PPGMPOOLPAGE) pgmPoolGetPage(PPGMPOOL pPool, RTHCPHYS HCPhys)
+DECLINLINE(PPGMPOOLPAGE) pgmPoolGetPage(PVM pVM, PPGMPOOL pPool, RTHCPHYS HCPhys)
 {
     /*
@@ -3018 +3020 @@
  *
  * @returns Pointer to the shadow page structure.
+ * @param   pVM         The VM handle.
  * @param   pPool       The pool.
  * @param   idx         The pool page index.
  */
-DECLINLINE(PPGMPOOLPAGE) pgmPoolGetPageByIdx(PPGMPOOL pPool, unsigned idx)
+DECLINLINE(PPGMPOOLPAGE) pgmPoolGetPageByIdx(PVM pVM, PPGMPOOL pPool, unsigned idx)
 {
     AssertFatalMsg(idx >= PGMPOOL_IDX_FIRST && idx < pPool->cCurPages, ("idx=%d\n", idx));

trunk/src/VBox/VMM/VMM.cpp

@@ -2233 +2233 @@
             break;
 
+        /*
+         * Signal a ring 0 hypervisor assertion.
+         */
+        case VMMCALLHOST_VM_R0_HYPER_ASSERTION:
+            return VINF_EM_DBG_HYPER_ASSERTION;
+
         default:
             AssertMsgFailed(("enmCallHostOperation=%d\n", pVM->vmm.s.enmCallHostOperation));

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

@@ -2673 +2673 @@
                 if (PdeDst.n.u1Present)
                 {
-                    PPGMPOOLPAGE pShwPage = pgmPoolGetPage(pPool, PdeDst.u & SHW_PDE_PG_MASK);
+                    PPGMPOOLPAGE pShwPage = pgmPoolGetPage(pVM, pPool, PdeDst.u & SHW_PDE_PG_MASK);
                     RTGCPHYS     GCPhys;
                     if (    !PdeSrc.b.u1Size
@@ -2753 +2753 @@
                 if (pPDEDst->n.u1Present)
                 {
-                    pgmPoolFreeByPage(pPool, pgmPoolGetPage(pPool, pPDEDst->u & SHW_PDE_PG_MASK), SHW_POOL_ROOT_IDX, iPdShw);
+                    pgmPoolFreeByPage(pPool, pgmPoolGetPage(pVM, pPool, pPDEDst->u & SHW_PDE_PG_MASK), SHW_POOL_ROOT_IDX, iPdShw);
                     pPDEDst->u = 0;
                     MY_STAM_COUNTER_INC(&pVM->pgm.s.CTXMID(Stat,SyncCR3DstFreedSrcNP));

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

@@ -609 +609 @@
     PPGMVIRTHANDLER pCur  = (PPGMVIRTHANDLER)pNode;
     PPGMHVUSTATE    pState = (PPGMHVUSTATE)pvUser;
+    PVM             pVM = pState->pVM;
 
 #if PGM_GST_TYPE == PGM_TYPE_32BIT
-    PX86PD          pPDSrc = pState->pVM->pgm.s.CTXSUFF(pGuestPD);
+    PX86PD          pPDSrc = pVM->pgm.s.CTXSUFF(pGuestPD);
 #endif
 
@@ -667 +668 @@
                         {
                             if (pCur->aPhysToVirt[iPage].Core.Key != NIL_RTGCPHYS)
-                                pgmHandlerVirtualClearPage(&pState->pVM->pgm.s, pCur, iPage);
+                                pgmHandlerVirtualClearPage(pState->pVM, &pState->pVM->pgm.s, pCur, iPage);
 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
                             AssertReleaseMsg(!pCur->aPhysToVirt[iPage].offNextAlias,
@@ -690 +691 @@
                         if (pCur->aPhysToVirt[iPage].Core.Key != NIL_RTGCPHYS)
                         {
-                            pgmHandlerVirtualClearPage(&pState->pVM->pgm.s, pCur, iPage);
+                            pgmHandlerVirtualClearPage(pState->pVM, &pState->pVM->pgm.s, pCur, iPage);
 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
                             AssertReleaseMsg(!pCur->aPhysToVirt[iPage].offNextAlias,
@@ -717 +718 @@
                     {
                         if (pCur->aPhysToVirt[iPage].Core.Key != NIL_RTGCPHYS)
-                            pgmHandlerVirtualClearPage(&pState->pVM->pgm.s, pCur, iPage);
+                            pgmHandlerVirtualClearPage(pState->pVM, &pState->pVM->pgm.s, pCur, iPage);
 #ifdef VBOX_STRICT_PGM_HANDLER_VIRTUAL
                         AssertReleaseMsg(!pCur->aPhysToVirt[iPage].offNextAlias,
@@ -739 +740 @@
                 if (pCur->aPhysToVirt[iPage].Core.Key != NIL_RTGCPHYS)
                 {
-                    pgmHandlerVirtualClearPage(&pState->pVM->pgm.s, pCur, iPage);
+                    pgmHandlerVirtualClearPage(pState->pVM, &pState->pVM->pgm.s, pCur, iPage);
                     pCur->aPhysToVirt[iPage].Core.Key = NIL_RTGCPHYS;
                     pState->fTodo |= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;

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

@@ -45 +45 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-DECLINLINE(unsigned) pgmHandlerPhysicalCalcFlags(PPGMPHYSHANDLER pCur);
 static int pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(PVM pVM, PPGMPHYSHANDLER pCur, PPGMRAMRANGE pRam);
 static void pgmHandlerPhysicalDeregisterNotifyREM(PVM pVM, PPGMPHYSHANDLER pCur);
@@ -234 +233 @@
     const int       rc = VINF_PGM_GCPHYS_ALIASED;
 #endif
-    const unsigned  fFlags = pgmHandlerPhysicalCalcFlags(pCur); Assert(!(fFlags & X86_PTE_PAE_PG_MASK));
+    const unsigned  fFlags = pgmHandlerPhysicalCalcFlags(pVM, pCur); Assert(!(fFlags & X86_PTE_PAE_PG_MASK));
     RTUINT          cPages = pCur->cPages;
     RTUINT          i = (pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT;
@@ -433 +432 @@
                 ||  (pBelow->Core.KeyLast >> PAGE_SHIFT) != (pCur->Core.Key >> PAGE_SHIFT))
                 break;
-            pgmRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pCur), &pRamHint);
+            pgmRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pVM, pCur), &pRamHint);
 
             /* next? */
@@ -455 +454 @@
                 ||  (pAbove->Core.Key >> PAGE_SHIFT) != (pCur->Core.KeyLast >> PAGE_SHIFT))
                 break;
-            pgmRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pCur), &pRamHint);
+            pgmRamFlagsSetByGCPhysWithHint(pPGM, GCPhys, pgmHandlerPhysicalCalcFlags(pVM, pCur), &pRamHint);
 
             /* next? */

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

@@ -43 +43 @@
 static void pgmPoolFlushAllInt(PPGMPOOL pPool);
 #ifdef PGMPOOL_WITH_USER_TRACKING
-DECLINLINE(unsigned) pgmPoolTrackGetShadowEntrySize(PGMPOOLKIND enmKind);
-DECLINLINE(unsigned) pgmPoolTrackGetGuestEntrySize(PGMPOOLKIND enmKind);
+DECLINLINE(unsigned) pgmPoolTrackGetShadowEntrySize(PVM pVM, PGMPOOLKIND enmKind);
+DECLINLINE(unsigned) pgmPoolTrackGetGuestEntrySize(PVM pVM, PGMPOOLKIND enmKind);
 static void pgmPoolTrackDeref(PPGMPOOL pPool, PPGMPOOLPAGE pPage);
 #endif
@@ -203 +203 @@
 
 #elif defined(IN_RING0)
+    PVM   pVM = pPool->CTXSUFF(pVM);
     void *pvRet;
+
     int rc = pgmRamGCPhys2HCPtr(&pPool->pVMHC->pgm.s, GCPhysFault & ~(RTGCPHYS)(cbEntry - 1), &pvRet);
     AssertFatalRCSuccess(rc);
@@ -236 +238 @@
 #endif
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     Assert(pPage->iMonitoredPrev == NIL_PGMPOOL_IDX);
     const unsigned off = GCPhysFault & PAGE_OFFSET_MASK;
@@ -248 +252 @@
             PX86PDPAE   pPDPae;
         } uShw;
-        uShw.pv = PGMPOOL_PAGE_2_PTR(pPool->CTXSUFF(pVM), pPage);
+        uShw.pv = PGMPOOL_PAGE_2_PTR(pVM, pPage);
 
         switch (pPage->enmKind)
@@ -310 +314 @@
                 if (uShw.pPD->a[iShw].u & PGM_PDFLAGS_MAPPING)
                 {
-                    Assert(pgmMapAreMappingsEnabled(&pPool->CTXSUFF(pVM)->pgm.s));
-                    VM_FF_SET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3);
+                    Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
+                    VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
                     LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw=%#x!\n", iShw));
                 }
@@ -324 +328 @@
                         &&  uShw.pPD->a[iShw2].u & PGM_PDFLAGS_MAPPING)
                     {
-                        Assert(pgmMapAreMappingsEnabled(&pPool->CTXSUFF(pVM)->pgm.s));
-                        VM_FF_SET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3);
+                        Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
+                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
                         LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw2=%#x!\n", iShw2));
                     }
@@ -331 +335 @@
 #if 0 /* useful when running PGMAssertCR3(), a bit too troublesome for general use (TLBs). */
                 if (    uShw.pPD->a[iShw].n.u1Present
-                    &&  !VM_FF_ISSET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3))
+                    &&  !VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
                 {
                     LogFlow(("pgmPoolMonitorChainChanging: iShw=%#x: %RX32 -> freeing it!\n", iShw, uShw.pPD->a[iShw].u));
@@ -337 +341 @@
                     ASMProbeReadByte(pvAddress);
 # endif
-                    pgmPoolFree(pPool->CTXSUFF(pVM), uShw.pPD->a[iShw].u & X86_PDE_PG_MASK, pPage->idx, iShw);
+                    pgmPoolFree(pVM, uShw.pPD->a[iShw].u & X86_PDE_PG_MASK, pPage->idx, iShw);
                     uShw.pPD->a[iShw].u = 0;
                 }
@@ -351 +355 @@
                     if ((uShw.pPDPae->a[iShw].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
                     {
-                        Assert(pgmMapAreMappingsEnabled(&pPool->CTXSUFF(pVM)->pgm.s));
-                        VM_FF_SET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3);
+                        Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
+                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
                         LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw=%#x!\n", iShw));
                     }
@@ -364 +368 @@
                             &&  (uShw.pPDPae->a[iShw2].u & (PGM_PDFLAGS_MAPPING | X86_PDE_P)) == (PGM_PDFLAGS_MAPPING | X86_PDE_P))
                         {
-                            Assert(pgmMapAreMappingsEnabled(&pPool->CTXSUFF(pVM)->pgm.s));
-                            VM_FF_SET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3);
+                            Assert(pgmMapAreMappingsEnabled(&pVM->pgm.s));
+                            VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
                             LogFlow(("pgmPoolMonitorChainChanging: Detected conflict at iShw2=%#x!\n", iShw2));
                         }
@@ -371 +375 @@
 #if 0 /* useful when running PGMAssertCR3(), a bit too troublesome for general use (TLBs). */
                     if (    uShw.pPDPae->a[iShw].n.u1Present
-                        &&  !VM_FF_ISSET(pPool->CTXSUFF(pVM), VM_FF_PGM_SYNC_CR3))
+                        &&  !VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
                     {
                         LogFlow(("pgmPoolMonitorChainChanging: iShw=%#x: %RX64 -> freeing it!\n", iShw, uShw.pPDPae->a[iShw].u));
@@ -377 +381 @@
                         ASMProbeReadByte(pvAddress);
 # endif
-                        pgmPoolFree(pPool->CTXSUFF(pVM), uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, pPage->idx, iShw);
+                        pgmPoolFree(pVM, uShw.pPDPae->a[iShw].u & X86_PDE_PAE_PG_MASK, pPage->idx, iShw);
                         uShw.pPDPae->a[iShw].u = 0;
                     }
@@ -781 +785 @@
 DECLINLINE(void) pgmPoolHashRemove(PPGMPOOL pPool, PPGMPOOLPAGE pPage)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     uint16_t iHash = PGMPOOL_HASH(pPage->GCPhys);
     if (pPool->aiHash[iHash] == pPage->idx)
@@ -818 +824 @@
 static int pgmPoolCacheFreeOne(PPGMPOOL pPool, uint16_t iUser)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     Assert(pPool->iAgeHead != pPool->iAgeTail); /* We shouldn't be here if there < 2 cached entries! */
     STAM_COUNTER_INC(&pPool->StatCacheFreeUpOne);
@@ -856 +864 @@
  * @returns true if reused and the cached page (enmKind1) should be flushed
  * @returns false if not reused.
+ * @param   pVM         The VM handle.
  * @param   enmKind1    The kind of the cached page.
  * @param   enmKind2    The kind of the requested page.
  */
-static bool pgmPoolCacheReusedByKind(PGMPOOLKIND enmKind1, PGMPOOLKIND enmKind2)
+static bool pgmPoolCacheReusedByKind(PVM pVM, PGMPOOLKIND enmKind1, PGMPOOLKIND enmKind2)
 {
     switch (enmKind1)
@@ -942 +951 @@
 static int pgmPoolCacheAlloc(PPGMPOOL pPool, RTGCPHYS GCPhys, PGMPOOLKIND enmKind, uint16_t iUser, uint16_t iUserTable, PPPGMPOOLPAGE ppPage)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Look up the GCPhys in the hash.
@@ -971 +982 @@
                  * different way than the other kinds.
                  */
-                if (pgmPoolCacheReusedByKind((PGMPOOLKIND)pPage->enmKind, enmKind))
+                if (pgmPoolCacheReusedByKind(pVM, (PGMPOOLKIND)pPage->enmKind, enmKind))
                 {
                     STAM_COUNTER_INC(&pPool->StatCacheKindMismatches);
@@ -1080 +1091 @@
 {
 #ifdef PGMPOOL_WITH_CACHE
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Look up the GCPhys in the hash.
@@ -1145 +1158 @@
 static int pgmPoolMonitorInsert(PPGMPOOL pPool, PPGMPOOLPAGE pPage)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Filter out the relevant kinds.
@@ -1196 +1211 @@
     {
         Assert(pPage->iMonitoredNext == NIL_PGMPOOL_IDX); Assert(pPage->iMonitoredPrev == NIL_PGMPOOL_IDX);
-        PVM pVM = pPool->CTXSUFF(pVM);
         const RTGCPHYS GCPhysPage = pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1);
         rc = PGMHandlerPhysicalRegisterEx(pVM, PGMPHYSHANDLERTYPE_PHYSICAL_WRITE,
@@ -1226 +1240 @@
 static int pgmPoolMonitorFlush(PPGMPOOL pPool, PPGMPOOLPAGE pPage)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Filter out the relevant kinds.
@@ -1261 +1277 @@
      * Remove the page from the monitored list or uninstall it if last.
      */
-    const PVM pVM = pPool->CTXSUFF(pVM);
     int rc;
     if (    pPage->iMonitoredNext != NIL_PGMPOOL_IDX
@@ -1354 +1369 @@
 int pgmPoolMonitorMonitorCR3(PPGMPOOL pPool, uint16_t idxRoot, RTGCPHYS GCPhysCR3)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     Assert(idxRoot != NIL_PGMPOOL_IDX && idxRoot < PGMPOOL_IDX_FIRST);
     PPGMPOOLPAGE pPage = &pPool->aPages[idxRoot];
@@ -1409 +1426 @@
 int pgmPoolMonitorUnmonitorCR3(PPGMPOOL pPool, uint16_t idxRoot)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     Assert(idxRoot != NIL_PGMPOOL_IDX && idxRoot < PGMPOOL_IDX_FIRST);
     PPGMPOOLPAGE pPage = &pPool->aPages[idxRoot];
@@ -1851 +1870 @@
 static void pgmPoolTrackFreeUser(PPGMPOOL pPool, PPGMPOOLPAGE pPage, uint16_t iUser, uint16_t iUserTable)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Unlink and free the specified user entry.
@@ -1900 +1921 @@
  * Gets the entry size of a shadow table.
  *
- * @param enmKind
- *          The kind of page.
+ * @param   pVM         The VM handle.
+ * @param   enmKind     The kind of page.
  *
  * @returns The size of the entry in bytes. That is, 4 or 8.
@@ -1907 +1928 @@
  *          returned.
  */
-DECLINLINE(unsigned) pgmPoolTrackGetShadowEntrySize(PGMPOOLKIND enmKind)
+DECLINLINE(unsigned) pgmPoolTrackGetShadowEntrySize(PVM pVM, PGMPOOLKIND enmKind)
 {
     switch (enmKind)
@@ -1939 +1960 @@
  * Gets the entry size of a guest table.
  *
- * @param enmKind
- *          The kind of page.
+ * @param   pVM         The VM handle.
+ * @param   enmKind     The kind of page.
  *
  * @returns The size of the entry in bytes. That is, 0, 4 or 8.
@@ -1946 +1967 @@
  *          returned.
  */
-DECLINLINE(unsigned) pgmPoolTrackGetGuestEntrySize(PGMPOOLKIND enmKind)
+DECLINLINE(unsigned) pgmPoolTrackGetGuestEntrySize(PVM pVM, PGMPOOLKIND enmKind)
 {
     switch (enmKind)
@@ -2250 +2271 @@
         uint32_t       *pau32;
     } u;
-    u.pau64 = (uint64_t *)PGMPOOL_PAGE_2_PTR(pPool->CTXSUFF(pVM), pUserPage);
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
+    u.pau64 = (uint64_t *)PGMPOOL_PAGE_2_PTR(pVM, pUserPage);
 
 #ifdef VBOX_STRICT
@@ -2524 +2547 @@
 {
     const unsigned cRefs = pPhysPage->HCPhys >> MM_RAM_FLAGS_CREFS_SHIFT; /** @todo PAGE FLAGS */
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     AssertFatalMsg(cRefs == MM_RAM_FLAGS_CREFS_PHYSEXT, ("cRefs=%d HCPhys=%RHp pPage=%p:{.idx=%d}\n", cRefs, pPhysPage->HCPhys, pPage, pPage->idx));
 
@@ -2552 +2577 @@
 
                     /* we can free the node. */
-                    PVM pVM = pPool->CTXSUFF(pVM);
                     const uint16_t iPhysExtNext = paPhysExts[iPhysExt].iNext;
                     if (    iPhysExtPrev == NIL_PGMPOOL_PHYSEXT_INDEX
@@ -2610 +2634 @@
 static void pgmPoolTracDerefGCPhys(PPGMPOOL pPool, PPGMPOOLPAGE pPage, RTHCPHYS HCPhys, RTGCPHYS GCPhys)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
     /*
      * Walk range list.
      */
-    PPGMRAMRANGE pRam = pPool->CTXSUFF(pVM)->pgm.s.CTXSUFF(pRamRanges);
+    PPGMRAMRANGE pRam = pVM->pgm.s.CTXSUFF(pRamRanges);
     while (pRam)
     {
@@ -2645 +2670 @@
 static void pgmPoolTracDerefGCPhysHint(PPGMPOOL pPool, PPGMPOOLPAGE pPage, RTHCPHYS HCPhys, RTGCPHYS GCPhysHint)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
     /*
      * Walk range list.
      */
-    PPGMRAMRANGE pRam = pPool->CTXSUFF(pVM)->pgm.s.CTXSUFF(pRamRanges);
+    PPGMRAMRANGE pRam = pVM->pgm.s.CTXSUFF(pRamRanges);
     while (pRam)
     {
@@ -2671 +2697 @@
      */
     STAM_COUNTER_INC(&pPool->StatTrackLinearRamSearches);
-    pRam = pPool->CTXSUFF(pVM)->pgm.s.CTXSUFF(pRamRanges);
+    pRam = pVM->pgm.s.CTXSUFF(pRamRanges);
     while (pRam)
     {
@@ -2804 +2830 @@
 DECLINLINE(void) pgmPoolTrackDerefPDPae(PPGMPOOL pPool, PPGMPOOLPAGE pPage, PX86PDPAE pShwPD)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     for (unsigned i = 0; i < ELEMENTS(pShwPD->a); i++)
     {
@@ -2828 +2856 @@
 DECLINLINE(void) pgmPoolTrackDerefPDPTR64Bit(PPGMPOOL pPool, PPGMPOOLPAGE pPage, PX86PDPTR pShwPdPtr)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     for (unsigned i = 0; i < ELEMENTS(pShwPdPtr->a); i++)
     {
@@ -2853 +2883 @@
 static void pgmPoolTrackDeref(PPGMPOOL pPool, PPGMPOOLPAGE pPage)
 {
+    const PVM pVM = pPool->CTXSUFF(pVM);
+
     /*
      * Map the shadow page and take action according to the page kind.
@@ -3143 +3175 @@
         if (pPage->fMonitored)
         {
-            PVM pVM = pPool->CTXSUFF(pVM);
+            const PVM pVM = pPool->CTXSUFF(pVM);
             int rc = PGMHandlerPhysicalChangeCallbacks(pVM, pPage->GCPhys & ~(RTGCPHYS)(PAGE_SIZE - 1),
                                                        pPool->pfnAccessHandlerR3, MMHyperCCToR3(pVM, pPage),
@@ -3463 +3495 @@
     LogFlow(("pgmPoolFree: HCPhys=%VHp iUser=%#x iUserTable=%#x\n", HCPhys, iUser, iUserTable));
     PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
-    pgmPoolFreeByPage(pPool, pgmPoolGetPage(pPool, HCPhys), iUser, iUserTable);
+    pgmPoolFreeByPage(pPool, pgmPoolGetPage(pVM, pPool, HCPhys), iUser, iUserTable);
 }
 
@@ -3479 +3511 @@
     /** @todo profile this! */
     PPGMPOOL pPool = pVM->pgm.s.CTXSUFF(pPool);
-    PPGMPOOLPAGE pPage = pgmPoolGetPage(pPool, HCPhys);
+    PPGMPOOLPAGE pPage = pgmPoolGetPage(pVM, pPool, HCPhys);
     Log3(("pgmPoolGetPageByHCPhys: HCPhys=%VHp -> %p:{.idx=%d .GCPhys=%VGp .enmKind=%d}\n",
           HCPhys, pPage, pPage->idx, pPage->GCPhys, pPage->enmKind));

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

@@ -696 +696 @@
 TMDECL(uint64_t) TMTimerToNano(PTMTIMER pTimer, uint64_t u64Ticks)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {
@@ -729 +731 @@
 TMDECL(uint64_t) TMTimerToMicro(PTMTIMER pTimer, uint64_t u64Ticks)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {
@@ -762 +766 @@
 TMDECL(uint64_t) TMTimerToMilli(PTMTIMER pTimer, uint64_t u64Ticks)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {
@@ -794 +800 @@
 TMDECL(uint64_t) TMTimerFromNano(PTMTIMER pTimer, uint64_t u64NanoTS)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {
@@ -826 +834 @@
 TMDECL(uint64_t) TMTimerFromMicro(PTMTIMER pTimer, uint64_t u64MicroTS)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {
@@ -858 +868 @@
 TMDECL(uint64_t) TMTimerFromMilli(PTMTIMER pTimer, uint64_t u64MilliTS)
 {
+    PVM pVM = pTimer->CTXALLSUFF(pVM);  NOREF(pVM);
+
     switch (pTimer->enmClock)
     {

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

@@ -943 +943 @@
 # define LOG_GROUP LOG_GROUP_EM
 
+DECLEXPORT(void) RTCALL RTR0AssertBreakpoint(void *pvVM)
+{
+    if (pvVM)
+    {
+        PVM pVM = (PVM)pvVM;
+        pVM->vmm.s.enmCallHostOperation = VMMCALLHOST_VM_R0_HYPER_ASSERTION;
+        pVM->vmm.s.u64CallHostArg = 0;
+        pVM->vmm.s.rcCallHost = VERR_INTERNAL_ERROR;
+        int rc = vmmR0CallHostLongJmp(&pVM->vmm.s.CallHostR0JmpBuf, VERR_INTERNAL_ERROR);
+        if (rc == VINF_SUCCESS)
+            rc = pVM->vmm.s.rcCallHost;
+    }
+}
+
 /** Runtime assert implementation for Native Win32 Ring-0. */
 DECLEXPORT(void) RTCALL AssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction)