Changeset 1835 in vbox for trunk/src/VBox/Main

Timestamp:

Mar 30, 2007 5:18:35 PM (18 years ago)

Author:

vboxsync

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

20022

Message:

Main: Fixed delayed VirtualBox server shutdown on XPCOM.

File:

• trunk/src/VBox/Main/linux/server.cpp (modified) (7 diffs)

trunk/src/VBox/Main/linux/server.cpp

@@ -246 +246 @@
                 gEventQ->IsOnCurrentThread (&onMainThread);
 
-            if (!onMainThread)
+            LogFlowFunc (("Last VirtualBox instance was released, "
+                          "scheduling server shutdown in %d ms...\n",
+                          VBoxSVC_ShutdownDelay));
+
+            int vrc = RTTimerStart (sTimer, uint64_t (VBoxSVC_ShutdownDelay) * 1000000);
+            AssertRC (vrc);
+            if (VBOX_FAILURE (vrc))
             {
-                LogFlowFunc (("Last VirtualBox instance was released, "
-                              "scheduling server shutdown in %d ms...\n",
-                              VBoxSVC_ShutdownDelay));
-
-                /* Start a shutdown timer to provide some delay */
-#if 0 /** @todo Doesn't work when the 2nd client attaches while before the timer ticks. Dmitry will debug. */
-                int vrc = RTTimerStart (sTimer, uint64_t (VBoxSVC_ShutdownDelay) * 1000000);
-                AssertRC (vrc);
-                if (VBOX_FAILURE (vrc))
-#endif
+                /* Failed to start the timer, post the shutdown event
+                 * manually if not on the main thread alreay. */
+                if (!onMainThread)
                 {
-                    /* failed to start the timer, post the shutdown event
-                     * manually */
                     ShutdownTimer (NULL, NULL);
                 }
+                else
+                {
+                    /* Here we come if:
+                     *
+                     * a) gEventQ is 0 which means either FactoryDestructor() is called
+                     *    or the IPC/DCONNECT shutdown sequence is initiated by the
+                     *    XPCOM shutdown routine (NS_ShutdownXPCOM()), which always
+                     *    happens on the main thread.
+                     *
+                     * b) gEventQ has reported we're on the main thread. This means
+                     *    that DestructEventHandler() has been called, but another
+                     *    client was faster and requested VirtualBox again.
+                     *
+                     * In either case, since we're on the main thread already,
+                     * it's necessary just to release the instance once more
+                     * to call its destructor.
+                     */
+                    count = VirtualBox::Release();
+                }
             }
-            else
-            {
-                /* Here we come if:
-                 *
-                 * a) gEventQ is 0 which means either FactoryDestructor() is called
-                 *    or the IPC/DCONNECT shutdown sequence is initiated by the
-                 *    XPCOM shutdown routine (NS_ShutdownXPCOM()), which always
-                 *    happens on the main thread.
-                 *
-                 * b) gEventQ has reported we're on the main thread. This means
-                 *    that DestructEventHandler() has been called, but another
-                 *    client was faster and requested VirtualBox again.
-                 *
-                 * We have nothing to do in these cases.
-                 */
-            }
         }
 
@@ -285 +285 @@
     }
 
+    /* Returns the current value of the reference counter. */
+    nsrefcnt GetRefCount()
+    {
+        /* we don't use our own Release() to avoid its "side effect" */
+        nsrefcnt count = VirtualBox::AddRef();
+        count = VirtualBox::Release();
+        return count;
+    }
+
+    /* called on the main thread */
     static void *PR_CALLBACK DestructEventHandler (PLEvent* self)
     {
@@ -294 +304 @@
         Assert (sInstance);
 
-        /* release the reference we added in GetInstance()
-         * (will call the destructor if nobody referenced us again) */
-        nsrefcnt count = sInstance->Release();
-        if (count != 0)
-        {
-            LogFlowFunc (("Destruction is canceled.\n"));
+        nsrefcnt count = sInstance->GetRefCount();
+        AssertMsg (count >= 1, ("count=%d\n", count));
+
+        if (count > 1)
+        {
+            /* This case is very unlikely because we stop the timer when a new
+             * client connects after the instance was scheduled for
+             * destruction, but it's still possible. This is the only reason
+             * for the above GetRefCount() btw.  */
+            LogFlowFunc (("Destruction is canceled (refcnt=%d).\n", count));
+        }
+        else
+        {
+            /* release the last (first) reference we added in GetInstance()
+             * (this must call the destructor) */
+            nsrefcnt count = sInstance->Release();
+            AssertMsg (count == 0, ("count=%d\n", count));
         }
 
@@ -314 +335 @@
     static void ShutdownTimer (PRTTIMER pTimer, void *pvUser)
     {
+        NOREF (pTimer);
         NOREF (pvUser);
+
+        /* A "too late" event is theoretically possible if somebody
+         * manually ended the server after a destruction has been scheduled
+         * and this method was so lucky that it got a chance to run before
+         * the timer was killed. */
+        AssertReturnVoid (gEventQ);
 
         /* post a destruction event to the main thread to safely release the
@@ -424 +452 @@
                               "a reference of VirtualBox scheduled for destruction, "
                               "canceling detruction...\n"));
-
-                /* add a reference to compensate one that DestructEventHandler()
-                 * will release */
-                sInstance->AddRef();
+                
+                /* make sure the previous timer is stopped */
+                RTTimerStop (sTimer);
             }
         }
@@ -440 +467 @@
 private:
 
-    static VirtualBox *sInstance;
+    /* Don't be confused that sInstance is of the *ClassFactory type. This is
+     * actually a singleton instance (*ClassFactory inherits the singleton
+     * class; we combined them just for "simplicity" and used "static" for
+     * factory methods. *ClassFactory here is necessary for a couple of extra
+     * methods. */
+
+    static VirtualBoxClassFactory *sInstance;
     static RTCRITSECT sLock;
 
@@ -446 +479 @@
 };
 
-VirtualBox *VirtualBoxClassFactory::sInstance = 0;
+VirtualBoxClassFactory *VirtualBoxClassFactory::sInstance = 0;
 RTCRITSECT VirtualBoxClassFactory::sLock = {0};