Changeset 50281 in vbox for trunk

Timestamp:

Jan 30, 2014 10:43:54 AM (11 years ago)

Author:

vboxsync

Message:

Additions/x11/VBoxClient: detect VT switches on Linux 2.6.38 and higher and notify the service.

Location:

trunk/src/VBox/Additions/x11/VBoxClient

Files:

• VBoxClient.h (modified) (1 diff)
• main.cpp (modified) (8 diffs)

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

@@ -33 +33 @@
     /** Run the service main loop */
     virtual int run(bool fDaemonised = false) = 0;
-    /** Clean up any global resources before we shut down hard */
+    /** Pause the service loop.  This must be safe to call on a different thread
+     * and potentially before @run is or after it exits. */
+    virtual void pause() { }
+    /** Resume after pausing.  The same applies here as for @a pause. */
+    virtual void resume() { }
+    /** Clean up any global resources before we shut down hard.  Calling
+     *  @a pause or @a resume later than @a cleanup must not cause errors. */
     virtual void cleanup() = 0;
     /** Virtual destructor.  Not used */

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

@@ -18 +18 @@
 
 #include <sys/types.h>
+#if 0
+#include <sys/vt.h>
+#endif
 #include <stdlib.h>       /* For exit */
 #include <stdio.h>
@@ -23 +26 @@
 #include <unistd.h>
 #include <errno.h>
+#include <poll.h>
 #include <signal.h>
 
 #include <X11/Xlib.h>
+#include <X11/Xatom.h>
 
 #include <iprt/critsect.h>
 #include <iprt/env.h>
+#include <iprt/file.h>
 #include <iprt/initterm.h>
 #include <iprt/message.h>
@@ -35 +41 @@
 #include <iprt/stream.h>
 #include <iprt/string.h>
+#include <iprt/types.h>
 #include <VBox/VBoxGuestLib.h>
 #include <VBox/log.h>
@@ -53 +60 @@
  * cleanup routine. */
 static RTFILE g_hPidFile;
-/** Global critical section used to protect the clean-up routine, which can be
- * called from different threads.
- */
-RTCRITSECT g_critSect;
+/** Global critical section held during the clean-up routine (to prevent it
+ * being called on multiple threads at once) or things which may not happen
+ * during clean-up (e.g. pausing and resuming the service).
+ */
+RTCRITSECT g_cleanupCritSect;
 
 /** Clean up if we get a signal or something.  This is extern so that we
@@ -65 +73 @@
      * async-safe.  Until we fix this application properly, we should be sure
      * never to exit from anywhere except from this method. */
-    int rc = RTCritSectEnter(&g_critSect);
+    int rc = RTCritSectEnter(&g_cleanupCritSect);
     if (RT_FAILURE(rc))
     {
@@ -136 +144 @@
 }
 
+/** Connect to the X server and return the "XFree86_VT" root window property,
+ * or 0 on failure. */
+static unsigned long getXOrgVT(void)
+{
+    Display *pDisplay;
+    Atom actualType;
+    int actualFormat;
+    unsigned long cItems, cbLeft, cVT = 0;
+    unsigned long *pValue;
+
+    pDisplay = XOpenDisplay(NULL);
+    if (!pDisplay)
+        return VINF_SUCCESS;
+    XGetWindowProperty(pDisplay, DefaultRootWindow(pDisplay),
+                       XInternAtom(pDisplay, "XFree86_VT", False), 0, 1, False,
+                       XA_INTEGER, &actualType, &actualFormat, &cItems, &cbLeft,
+                       (unsigned char **)&pValue);
+    if (cItems && actualFormat == 32)
+    {
+        cVT = *pValue;
+        XFree(pValue);
+    }
+    XCloseDisplay(pDisplay);
+    return cVT;
+}
+
+#ifdef RT_OS_LINUX
+/** Poll for TTY changes using sysfs. Reading from the start of the pollable
+ * file "/sys/class/tty/tty0/active" returns the currently active TTY as a
+ * string of the form "tty<n>", with n greater than zero.  Polling for POLLPRI
+ * returns when the TTY changes. */
+static bool pollTTYSysfs(uint32_t cVT)
+{
+    RTFILE hFile;
+    struct pollfd pollFD;
+
+    if (RT_SUCCESS(RTFileOpen(&hFile, "/sys/class/tty/tty0/active",
+                          RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN)))
+    {
+        pollFD.fd = RTFileToNative(hFile);
+        pollFD.events = POLLPRI;
+        while (true)
+        {
+            char szTTY[7];
+            uint32_t cTTY;
+            size_t cbRead;
+
+            if (RT_FAILURE(RTFileReadAt(hFile, 0, (void *)szTTY, sizeof(szTTY),
+                           &cbRead)))
+            {
+                LogRel(("VT monitor thread: read failed, stopping.\n"));
+                break;
+            }
+            szTTY[6] = '\0';
+            cTTY = RTStrToUInt32(&szTTY[3]);
+            if (!cTTY)
+            {
+                LogRel(("VT monitor thread: failed to read the TTY, stopping.\n"));
+                break;
+            }
+            if (cTTY == cVT)
+                g_pService->resume();
+            else
+                g_pService->pause();
+            /* If we get caught in a tight loop for some reason try to limit the
+             * damage. */
+            if (poll(&pollFD, 1, 0) > 0)
+            {
+                LogRel(("VT monitor thread: unexpectedly fast event, revents=0x%x.\n",
+                        pollFD.revents));
+                RTThreadYield();
+            }
+            if (   (poll(&pollFD, 1, -1) < 0 && errno != EINVAL)
+                || pollFD.revents & POLLNVAL)
+            {
+                LogRel(("VT monitor thread: poll failed, stopping.\n"));
+                break;
+            }
+        }
+        RTFileClose(hFile);
+    }
+    else
+        return false;
+    return true;
+}
+#endif /* defined RT_OS_LINUX */
+
+#if 0
+/** @note This is disabled because I believe that our existing code works well
+ *        enough on the pre-Linux 2.6.38 systems where it would be needed. 
+ *        I will leave the code in place in case that proves to be wrong. */
+/** Here we monitor the active VT by performing a VT_STATE ioctl on
+ * /dev/console at regular intervals.  Unfortunately we can only monitor the
+ * first sixteen virtual terminals this way, so if the X server is running on
+ * a higher one we do not even try. */
+static bool pollTTYDevConsole(unsigned long cVT)
+{
+    RTFILE hFile;
+
+    if (cVT >= 16)
+        return false;
+    if (RT_SUCCESS(RTFileOpen(&hFile, "/dev/console",
+                      RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN)))
+    {
+        while (true)
+        {
+            struct vt_stat vtStat;
+            int rc;
+
+            if (   RT_FAILURE(RTFileIoCtl(hFile, VT_GETSTATE, &vtStat,
+                              sizeof(vtStat), &rc))
+                || rc)
+            {
+                LogRel(("VT monitor thread: ioctl failed, stopping.\n"));
+                break;
+            }
+            if (vtStat.v_active == cVT)
+                g_pService->resume();
+            else
+                g_pService->pause();
+            RTThreadSleep(1000);
+        }
+        RTFileClose(hFile);
+    }
+    else
+        return false;
+    return true;
+}
+#endif
+
+#ifdef RT_OS_LINUX
+/**
+ * Thread which notifies the service when we switch to a different VT or back.
+ * @note runs until programme exit.
+ * @todo take "g_cleanupCritSect" while pausing/resuming the service to ensure
+ *       that they do not happen after clean-up starts.  We actually want to
+ *       prevent racing with the static destructor for the service object, as
+ *       there is (I think) no guarantee that the VT thread will stop before the
+ *       destructor is called on programme exit.
+ */
+static int pfnVTMonitorThread(RTTHREAD self, void *pvUser)
+{
+    unsigned long cVT;
+    RTFILE hFile;
+    
+    cVT = getXOrgVT();
+    if (!cVT)
+        return VINF_SUCCESS;
+    if (!pollTTYSysfs((uint32_t) cVT))
+#if 0  /* Probably not needed, see comment before function. */
+        pollTTYDevConsole(cVT);
+#else
+        true;
+#endif
+    return VINF_SUCCESS;
+}
+
+/**
+ * Start the thread which notifies the service when we switch to a different
+ * VT or back.  This is best effort functionality (XFree86 4.3 and older do not
+ * report their VT via the "XFree86_VT" root window property at all), so we
+ * only fail if actual thread creation fails.
+ */
+static int startVTMonitorThread()
+{
+    return RTThreadCreate(NULL, pfnVTMonitorThread, NULL, 0,
+                          RTTHREADTYPE_INFREQUENT_POLLER, 0, "VT_MONITOR");
+}
+#endif /* defined RT_OS_LINUX */
+
 /**
  * Print out a usage message and exit with success.
@@ -190 +368 @@
 
     /* Initialise our global clean-up critical section */
-    rc = RTCritSectInit(&g_critSect);
+    rc = RTCritSectInit(&g_cleanupCritSect);
     if (RT_FAILURE(rc))
     {
@@ -307 +485 @@
     /* Set an X11 I/O error handler, so that we can shutdown properly on fatal errors. */
     XSetIOErrorHandler(vboxClientXLibIOErrorHandler);
+#ifdef RT_OS_LINUX
+    rc = startVTMonitorThread();
+    if (RT_FAILURE(rc))
+    {
+        RTPrintf("Failed to start the VT monitor thread (%Rrc).  Exiting.\n",
+                 rc);
+        LogRel(("Failed to start the VT monitor thread (%Rrc).  Exiting.\n",
+                 rc));
+        VbglR3Term();
+        return 1;
+    }
+#endif /* defined RT_OS_LINUX */
     g_pService->run(fDaemonise);
     VBoxClient::CleanUp();