Changeset 20663 in vbox for trunk/src/VBox/VMM

Timestamp:

Jun 17, 2009 12:47:55 PM (16 years ago)

Author:

vboxsync

Message:

VMM: Added VMMR3EmtRendezvous for getting the attention of all EMTs and run some code on one. Made first use of it in vmR3SetHaltMethodU that is called at the end of VMR3CreateVM.

Location:

trunk/src/VBox/VMM

Files:

• EM.cpp (modified) (6 diffs)
• VMEmt.cpp (modified) (4 diffs)
• VMM.cpp (modified) (7 diffs)
• VMMInternal.h (modified) (1 diff)
• testcase/tstVMStructGC.cpp (modified) (2 diffs)

trunk/src/VBox/VMM/EM.cpp

@@ -3320 +3320 @@
     {
         /*
+         * EMT Rendezvous (must be serviced before termination).
+         */
+        if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
+            VMMR3EmtRendezvousFF(pVM, pVCpu);
+
+        /*
          * Termination request.
          */
@@ -3374 +3380 @@
 
         /* check that we got them all  */
-        AssertCompile(VM_FF_NORMAL_PRIORITY_POST_MASK == (VM_FF_TERMINATE | VM_FF_DBGF | VM_FF_RESET | VM_FF_PGM_NO_MEMORY));
+        AssertCompile(VM_FF_NORMAL_PRIORITY_POST_MASK == (VM_FF_TERMINATE | VM_FF_DBGF | VM_FF_RESET | VM_FF_PGM_NO_MEMORY | VM_FF_EMT_RENDEZVOUS));
         AssertCompile(VMCPU_FF_NORMAL_PRIORITY_POST_MASK == VMCPU_FF_CSAM_SCAN_PAGE);
     }
@@ -3395 +3401 @@
         if (VM_FF_IS_PENDING_EXCEPT(pVM, VM_FF_PDM_DMA, VM_FF_PGM_NO_MEMORY))
             PDMR3DmaRun(pVM);
+
+        /*
+         * EMT Rendezvous (make sure they are handled before the requests).
+         */
+        if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
+            VMMR3EmtRendezvousFF(pVM, pVCpu);
 
         /*
@@ -3421 +3433 @@
 
         /* check that we got them all  */
-        AssertCompile(VM_FF_NORMAL_PRIORITY_MASK == (VM_FF_REQUEST | VM_FF_PDM_QUEUES | VM_FF_PDM_DMA | VM_FF_REM_HANDLER_NOTIFY));
+        AssertCompile(VM_FF_NORMAL_PRIORITY_MASK == (VM_FF_REQUEST | VM_FF_PDM_QUEUES | VM_FF_PDM_DMA | VM_FF_REM_HANDLER_NOTIFY | VM_FF_EMT_RENDEZVOUS));
     }
 
@@ -3536 +3548 @@
 
         /*
+         * EMT Rendezvous (must be serviced before termination).
+         */
+        if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
+            VMMR3EmtRendezvousFF(pVM, pVCpu);
+
+        /*
          * Termination request.
          */
@@ -3578 +3596 @@
 
         /* check that we got them all  */
-        AssertCompile(VM_FF_HIGH_PRIORITY_PRE_MASK == (VM_FF_TM_VIRTUAL_SYNC | VM_FF_DBGF | VM_FF_TERMINATE | VM_FF_DEBUG_SUSPEND | VM_FF_PGM_NEED_HANDY_PAGES | VM_FF_PGM_NO_MEMORY));
+        AssertCompile(VM_FF_HIGH_PRIORITY_PRE_MASK == (VM_FF_TM_VIRTUAL_SYNC | VM_FF_DBGF | VM_FF_TERMINATE | VM_FF_DEBUG_SUSPEND | VM_FF_PGM_NEED_HANDY_PAGES | VM_FF_PGM_NO_MEMORY | VM_FF_EMT_RENDEZVOUS));
         AssertCompile(VMCPU_FF_HIGH_PRIORITY_PRE_MASK == (VMCPU_FF_TIMER | VMCPU_FF_INTERRUPT_APIC | VMCPU_FF_INTERRUPT_PIC | VMCPU_FF_PGM_SYNC_CR3 | VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL | VMCPU_FF_SELM_SYNC_TSS | VMCPU_FF_TRPM_SYNC_IDT | VMCPU_FF_SELM_SYNC_GDT | VMCPU_FF_SELM_SYNC_LDT | VMCPU_FF_INHIBIT_INTERRUPTS));
     }

trunk/src/VBox/VMM/VMEmt.cpp

@@ -155 +155 @@
                 break;
             }
+            if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
+                VMMR3EmtRendezvousFF(pVM, &pVM->aCpus[idCpu]);
             if (pUVM->vm.s.pReqs)
             {
@@ -203 +205 @@
             if (    rc == VINF_EM_TERMINATE
                 ||  pUVM->vm.s.fTerminateEMT
-                ||  (   pUVM->pVM
+                ||  (   pUVM->pVM /* pVM may have become invalid by now. */
                      && VM_FF_ISSET(pUVM->pVM, VM_FF_TERMINATE)))
                 break;
@@ -1086 +1088 @@
 
 /**
+ * Rendezvous callback that will be called once.
+ *
+ * @returns VBox status code.
+ * @param   pVM                 VM handle.
+ * @param   pVCpu               The VMCPU handle for the calling EMT.
+ * @param   pvUser              The new g_aHaltMethods index.
+ */
+static DECLCALLBACK(int) vmR3SetHaltMethodCallback(PVM pVM, PVMCPU pVCpu, void *pvUser)
+{
+    PUVM        pUVM = pVM->pUVM;
+    uintptr_t   i    = (uintptr_t)pvUser;
+    Assert(i < RT_ELEMENTS(g_aHaltMethods));
+    NOREF(pVCpu);
+
+    /*
+     * Terminate the old one.
+     */
+    if (    pUVM->vm.s.enmHaltMethod != VMHALTMETHOD_INVALID
+        &&  g_aHaltMethods[pUVM->vm.s.iHaltMethod].pfnTerm)
+    {
+        g_aHaltMethods[pUVM->vm.s.iHaltMethod].pfnTerm(pUVM);
+        pUVM->vm.s.enmHaltMethod = VMHALTMETHOD_INVALID;
+    }
+
+    /* Assert that the failure fallback is where we expect. */
+    Assert(g_aHaltMethods[0].enmHaltMethod == VMHALTMETHOD_BOOTSTRAP);
+    Assert(!g_aHaltMethods[0].pfnTerm && !g_aHaltMethods[0].pfnInit);
+
+    /*
+     * Init the new one.
+     */
+    int rc = VINF_SUCCESS;
+    memset(&pUVM->vm.s.Halt, 0, sizeof(pUVM->vm.s.Halt));
+    if (g_aHaltMethods[i].pfnInit)
+    {
+        rc = g_aHaltMethods[i].pfnInit(pUVM);
+        if (RT_FAILURE(rc))
+        {
+            /* Fall back on the bootstrap method. This requires no
+               init/term (see assertion above), and will always work. */
+            AssertLogRelRC(rc);
+            i = 0;
+        }
+    }
+
+    /*
+     * Commit it.
+     */
+    pUVM->vm.s.enmHaltMethod = g_aHaltMethods[i].enmHaltMethod;
+    ASMAtomicWriteU32(&pUVM->vm.s.iHaltMethod, i);
+
+    return rc;
+}
+
+
+/**
  * Changes the halt method.
  *
@@ -1131 +1189 @@
 
     /*
-     * Terminate the old one.
-     */
-    if (    pUVM->vm.s.enmHaltMethod != VMHALTMETHOD_INVALID
-        &&  g_aHaltMethods[pUVM->vm.s.iHaltMethod].pfnTerm)
-    {
-        g_aHaltMethods[pUVM->vm.s.iHaltMethod].pfnTerm(pUVM);
-        pUVM->vm.s.enmHaltMethod = VMHALTMETHOD_INVALID;
-    }
-
-/** @todo SMP: Need rendezvous thing here, the other EMTs must not be
- *        sleeping when we switch the notification method or we'll never
- *        manage to wake them up properly and end up relying on timeouts... */
-
-    /*
-     * Init the new one.
-     */
-    memset(&pUVM->vm.s.Halt, 0, sizeof(pUVM->vm.s.Halt));
-    if (g_aHaltMethods[i].pfnInit)
-    {
-        int rc = g_aHaltMethods[i].pfnInit(pUVM);
-        AssertRCReturn(rc, rc);
-    }
-    pUVM->vm.s.enmHaltMethod = enmHaltMethod;
-
-    ASMAtomicWriteU32(&pUVM->vm.s.iHaltMethod, i);
-    return VINF_SUCCESS;
-}
-
+     * This needs to be done while the other EMTs are not sleeping or otherwise messing around.
+     */
+    return VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, vmR3SetHaltMethodCallback, (void *)(uintptr_t)i);
+}
+

trunk/src/VBox/VMM/VMM.cpp

@@ -88 +88 @@
 #include <iprt/asm.h>
 #include <iprt/time.h>
+#include <iprt/semaphore.h>
 #include <iprt/stream.h>
 #include <iprt/string.h>
@@ -136 +137 @@
      */
     pVM->vmm.s.offVM = RT_OFFSETOF(VM, vmm);
+    pVM->vmm.s.hEvtRendezvousEnterOneByOne      = NIL_RTSEMEVENT;
+    pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce  = NIL_RTSEMEVENTMULTI;
+    pVM->vmm.s.hEvtMulRendezvousDone            = NIL_RTSEMEVENTMULTI;
+    pVM->vmm.s.hEvtRendezvousDoneCaller         = NIL_RTSEMEVENT;
     int rc = CFGMR3QueryU32(CFGMR3GetRoot(pVM), "YieldEMTInterval", &pVM->vmm.s.cYieldEveryMillies);
     if (rc == VERR_CFGM_VALUE_NOT_FOUND)
@@ -144 +149 @@
 
     /*
-     * Initialize the VMM sync critical section.
+     * Initialize the VMM sync critical section and semaphores.
      */
     rc = RTCritSectInit(&pVM->vmm.s.CritSectSync);
+    AssertRCReturn(rc, rc);
+    rc = RTSemEventCreate(&pVM->vmm.s.hEvtRendezvousEnterOneByOne);
+    AssertRCReturn(rc, rc);
+    rc = RTSemEventMultiCreate(&pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce);
+    AssertRCReturn(rc, rc);
+    rc = RTSemEventMultiCreate(&pVM->vmm.s.hEvtMulRendezvousDone);
+    AssertRCReturn(rc, rc);
+    rc = RTSemEventCreate(&pVM->vmm.s.hEvtRendezvousDoneCaller);
     AssertRCReturn(rc, rc);
 
@@ -649 +662 @@
 
     RTCritSectDelete(&pVM->vmm.s.CritSectSync);
+    RTSemEventDestroy(pVM->vmm.s.hEvtRendezvousEnterOneByOne);
+    pVM->vmm.s.hEvtRendezvousEnterOneByOne = NIL_RTSEMEVENT;
+    RTSemEventMultiDestroy(pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce);
+    pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce = NIL_RTSEMEVENTMULTI;
+    RTSemEventMultiDestroy(pVM->vmm.s.hEvtMulRendezvousDone);
+    pVM->vmm.s.hEvtMulRendezvousDone = NIL_RTSEMEVENTMULTI;
+    RTSemEventDestroy(pVM->vmm.s.hEvtRendezvousDoneCaller);
+    pVM->vmm.s.hEvtRendezvousDoneCaller = NIL_RTSEMEVENT;
 
 #ifdef VBOX_STRICT_VMM_STACK
@@ -1298 +1319 @@
  * @param   pfnHandler  Callback handler
  * @param   pvUser      User specified parameter
+ *
+ * @thread EMT
  */
 VMMR3DECL(int) VMMR3AtomicExecuteHandler(PVM pVM, PFNATOMICHANDLER pfnHandler, void *pvUser)
@@ -1325 +1348 @@
     rc = pfnHandler(pVM, pvUser);
     RTCritSectLeave(&pVM->vmm.s.CritSectSync);
+    return rc;
+}
+
+
+/**
+ * Count returns and have the last non-caller EMT wake up the caller.
+ *
+ * @param   pVM                 The VM handle.
+ */
+DECL_FORCE_INLINE(void) vmmR3EmtRendezvousNonCallerReturn(PVM pVM)
+{
+    uint32_t cReturned = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsReturned);
+    if (cReturned == pVM->cCPUs - 1U)
+    {
+        int rc = RTSemEventSignal(pVM->vmm.s.hEvtRendezvousDoneCaller);
+        AssertLogRelRC(rc);
+    }
+}
+
+
+/**
+ * Common worker for VMMR3EmtRendezvous and VMMR3EmtRendezvousFF.
+ *
+ * @param   pVM                 The VM handle.
+ * @param   pVCpu               The VMCPU structure for the calling EMT.
+ * @param   fIsCaller           Whether we're the VMMR3EmtRendezvous caller or
+ *                              not.
+ * @param   fFlags              The flags.
+ * @param   pfnRendezvous       The callback.
+ * @param   pvUser              The user argument for the callback.
+ */
+static void vmmR3EmtRendezvousCommon(PVM pVM, PVMCPU pVCpu, bool fIsCaller,
+                                     uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser)
+{
+    int rc;
+
+    /*
+     * Enter, the last EMT triggers the next callback phase.
+     */
+    uint32_t cEntered = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsEntered);
+    if (cEntered != pVM->cCPUs)
+    {
+        if ((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ONE_BY_ONE)
+        {
+            /* Wait for our turn. */
+            rc = RTSemEventWait(pVM->vmm.s.hEvtRendezvousEnterOneByOne, RT_INDEFINITE_WAIT);
+            AssertLogRelRC(rc);
+        }
+        else if ((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE)
+        {
+            /* Wait for the last EMT to arrive and wake everyone up. */
+            rc = RTSemEventMultiWait(pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce, RT_INDEFINITE_WAIT);
+            AssertLogRelRC(rc);
+        }
+        else
+        {
+            Assert((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE);
+
+            /*
+             * The execute once is handled specially to optimize the code flow.
+             *
+             * The last EMT to arrive will perform the callback and the other
+             * EMTs will wait on the Done/DoneCaller semaphores (instead of
+             * the EnterOneByOne/AllAtOnce) in the meanwhile. When the callback
+             * returns, that EMT will initiate the normal return sequence.
+             */
+            if (!fIsCaller)
+            {
+                rc = RTSemEventMultiWait(pVM->vmm.s.hEvtMulRendezvousDone, RT_INDEFINITE_WAIT);
+                AssertLogRelRC(rc);
+
+                vmmR3EmtRendezvousNonCallerReturn(pVM);
+            }
+            return;
+        }
+    }
+    else
+    {
+        /*
+         * All EMTs are waiting, clear the FF and take action according to the
+         * execution method.
+         */
+        VM_FF_CLEAR(pVM, VM_FF_EMT_RENDEZVOUS);
+
+        if ((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ALL_AT_ONCE)
+        {
+            /* Wake up everyone. */
+            rc = RTSemEventMultiSignal(pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce);
+            AssertLogRelRC(rc);
+        }
+        /* else: execute the handler on the current EMT and wake up one or more threads afterwards. */
+    }
+
+
+    /*
+     * Do the callback and update the status if necessary.
+     */
+    rc = pfnRendezvous(pVM, pVCpu, pvUser);
+    if (rc != VINF_SUCCESS)
+    {
+        int32_t i32RendezvousStatus;
+        do
+        {
+            i32RendezvousStatus = ASMAtomicUoReadS32(&pVM->vmm.s.i32RendezvousStatus);
+            if (    RT_FAILURE(i32RendezvousStatus)
+                ||  (   i32RendezvousStatus != VINF_SUCCESS
+                     && RT_SUCCESS(rc)))
+                break;
+        } while (!ASMAtomicCmpXchgS32(&pVM->vmm.s.i32RendezvousStatus, rc, i32RendezvousStatus));
+    }
+
+    /*
+     * Increment the done counter and take action depending on whether we're
+     * the last to finish callback execution.
+     */
+    uint32_t cDone = ASMAtomicIncU32(&pVM->vmm.s.cRendezvousEmtsDone);
+    if (    cDone != pVM->cCPUs
+        &&  (fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) != VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE)
+    {
+        /* Signal the next EMT? */
+        if ((fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) == VMMEMTRENDEZVOUS_FLAGS_TYPE_ONE_BY_ONE)
+        {
+            rc = RTSemEventSignal(pVM->vmm.s.hEvtRendezvousEnterOneByOne);
+            AssertLogRelRC(rc);
+        }
+
+        /* Wait for the rest to finish (the caller waits on hEvtRendezvousDoneCaller). */
+        if (!fIsCaller)
+        {
+            rc = RTSemEventMultiWait(pVM->vmm.s.hEvtMulRendezvousDone, RT_INDEFINITE_WAIT);
+            AssertLogRelRC(rc);
+        }
+    }
+    else
+    {
+        /* Callback execution is all done, tell the rest to return. */
+        rc = RTSemEventMultiSignal(pVM->vmm.s.hEvtMulRendezvousDone);
+        AssertLogRelRC(rc);
+    }
+
+    if (!fIsCaller)
+        vmmR3EmtRendezvousNonCallerReturn(pVM);
+}
+
+
+/**
+ * Called in response to VM_FF_EMT_RENDEZVOUS.
+ *
+ * @param   pVM         The VM handle
+ * @param   pVCpu       The handle of the calling EMT.
+ *
+ * @thread  EMT
+ */
+VMMR3DECL(void) VMMR3EmtRendezvousFF(PVM pVM, PVMCPU pVCpu)
+{
+    vmmR3EmtRendezvousCommon(pVM, pVCpu, false /* fIsCaller */, pVM->vmm.s.fRendezvousFlags,
+                             pVM->vmm.s.pfnRendezvous, pVM->vmm.s.pvRendezvousUser);
+}
+
+
+/**
+ * EMT rendezvous.
+ *
+ * Gathers all the EMTs and execute some code on each of them, either in a one
+ * by one fashion or all at once.
+ *
+ * @returns VBox status code. This will be the first error or, if all succeed,
+ *          the first informational status code.
+ * @retval  VERR_VM_THREAD_NOT_EMT if the caller is not an EMT.
+ *
+ * @param   pVM             The VM handle.
+ * @param   fFlags          Flags indicating execution methods. See
+ *                          grp_VMMR3EmtRendezvous_fFlags.
+ * @param   pfnRendezvous   The callback.
+ * @param   pvUser          User argument for the callback.
+ *
+ * @thread  EMT
+ */
+VMMR3DECL(int) VMMR3EmtRendezvous(PVM pVM, uint32_t fFlags, PFNVMMEMTRENDEZVOUS pfnRendezvous, void *pvUser)
+{
+    /*
+     * Validate input.
+     */
+    PVMCPU pVCpu = VMMGetCpu(pVM);
+    AssertReturn(pVCpu, VERR_VM_THREAD_NOT_EMT);
+    AssertMsg(   (fFlags & VMMEMTRENDEZVOUS_FLAGS_TYPE_MASK) != VMMEMTRENDEZVOUS_FLAGS_TYPE_INVALID
+              && !(fFlags & ~VMMEMTRENDEZVOUS_FLAGS_VALID_MASK), ("%#x\n", fFlags));
+
+    int rc;
+    if (pVM->cCPUs == 1)
+        /*
+         * Shortcut for the single EMT case.
+         */
+        rc = pfnRendezvous(pVM, pVCpu, pvUser);
+    else
+    {
+        /*
+         * Spin lock. If busy, wait for the other EMT to finish while keeping a
+         * lookout of the RENDEZVOUS FF.
+         */
+        while (!ASMAtomicCmpXchgU32(&pVM->vmm.s.u32RendezvousLock, 0x77778888, 0))
+        {
+            if (VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS))
+                VMMR3EmtRendezvousFF(pVM, pVCpu);
+        }
+        Assert(!VM_FF_ISPENDING(pVM, VM_FF_EMT_RENDEZVOUS));
+
+        /*
+         * Clear the slate. This is a semaphore ping-pong orgy. :-)
+         */
+        rc = RTSemEventWait(pVM->vmm.s.hEvtRendezvousEnterOneByOne, 0);         AssertLogRelMsg(rc == VERR_TIMEOUT || rc == VINF_SUCCESS, ("%Rrc\n", rc));
+        rc = RTSemEventMultiReset(pVM->vmm.s.hEvtMulRendezvousEnterAllAtOnce);  AssertLogRelRC(rc);
+        rc = RTSemEventMultiReset(pVM->vmm.s.hEvtMulRendezvousDone);            AssertLogRelRC(rc);
+        rc = RTSemEventWait(pVM->vmm.s.hEvtRendezvousDoneCaller, 0);            AssertLogRelMsg(rc == VERR_TIMEOUT || rc == VINF_SUCCESS, ("%Rrc\n", rc));
+        ASMAtomicWriteU32(&pVM->vmm.s.cRendezvousEmtsEntered, 0);
+        ASMAtomicWriteU32(&pVM->vmm.s.cRendezvousEmtsDone, 0);
+        ASMAtomicWriteU32(&pVM->vmm.s.cRendezvousEmtsReturned, 0);
+        ASMAtomicWriteS32(&pVM->vmm.s.i32RendezvousStatus, VINF_SUCCESS);
+        ASMAtomicWritePtr((void * volatile *)&pVM->vmm.s.pfnRendezvous, (void *)(uintptr_t)pfnRendezvous);
+        ASMAtomicWritePtr(&pVM->vmm.s.pvRendezvousUser, pvUser);
+        ASMAtomicWriteU32(&pVM->vmm.s.fRendezvousFlags, fFlags);
+
+        /*
+         * Set the FF and poke the other EMTs.
+         */
+        VM_FF_SET(pVM, VM_FF_EMT_RENDEZVOUS);
+        VMR3NotifyGlobalFFU(pVM->pUVM, VMNOTIFYFF_FLAGS_POKE);
+
+        /*
+         * Do the same ourselves.
+         */
+        vmmR3EmtRendezvousCommon(pVM, pVCpu, true /* fIsCaller */, fFlags, pfnRendezvous, pvUser);
+
+        /*
+         * The caller waits for the other EMTs to be done and return before doing
+         * the cleanup. This makes away with wakeup / reset races we would otherwise
+         * risk in the multiple release event semaphore code (hEvtRendezvousDoneCaller).
+         */
+        rc = RTSemEventWait(pVM->vmm.s.hEvtRendezvousDoneCaller, RT_INDEFINITE_WAIT);
+        AssertLogRelRC(rc);
+
+        /*
+         * Get the return code and clean up a little bit.
+         */
+        rc = pVM->vmm.s.i32RendezvousStatus;
+        ASMAtomicWritePtr((void * volatile *)&pVM->vmm.s.pfnRendezvous, NULL);
+
+        ASMAtomicWriteU32(&pVM->vmm.s.u32RendezvousLock, 0);
+    }
+
     return rc;
 }
@@ -1760 +2033 @@
     PRINT_FLAG(VM_FF_,TERMINATE);
     PRINT_FLAG(VM_FF_,RESET);
+    PRINT_FLAG(VM_FF_,EMT_RENDEZVOUS);
     PRINT_FLAG(VM_FF_,PGM_NEED_HANDY_PAGES);
     PRINT_FLAG(VM_FF_,PGM_NO_MEMORY);

trunk/src/VBox/VMM/VMMInternal.h

@@ -267 +267 @@
      * Use for synchronizing all VCPUs
      */
-    RTCRITSECT                 CritSectSync;
+    RTCRITSECT                  CritSectSync;
+
+    /** @name EMT Rendezvous
+     * @{ */
+    /** Semaphore to wait on upon entering for one-by-one execution. */
+    RTSEMEVENT                  hEvtRendezvousEnterOneByOne;
+    /** Semaphore to wait on upon entering for all-at-once execution. */
+    RTSEMEVENTMULTI             hEvtMulRendezvousEnterAllAtOnce;
+    /** Semaphore to wait on when done. */
+    RTSEMEVENTMULTI             hEvtMulRendezvousDone;
+    /** Semaphore the VMMR3EmtRendezvous caller waits on at the end. */
+    RTSEMEVENT                  hEvtRendezvousDoneCaller;
+    /** Callback. */
+    R3PTRTYPE(PFNVMMEMTRENDEZVOUS) volatile pfnRendezvous;
+    /** The user argument for the callback. */
+    RTR3PTR volatile            pvRendezvousUser;
+    /** Flags. */
+    volatile uint32_t           fRendezvousFlags;
+    /** The number of EMTs that has entered. */
+    volatile uint32_t           cRendezvousEmtsEntered;
+    /** The number of EMTs that has done their job. */
+    volatile uint32_t           cRendezvousEmtsDone;
+    /** The number of EMTs that has returned. */
+    volatile uint32_t           cRendezvousEmtsReturned;
+    /** The status code. */
+    volatile int32_t            i32RendezvousStatus;
+    /** Spin lock. */
+    volatile uint32_t           u32RendezvousLock;
+    /** @} */
 
     /** Buffer for storing the standard assertion message for a ring-0 assertion.

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

@@ -882 +882 @@
     GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuest);
     GEN_CHECK_OFF(VMM, pfnCPUMRCResumeGuestV86);
+    GEN_CHECK_OFF(VMM, pRCLoggerRC);
+    GEN_CHECK_OFF(VMM, pRCLoggerR3);
+    GEN_CHECK_OFF(VMM, cbRCLogger);
+    GEN_CHECK_OFF(VMM, pYieldTimer);
+    GEN_CHECK_OFF(VMM, cYieldResumeMillies);
+    GEN_CHECK_OFF(VMM, cYieldEveryMillies);
+    GEN_CHECK_OFF(VMM, CritSectSync);
+    GEN_CHECK_OFF(VMM, hEvtRendezvousEnterOneByOne);
+    GEN_CHECK_OFF(VMM, hEvtMulRendezvousEnterAllAtOnce);
+    GEN_CHECK_OFF(VMM, hEvtMulRendezvousDone);
+    GEN_CHECK_OFF(VMM, hEvtRendezvousDoneCaller);
+    GEN_CHECK_OFF(VMM, pfnRendezvous);
+    GEN_CHECK_OFF(VMM, pvRendezvousUser);
+    GEN_CHECK_OFF(VMM, fRendezvousFlags);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsEntered);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsDone);
+    GEN_CHECK_OFF(VMM, cRendezvousEmtsReturned);
+    GEN_CHECK_OFF(VMM, i32RendezvousStatus);
+    GEN_CHECK_OFF(VMM, u32RendezvousLock);
+    GEN_CHECK_OFF(VMM, szRing0AssertMsg1);
+    GEN_CHECK_OFF(VMM, szRing0AssertMsg2);
+    GEN_CHECK_OFF(VMM, StatRunRC);
+    GEN_CHECK_OFF(VMM, StatRZCallPGMLock);
     GEN_CHECK_OFF(VMMCPU, iLastGZRc);
     GEN_CHECK_OFF(VMMCPU, pbEMTStackR3);
     GEN_CHECK_OFF(VMMCPU, pbEMTStackRC);
     GEN_CHECK_OFF(VMMCPU, pbEMTStackBottomRC);
-    GEN_CHECK_OFF(VMM, pRCLoggerRC);
-    GEN_CHECK_OFF(VMM, pRCLoggerR3);
 #ifdef LOG_ENABLED
     GEN_CHECK_OFF(VMMCPU, pR0LoggerR0);
     GEN_CHECK_OFF(VMMCPU, pR0LoggerR3);
 #endif
-    GEN_CHECK_OFF(VMM, cbRCLogger);
-    GEN_CHECK_OFF(VMM, pYieldTimer);
-    GEN_CHECK_OFF(VMM, cYieldResumeMillies);
-    GEN_CHECK_OFF(VMM, cYieldEveryMillies);
     GEN_CHECK_OFF(VMMCPU, enmCallHostOperation);
     GEN_CHECK_OFF(VMMCPU, rcCallHost);
@@ -902 +919 @@
     GEN_CHECK_OFF(VMMCPU, CallHostR0JmpBuf.SpCheck);
     GEN_CHECK_OFF(VMMCPU, CallHostR0JmpBuf.SpResume);
-    GEN_CHECK_OFF(VMM, StatRunRC);
-    GEN_CHECK_OFF(VMM, StatRZCallPGMLock);
 
     GEN_CHECK_SIZE(RTPINGPONG);