Changeset 50495 in vbox for trunk/src/VBox/Additions/x11/VBoxClient

Timestamp:

Feb 18, 2014 2:57:35 PM (11 years ago)

Author:

vboxsync

Message:

Additions/x11/VBoxClient: add VT monitoring to seamless service.

Location:

trunk/src/VBox/Additions/x11/VBoxClient

Files:

• seamless.cpp (modified) (8 diffs)
• seamless.h (modified) (5 diffs)
• testcase/tstSeamlessX11.cpp (modified) (1 diff)

trunk/src/VBox/Additions/x11/VBoxClient/seamless.cpp

@@ -36 +36 @@
     mX11MonitorThread = NIL_RTTHREAD;
     mX11MonitorThreadStopping = false;
+    mMode = VMMDev_Seamless_Disabled;
+    mfPaused = false;
 }
 
@@ -45 +47 @@
 
 /**
- * Start the main service thread which listens for host state change
+ * initialise the service.
+ */
+int SeamlessMain::init(void)
+{
+    int rc;
+    const char *pcszStage;
+
+    LogRelFlowFunc(("\n"));
+    do {
+        pcszStage = "Connecting to the X server";
+        rc = mX11Monitor.init(this);
+        if (RT_FAILURE(rc))
+            break;
+        pcszStage = "Setting guest IRQ filter mask";
+        rc = VbglR3CtlFilterMask(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST, 0);
+        if (RT_FAILURE(rc))
+            break;
+        pcszStage = "Reporting support for seamless capability";
+        rc = VbglR3SeamlessSetCap(true);
+        if (RT_FAILURE(rc))
+            break;
+    } while(0);
+    if (RT_FAILURE(rc))
+        LogRel(("VBoxClient (seamless): failed to start.  Stage: \"%s\"  Error: %Rrc\n",
+                pcszStage, rc));
+    return rc;
+}
+
+/**
+ * Run the main service thread which listens for host state change
  * notifications.
  * @returns iprt status value.  Service will be set to the stopped state on
  *          failure.
  */
-int SeamlessMain::start(void)
-{
-    int rc;
-    const char *pszStage;
-
-    LogRelFlowFunc(("\n"));
-    do {
-        pszStage = "Testing event loop cancellation";
-        VbglR3InterruptEventWaits();
-        if (RT_FAILURE(VbglR3WaitEvent(VMMDEV_EVENT_VALID_EVENT_MASK, 0, NULL)))
-            break;
-        if (   VbglR3WaitEvent(VMMDEV_EVENT_VALID_EVENT_MASK, 0, NULL)
-            != VERR_TIMEOUT)
-            break;
-        pszStage = "Connecting to the X server";
-        rc = mX11Monitor.init(this);
-        if (RT_FAILURE(rc))
-            break;
-        pszStage = "Setting guest IRQ filter mask";
-        rc = VbglR3CtlFilterMask(VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST, 0);
-        if (RT_FAILURE(rc))
-            break;
-        pszStage = "Reporting support for seamless capability";
-        rc = VbglR3SeamlessSetCap(true);
-        if (RT_FAILURE(rc))
-            break;
-        pszStage = "Running event loop";
-        /* This will only exit if something goes wrong. */
-        /** @todo Add a "stopping" variable.  Actually "pausing" the service
-         * should be enough. */
-        while (RT_SUCCESS(rc) || rc == VERR_TRY_AGAIN || rc == VERR_INTERRUPTED)
-        {
-            if (RT_FAILURE(rc))
-                /* If we are not stopping, sleep for a bit to avoid using up too
-                    much CPU while retrying. */
-                RTThreadYield();
-            rc = nextStateChangeEvent();
-        }
-    } while(0);
-    if (RT_FAILURE(rc))
-    {
-        LogRel(("VBoxClient (seamless): failed to start.  Stage: \"%s\"  Error: %Rrc\n",
-                pszStage, rc));
+int SeamlessMain::run(void)
+{
+    int rc = VINF_SUCCESS;
+
+    LogRelFlowFunc(("\n"));
+    /* This will only exit if something goes wrong. */
+    while (RT_SUCCESS(rc) || rc == VERR_INTERRUPTED)
+    {
+        if (RT_FAILURE(rc))
+            /* If we are not stopping, sleep for a bit to avoid using up too
+                much CPU while retrying. */
+            RTThreadYield();
+        rc = nextStateChangeEvent();
+    }
+    if (RT_FAILURE(rc))
+    {
+        LogRel(("VBoxClient (seamless): event loop failed with error: %Rrc\n",
+                rc));
         stop();
     }
-    LogRelFlowFunc(("returning %Rrc\n", rc));
     return rc;
 }
@@ -123 +128 @@
     if (RT_SUCCESS(rc))
     {
-        switch(newMode)
+        mMode = newMode;
+        switch (newMode)
         {
             case VMMDev_Seamless_Visible_Region:
-            /* A simplified seamless mode, obtained by making the host VM window borderless and
-              making the guest desktop transparent. */
-                LogRelFlowFunc(("VMMDev_Seamless_Visible_Region request received (VBoxClient).\n"));
-                /** @todo Do something on failure, like bail out. */
-                startX11MonitorThread();
+            /* A simplified seamless mode, obtained by making the host VM window
+             * borderless and making the guest desktop transparent. */
+                LogRelFlowFunc(("\"Visible region\" mode requested (VBoxClient).\n"));
+                break;
+            case VMMDev_Seamless_Disabled:
+                LogRelFlowFunc(("\"Disabled\" mode requested (VBoxClient).\n"));
                 break;
             case VMMDev_Seamless_Host_Window:
             /* One host window represents one guest window.  Not yet implemented. */
-                LogRelFunc(("Warning: VMMDev_Seamless_Host_Window request received (VBoxClient).\n"));
-                /* fall through to default */
+                LogRelFunc(("Unsupported \"host window\" mode requested (VBoxClient).\n"));
+                return VERR_NOT_SUPPORTED;
             default:
-                LogRelFunc(("Warning: unsupported VMMDev_Seamless request %d received (VBoxClient).\n", newMode));
-                /* fall through to case VMMDev_Seamless_Disabled */
-            case VMMDev_Seamless_Disabled:
-                LogRelFlowFunc(("VMMDev_Seamless_Disabled set (VBoxClient).\n"));
-                stopX11MonitorThread();
+                LogRelFunc(("Unsupported mode %d requested (VBoxClient).\n",
+                            newMode));
+                return VERR_NOT_SUPPORTED;
         }
     }
+    if (RT_SUCCESS(rc) || rc == VERR_TRY_AGAIN)
+    {
+        if (mMode == VMMDev_Seamless_Visible_Region && !mfPaused)
+            /* This does it's own logging on failure. */
+            rc = startX11MonitorThread();
+        else
+            /* This does it's own logging on failure. */
+            rc = stopX11MonitorThread();
+    }
     else
     {
@@ -150 +164 @@
     LogRelFlowFunc(("returning %Rrc\n", rc));
     return rc;
+}
+
+int SeamlessMain::cancelEvent(void)
+{
+    return VbglR3InterruptEventWaits();
 }
 
@@ -196 +215 @@
 
     mX11MonitorThreadStopping = false;
+    if (isX11MonitorThreadRunning())
+        return VINF_SUCCESS;
     rc = RTThreadCreate(&mX11MonitorThread, x11MonitorThread, this, 0,
                         RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE,
@@ -207 +228 @@
  * Send a signal to the thread function that it should exit
  */
-void SeamlessMain::stopX11MonitorThread(void)
+int SeamlessMain::stopX11MonitorThread(void)
 {
     int rc;
 
     mX11MonitorThreadStopping = true;
-    if (!mX11MonitorThread)
-        return;
+    if (!isX11MonitorThreadRunning())
+        return VINF_SUCCESS;
     mX11Monitor.interruptEventWait();
     rc = RTThreadWait(mX11MonitorThread, RT_INDEFINITE_WAIT, NULL);
@@ -221 +242 @@
         LogRelThisFunc(("Failed to stop X11 monitor thread, rc=%Rrc!\n",
                         rc));
-}
-
-/** @todo Re-arrange the service to support pausing and resuming.  The state
- * needs to become more complex: we need to know: whether seamless is currently
- * requested by the host; whether we are currently in charge of the guest
- * desktop; whether the guest monitoring thead is currently active. */
+    return rc;
+}
+
+/** Pause the service loop. */
+int SeamlessMain::pause()
+{
+    int rc;
+    const char *pcszStage;
+
+    LogRelFlowFunc(("\n"));
+    mfPaused = true;
+    do {
+        pcszStage = "Reporting end of support for seamless capability";
+        rc = VbglR3SeamlessSetCap(false);
+        if (RT_FAILURE(rc))
+            break;
+        pcszStage = "Interrupting the event loop";
+        rc = cancelEvent();
+        if (RT_FAILURE(rc))
+            break;
+    } while (0);
+    if (RT_FAILURE(rc))
+        LogRelFunc(("Failure.  Stage: \"%s\"  Error: %Rrc (VBoxClient)\n",
+                    pcszStage, rc));
+    return rc;
+}
+
+/** Resume after pausing. */
+int SeamlessMain::resume()
+{
+    int rc;
+    const char *pcszStage;
+
+    LogRelFlowFunc(("\n"));
+    mfPaused = false;
+    do {
+        pcszStage = "Reporting support for seamless capability";
+        rc = VbglR3SeamlessSetCap(true);
+        if (RT_FAILURE(rc))
+            break;
+        pcszStage = "Interrupting the event loop";
+        rc = cancelEvent();
+        if (RT_FAILURE(rc))
+            break;
+    } while (0);
+    if (RT_FAILURE(rc))
+        LogRelFunc(("Failure.  Stage: \"%s\"  Error: %Rrc (VBoxClient)\n",
+                    pcszStage, rc));
+    return rc;
+}
+
+/** @todo Expand this? */
+int SeamlessMain::selfTest()
+{
+    int rc = VERR_INTERNAL_ERROR;
+    const char *pcszStage;
+
+    LogRelFlowFunc(("\n"));
+    do {
+        pcszStage = "Testing event loop cancellation";
+        VbglR3InterruptEventWaits();
+        if (RT_FAILURE(VbglR3WaitEvent(VMMDEV_EVENT_VALID_EVENT_MASK, 0, NULL)))
+            break;
+        if (   VbglR3WaitEvent(VMMDEV_EVENT_VALID_EVENT_MASK, 0, NULL)
+            != VERR_TIMEOUT)
+            break;
+        pcszStage = "Testing pause";  /* Other states are dangerous to test. */
+        mMode = VMMDev_Seamless_Visible_Region;
+        pause();
+        if (RT_FAILURE(nextStateChangeEvent()))
+            break;
+        if (isX11MonitorThreadRunning())
+            break;
+        mMode = VMMDev_Seamless_Disabled;
+        mfPaused = false;
+        rc = VINF_SUCCESS;
+    } while(0);
+    if (RT_FAILURE(rc))
+        LogRel(("VBoxClient (seamless): self test failed.  Stage: \"%s\"\n",
+                pcszStage));
+    return rc;
+}
+
 /** VBoxClient service class wrapping the logic for the seamless service while
  *  the main VBoxClient code provides the daemon logic needed by all services.
@@ -240 +338 @@
         return ".vboxclient-seamless.pid";
     }
-    virtual int run(bool fDaemonised /* = false */)
+    virtual int init()
     {
         int rc;
+
         if (mIsInitialised)
             return VERR_INTERNAL_ERROR;
+        rc = mSeamless.init();
+        if (RT_FAILURE(rc))
+            return rc;
+        rc = mSeamless.selfTest();
+        if (RT_FAILURE(rc))
+        {
+            mSeamless.stop();
+            return rc;
+        }
         mIsInitialised = true;
-        rc = mSeamless.start();
-        LogRelFunc(("VBoxClient: seamless service failed to start.  Error: %Rrc\n",
-                    rc));
+        return VINF_SUCCESS;
+    }
+    virtual int run(bool fDaemonised /* = false */)
+    {
+        int rc;
+        if (!mIsInitialised)
+            return VERR_INTERNAL_ERROR;
+        /* This only exits on error. */
+        rc = mSeamless.run();
+        mIsInitialised = false;
         return rc;
     }
+    virtual int pause() { return mSeamless.pause(); }
+    virtual int resume() { return mSeamless.resume(); }
     virtual void cleanup()
     {

trunk/src/VBox/Additions/x11/VBoxClient/seamless.h

@@ -45 +45 @@
     volatile bool mX11MonitorThreadStopping;
 
+    /** The current seamless mode we are in. */
+    VMMDevSeamlessMode mMode;
+    /** Is the service currently paused? */
+    volatile bool mfPaused;
+
     /**
      * Waits for a seamless state change events from the host and dispatch it.  This is
@@ -54 +59 @@
 
     /**
-     * Interrupt an event wait and cause nextStateChangeEvent() to return immediately.
+     * Interrupt an event wait and cause the current or next
+     * @a nextStateChangeEvent call to return immediately.
      */
-    void cancelEvent(void) { VbglR3InterruptEventWaits(); }
+    int cancelEvent(void);
     
     /** Thread function to monitor X11 window configuration changes. */
@@ -65 +71 @@
 
     /** Helper to stop the X11 monitor thread again. */
-    void stopX11MonitorThread(void);
+    int stopX11MonitorThread(void);
+    
+    /** Is the service currently actively monitoring X11 windows? */
+    bool isX11MonitorThreadRunning()
+    {
+        return mX11MonitorThread != NIL_RTTHREAD;
+    }
 
 public:
@@ -72 +84 @@
 
     /**
-      * Start the service.
+      * Initialise the service.
+      */
+    int init(void);
+
+    /**
+      * Run the service.
       * @returns iprt status value
       */
-    int start(void);
+    int run(void);
 
     /**
@@ -82 +99 @@
     void stop();
 
+    /** Pause the service loop.  This must be safe to call on a different thread
+     * and potentially before @a run is or after it exits.
+     * This is called by the VT monitoring thread to allow the service to disable
+     * itself when the X server is switched out.  If the monitoring functionality
+     * is available then @a pause or @a resume will be called as soon as it starts
+     * up. */
+    int pause();
+    /** Resume after pausing.  The same applies here as for @a pause. */
+    int resume();
+
     /**
      * Update the set of visible rectangles in the host.
      */
     virtual void sendRegionUpdate(RTRECT *pRects, size_t cRects);
+
+    /** Run a few tests to be sure everything is working as intended. */
+    int selfTest();
 };
 

trunk/src/VBox/Additions/x11/VBoxClient/testcase/tstSeamlessX11.cpp

@@ -120 +120 @@
     SeamlessMain seamless;
     LogRel(("Starting seamless Guest Additions...\n"));
-    rc = seamless.start();
+    rc = seamless.init();
     if (rc != VINF_SUCCESS)
     {
         RTPrintf("Failed to initialise seamless Additions, rc = %Rrc\n", rc);
     }
+    rc = seamless.run();
+    if (rc != VINF_SUCCESS)
+    {
+        RTPrintf("Failed to run seamless Additions, rc = %Rrc\n", rc);
+    }
     return rc;
 }