Changeset 19089 in vbox

Timestamp:

Apr 21, 2009 5:31:47 PM (16 years ago)

Author:

vboxsync

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

46233

Message:

VMM: Fixed cleanup issue where the EMT was left behind by always waiting for the EMTs in vmR3DestroyUVM.

Location:

trunk

Files:

• include/VBox/uvm.h (modified) (1 diff)
• src/VBox/VMM/VM.cpp (modified) (6 diffs)

trunk/include/VBox/uvm.h

@@ -71 +71 @@
     /** Magic / eye-catcher (UVM_MAGIC). */
     uint32_t        u32Magic;
-    uint32_t        uReserved;          /**< alignment */
+    /** The number of virtual CPUs. */
+    uint32_t        cCpus;
     /** The ring-3 mapping of the shared VM structure. */
     PVM             pVM;

trunk/src/VBox/VMM/VM.cpp

@@ -137 +137 @@
 static DECLCALLBACK(int) vmR3Load(PVM pVM, const char *pszFilename, PFNVMPROGRESS pfnProgress, void *pvUser);
 static DECLCALLBACK(int) vmR3PowerOff(PVM pVM);
-static void              vmR3DestroyUVM(PUVM pUVM);
+static void              vmR3DestroyUVM(PUVM pUVM, uint32_t cMilliesEMTWait);
 static void              vmR3AtDtor(PVM pVM);
 static int               vmR3AtResetU(PUVM pUVM);
@@ -371 +371 @@
 
     /* cleanup */
-    vmR3DestroyUVM(pUVM);
+    vmR3DestroyUVM(pUVM, 2000);
     LogFlow(("VMR3Create: returns %Rrc\n", rc));
     return rc;
@@ -397 +397 @@
     AssertReturn(pUVM, VERR_NO_MEMORY);
     pUVM->u32Magic = UVM_MAGIC;
+    pUVM->cCpus = cCPUs;
 
     AssertCompile(sizeof(pUVM->vm.s) <= sizeof(pUVM->vm.padding));
@@ -1620 +1621 @@
 
         /*
-         * Wait for the EMT thread to terminate.
+         * Now do the final bit where the heap and VM structures are freed up.
+         * This will also wait 30 secs for the emulation threads to terminate.
          */
-        Assert(pUVM->vm.s.fTerminateEMT);
-        /** @todo SMP */
-        rc = RTThreadWait(pUVM->aCpus[0].vm.s.ThreadEMT, 30000, NULL);
-        AssertMsgRC(rc, ("EMT thread wait failed, rc=%Rrc\n", rc));
-
-        /*
-         * Now do the final bit where the heap and VM structures are freed up.
-         */
-        vmR3DestroyUVM(pUVM);
+        vmR3DestroyUVM(pUVM, 30000);
     }
 
@@ -1744 +1738 @@
 
     /*
-     * Did EMT call VMR3Destroy and have to do it all?
+     * Did an EMT call VMR3Destroy and end up having to do all the work?
      */
     if (pUVM->vm.s.fEMTDoesTheCleanup)
-        vmR3DestroyUVM(pUVM);
+        vmR3DestroyUVM(pUVM, 30000);
 }
 
@@ -1759 +1753 @@
  * vmR3DestroyFinalBitFromEMT completes.
  *
- * @param   pVM     VM Handle.
- */
-static void vmR3DestroyUVM(PUVM pUVM)
-{
-    /*
-     * Terminate the EMT if still running (creation failure only).
-     */
-    if (!pUVM->vm.s.fTerminateEMT)
-    {
-        ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
+ * @param   pVM             VM Handle.
+ * @param   cMilliesEMTWait The number of milliseconds to wait for the emulation
+ *                          threads.
+ */
+static void vmR3DestroyUVM(PUVM pUVM, uint32_t cMilliesEMTWait)
+{
+    /*
+     * Signal termination of each the emulation threads and
+     * wait for them to complete.
+     */
+    /* Signal them. */
+    ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
+    for (VMCPUID i = 0; i < pUVM->cCpus; i++)
+    {
+        ASMAtomicUoWriteBool(&pUVM->aCpus[i].vm.s.fTerminateEMT, true);
         if (pUVM->pVM)
+            VM_FF_SET(pUVM->pVM, VM_FF_TERMINATE);
+        VMR3NotifyFFU(pUVM, false);
+        if (pUVM->aCpus[i].vm.s.EventSemWait != NIL_RTSEMEVENT) /** @todo remove test when we start initializing it! */
+            RTSemEventSignal(pUVM->aCpus[i].vm.s.EventSemWait);
+    }
+    RTSemEventSignal(pUVM->vm.s.EventSemWait);
+
+    /* Wait for them. */
+    uint64_t    NanoTS = RTTimeNanoTS();
+    RTTHREAD    hSelf  = RTThreadSelf();
+    ASMAtomicUoWriteBool(&pUVM->vm.s.fTerminateEMT, true);
+    for (VMCPUID i = 0; i < pUVM->cCpus; i++)
+    {
+        RTTHREAD hThread = pUVM->aCpus[i].vm.s.ThreadEMT;
+        if (    hThread != NIL_RTTHREAD
+            &&  hThread != hSelf)
         {
-            VM_FF_SET(pUVM->pVM, VM_FF_TERMINATE);
-            VMR3NotifyFF(pUVM->pVM, false);
+            uint64_t cMilliesElapsed = (RTTimeNanoTS() - NanoTS) / 1000000;
+            int rc2 = RTThreadWait(hThread,
+                                   cMilliesElapsed < cMilliesEMTWait
+                                   ? RT_MAX(cMilliesEMTWait - cMilliesElapsed, 2000)
+                                   : 2000,
+                                   NULL);
+            if (rc2 == VERR_TIMEOUT) /* avoid the assertion when debugging. */
+                rc2 = RTThreadWait(hThread, 1000, NULL);
+            AssertLogRelMsgRC(rc2, ("i=%u rc=%Rrc\n", i, rc2));
+            if (RT_SUCCESS(rc2))
+                pUVM->aCpus[0].vm.s.ThreadEMT = NIL_RTTHREAD;
         }
-        RTSemEventSignal(pUVM->vm.s.EventSemWait);
-
-        /** @todo SMP */
-        int rc2 = RTThreadWait(pUVM->aCpus[0].vm.s.ThreadEMT, 2000, NULL);
-        AssertRC(rc2);
-    }
+    }
+
+    /* Cleanup the semaphores. */
+    for (VMCPUID i = 0; i < pUVM->cCpus; i++)
+        if (pUVM->aCpus[i].vm.s.EventSemWait != NIL_RTSEMEVENT) /** @todo remove test when we start initializing it! */
+        {
+            RTSemEventDestroy(pUVM->aCpus[i].vm.s.EventSemWait);
+            pUVM->aCpus[i].vm.s.EventSemWait = NIL_RTSEMEVENT;
+        }
     RTSemEventDestroy(pUVM->vm.s.EventSemWait);
     pUVM->vm.s.EventSemWait = NIL_RTSEMEVENT;