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

Timestamp:

Feb 10, 2020 2:56:41 PM (5 years ago)

Author:

vboxsync

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

136057

Message:

bugref:9637. Updating svga-display-x11 to use xrandr directly.

File:

• trunk/src/VBox/Additions/x11/VBoxClient/display-svga-x11.cpp (modified) (8 diffs)

trunk/src/VBox/Additions/x11/VBoxClient/display-svga-x11.cpp

@@ -37 +37 @@
  *  - When VMSVGA is not enabled, VBoxClient --vmsvga should never stay running.
  */
-
+#include "stdio.h"
 #include "VBoxClient.h"
 
@@ -57 +57 @@
 
 #include <X11/Xlibint.h>
+#include <X11/extensions/Xrandr.h>
+
+#ifdef RT_OS_LINUX
+# include <sys/ioctl.h>
+#else  /* Solaris and BSDs, in case they ever adopt the DRM driver. */
+# include <sys/ioccom.h>
+#endif
+
+#define USE_XRANDR_BIN
+
+
+struct X11VMWRECT /* xXineramaScreenInfo in Xlib headers. */
+{
+    int16_t x;
+    int16_t y;
+    uint16_t w;
+    uint16_t h;
+};
+AssertCompileSize(struct X11VMWRECT, 8);
+
+struct X11CONTEXT
+{
+    Display *pDisplay;
+    int hRandRMajor;
+    int hVMWMajor;
+    int hRandRMinor;
+    int hRandREventBase;
+    int hRandRErrorBase;
+    Window rootWindow;
+};
+
+static void x11Connect(struct X11CONTEXT *pContext)
+{
+    int dummy;
+
+    if (pContext->pDisplay != NULL)
+        VBClLogFatalError("%s called with bad argument\n", __func__);
+    pContext->pDisplay = XOpenDisplay(NULL);
+    if (pContext->pDisplay == NULL)
+        return;
+    // if (   !XQueryExtension(pContext->pDisplay, "RANDR",
+    //                         &pContext->hRandRMajor, &dummy, &dummy)
+    if(!XQueryExtension(pContext->pDisplay, "VMWARE_CTRL",
+                        &pContext->hVMWMajor, &dummy, &dummy))
+    {
+        XCloseDisplay(pContext->pDisplay);
+        pContext->pDisplay = NULL;
+    }
+    if (!XRRQueryExtension(pContext->pDisplay, &pContext->hRandREventBase, &pContext->hRandRErrorBase))
+    {
+        XCloseDisplay(pContext->pDisplay);
+        pContext->pDisplay = NULL;
+    }
+    if (!XRRQueryVersion(pContext->pDisplay, &pContext->hRandRMajor, &pContext->hRandRMinor))
+    {
+        XCloseDisplay(pContext->pDisplay);
+        pContext->pDisplay = NULL;
+    }
+    pContext->rootWindow = DefaultRootWindow(pContext->pDisplay);
+}
+
+#ifndef USE_XRANDR_BIN
 
 static bool checkRecentLinuxKernel(void)
@@ -69 +131 @@
 }
 
-struct X11CONTEXT
-{
-    Display *pDisplay;
-    int hRandRMajor;
-    int hVMWMajor;
-};
-
-static void x11Connect(struct X11CONTEXT *pContext)
-{
-    int dummy;
-
-    if (pContext->pDisplay != NULL)
-        VBClLogFatalError("%s called with bad argument\n", __func__);
-    pContext->pDisplay = XOpenDisplay(NULL);
-    if (pContext->pDisplay == NULL)
-        return;
-    if (   !XQueryExtension(pContext->pDisplay, "RANDR",
-                            &pContext->hRandRMajor, &dummy, &dummy)
-        || !XQueryExtension(pContext->pDisplay, "VMWARE_CTRL",
-                            &pContext->hVMWMajor, &dummy, &dummy))
-    {
-        XCloseDisplay(pContext->pDisplay);
-        pContext->pDisplay = NULL;
-    }
-}
 
 #define X11_VMW_TOPOLOGY_REQ 2
-struct X11VMWRECT /* xXineramaScreenInfo in Xlib headers. */
-{
-    int16_t x;
-    int16_t y;
-    uint16_t w;
-    uint16_t h;
-};
-AssertCompileSize(struct X11VMWRECT, 8);
 
 struct X11REQHEADER
@@ -225 +254 @@
 }
 
+#else //#fndef USE_XRANDR_BIN
+
+#define MAX_MODE_NAME_LEN 64
+#define MAX_COMMAND_LINE_LEN 512
+#define MAX_MODE_LINE_LEN 512
+
+static const char *szDefaultOutputNamePrefix = "Virtual";
+static const char *pcszXrandr = "xrandr";
+static const char *pcszCvt = "cvt";
+/** The number of outputs (monitors, including disconnect ones) xrandr reports. */
+static int iOutputCount = 0;
+
+struct DRMCONTEXT
+{
+    RTFILE hDevice;
+};
+
+#define DRM_DRIVER_NAME "vmwgfx"
+
+/** DRM version structure. */
+struct DRMVERSION
+{
+    int cMajor;
+    int cMinor;
+    int cPatchLevel;
+    size_t cbName;
+    char *pszName;
+    size_t cbDate;
+    char *pszDate;
+    size_t cbDescription;
+    char *pszDescription;
+};
+AssertCompileSize(struct DRMVERSION, 8 + 7 * sizeof(void *));
+
+#define DRM_IOCTL_VERSION _IOWR('d', 0x00, struct DRMVERSION)
+
+/** Rectangle structure for geometry of a single screen. */
+struct DRMVMWRECT
+{
+        int32_t x;
+        int32_t y;
+        uint32_t w;
+        uint32_t h;
+};
+AssertCompileSize(struct DRMVMWRECT, 16);
+
+struct DRMVMWUPDATELAYOUT {
+        uint32_t cOutputs;
+        uint32_t u32Pad;
+        uint64_t ptrRects;
+};
+AssertCompileSize(struct DRMVMWUPDATELAYOUT, 16);
+
+#define DRM_IOCTL_VMW_UPDATE_LAYOUT \
+        _IOW('d', 0x40 + 20, struct DRMVMWUPDATELAYOUT)
+
+struct RANDROUTPUT
+{
+    int32_t x;
+    int32_t y;
+    uint32_t width;
+    uint32_t height;
+    bool fEnabled;
+};
+
+/** run the xrandr command without options to get the total # of outputs (monitors) including
+ *  disbaled ones. */
+static int determineOutputCount()
+{
+    int iCount = 0;
+    char szCommand[MAX_COMMAND_LINE_LEN];
+    RTStrPrintf(szCommand, sizeof(szCommand), "%s ", pcszXrandr);
+
+    FILE *pFile;
+    pFile = popen(szCommand, "r");
+    if (pFile == NULL)
+    {
+        VBClLogError("Failed to run %s\n", szCommand);
+        return VMW_MAX_HEADS;
+    }
+    char szModeLine[MAX_COMMAND_LINE_LEN];
+    while (fgets(szModeLine, sizeof(szModeLine), pFile) != NULL)
+    {
+        if (RTStrIStr(szModeLine, szDefaultOutputNamePrefix))
+            ++iCount;
+    }
+    if (iCount == 0)
+        iCount = VMW_MAX_HEADS;
+    return iCount;
+}
+
+/** Parse a single line of the output of xrandr command to extract Mode name.
+ * Assumed to be null terminated and in following format:
+ * e.g. 1016x559_vbox  59.70. where 1016x559_vbox is the mode name and at least one space in front
+ * Set  mode name @p outPszModeName and return true if the name can be found, false otherwise.
+ * outPszModeNameis assumed to be of length MAX_MODE_NAME_LEN. */
+static bool parseModeLine(char *pszLine, char *outPszModeName)
+{
+    char *p = pszLine;
+    (void*)outPszModeName;
+    /* Copy chars to outPszModeName starting from the first non-space until outPszModeName ends with 'vbox'*/
+    size_t iNameIndex = 0;
+    bool fInitialSpace = true;
+
+    while(*p)
+    {
+        if (*p != ' ')
+            fInitialSpace = false;
+        if (!fInitialSpace && iNameIndex < MAX_MODE_NAME_LEN)
+        {
+            outPszModeName[iNameIndex] = *p;
+            ++iNameIndex;
+            if (iNameIndex >= 4)
+            {
+                if (outPszModeName[iNameIndex-1] == 'x' &&
+                    outPszModeName[iNameIndex-2] == 'o' &&
+                    outPszModeName[iNameIndex-3] == 'b')
+                    break;
+            }
+        }
+        ++p;
+    }
+    outPszModeName[iNameIndex] = '\0';
+    return true;
+}
+
+/** Parse the output of the xrandr command to try to remove custom modes.
+ * This function assumes all the outputs are named as VirtualX. */
+static void removeCustomModesFromOutputs()
+{
+    char szCommand[MAX_COMMAND_LINE_LEN];
+    RTStrPrintf(szCommand, sizeof(szCommand), "%s ", pcszXrandr);
+
+    FILE *pFile;
+    pFile = popen(szCommand, "r");
+    if (pFile == NULL)
+    {
+        VBClLogError("Failed to run %s\n", szCommand);
+        return;
+    }
+    char szModeLine[MAX_COMMAND_LINE_LEN];
+    char szModeName[MAX_MODE_NAME_LEN];
+    int iCount = 0;
+    char szRmModeCommand[MAX_COMMAND_LINE_LEN];
+    char szDelModeCommand[MAX_COMMAND_LINE_LEN];
+
+    while (fgets(szModeLine, sizeof(szModeLine), pFile) != NULL)
+    {
+        if (RTStrIStr(szModeLine, szDefaultOutputNamePrefix))
+        {
+            ++iCount;
+            continue;
+        }
+        if (iCount > 0 && RTStrIStr(szModeLine, "_vbox"))
+        {
+            parseModeLine(szModeLine, szModeName);
+            if (strlen(szModeName) >= 4)
+            {
+                /* Delete the mode from the outout. this fails if the mode is currently in use. */
+                RTStrPrintf(szDelModeCommand, sizeof(szDelModeCommand), "%s --delmode Virtual%d %s", pcszXrandr, iCount, szModeName);
+                system(szDelModeCommand);
+                /* Delete the mode from the xserver. note that this will fail if some output has still has this mode (even if unused).
+                 * thus this will fail most of the time. */
+                RTStrPrintf(szRmModeCommand, sizeof(szRmModeCommand), "%s --rmmode %s", pcszXrandr, szModeName);
+                system(szRmModeCommand);
+            }
+        }
+    }
+}
+
+static void getModeNameAndLineFromCVT(int iWidth, int iHeight, char *pszOutModeName, char *pszOutModeLine)
+{
+    char szCvtCommand[MAX_COMMAND_LINE_LEN];
+    const int iFreq = 60;
+    const int iMinNameLen = 4;
+    RTStrPrintf(szCvtCommand, sizeof(szCvtCommand), "%s %d %d %d", pcszCvt, iWidth, iHeight, iFreq);
+    FILE *pFile;
+    pFile = popen(szCvtCommand, "r");
+    if (pFile == NULL)
+    {
+        VBClLogError("Failed to run %s\n", szCvtCommand);
+        return;
+    }
+
+    char szModeLine[MAX_COMMAND_LINE_LEN];
+    while (fgets(szModeLine, sizeof(szModeLine), pFile) != NULL)
+    {
+        if (RTStrStr(szModeLine, "Modeline"))
+        {
+            if(szModeLine[strlen(szModeLine) - 1] == '\n')
+                szModeLine[strlen(szModeLine) - 1] = '\0';
+            size_t iFirstQu = RTStrOffCharOrTerm(szModeLine, '\"');
+            size_t iModeLineLen = strlen(szModeLine);
+            Assert(iFirstQu < iModeLineLen - iMinNameLen);
+
+            char *p = &(szModeLine[iFirstQu + 1]);
+            size_t iSecondQu = RTStrOffCharOrTerm(p, '_');
+            Assert(iSecondQu > iMinNameLen);
+            Assert(iSecondQu < MAX_MODE_NAME_LEN);
+            Assert(iSecondQu < iModeLineLen);
+
+            RTStrCopy(pszOutModeName, iSecondQu + 2, p);
+            RTStrCat(pszOutModeName, MAX_MODE_NAME_LEN, "vbox");
+            iSecondQu = RTStrOffCharOrTerm(p, '\"');
+            RTStrCopy(pszOutModeLine, MAX_MODE_LINE_LEN, &(szModeLine[iFirstQu + iSecondQu + 2]));
+            break;
+        }
+    }
+}
+
+/** Add a new mode to xserver and to the output */
+static void addMode(const char *pszModeName, const char *pszModeLine)
+{
+    char szNewModeCommand[MAX_COMMAND_LINE_LEN];
+    RTStrPrintf(szNewModeCommand, sizeof(szNewModeCommand), "%s --newmode \"%s\" %s", pcszXrandr, pszModeName, pszModeLine);
+    system(szNewModeCommand);
+
+    char szAddModeCommand[1024];
+    /* try to add the new mode to all possible outputs. we currently dont care if most the are disabled. */
+    for(int i = 0; i < iOutputCount; ++i)
+    {
+        RTStrPrintf(szAddModeCommand, sizeof(szAddModeCommand), "%s --addmode Virtual%d \"%s\"", pcszXrandr, i + 1, pszModeName);
+        system(szAddModeCommand);
+    }
+}
+
+static bool checkDefaultModes(struct RANDROUTPUT *pOutput, int iOutputIndex, char *pszModeName)
+{
+    const char szError[] = "cannot find mode";
+    char szXranrCommand[MAX_COMMAND_LINE_LEN];
+    RTStrPrintf(szXranrCommand, sizeof(szXranrCommand),
+                "%s --dryrun --output Virtual%u --mode %dx%d --pos %dx%d 2>/dev/stdout", pcszXrandr, iOutputIndex,
+                pOutput->width, pOutput->height, pOutput->x, pOutput->y);
+    RTStrPrintf(pszModeName, MAX_MODE_NAME_LEN, "%dx%d", pOutput->width, pOutput->height);
+    FILE *pFile;
+    pFile = popen(szXranrCommand, "r");
+    if (pFile == NULL)
+    {
+        VBClLogError("Failed to run %s\n", szXranrCommand);
+        return false;
+    }
+    char szResult[64];
+    if (fgets(szResult, sizeof(szResult), pFile) != NULL)
+    {
+        if (RTStrIStr(szResult, szError))
+            return false;
+    }
+    return true;
+}
+
+/** Construct the xrandr command which sets the whole monitor topology each time. */
+static void setXrandrModes(struct RANDROUTPUT *paOutputs)
+{
+    char szCommand[MAX_COMMAND_LINE_LEN];
+    RTStrPrintf(szCommand, sizeof(szCommand), "%s ", pcszXrandr);
+
+    for (int i = 0; i < iOutputCount; ++i)
+    {
+        char line[64];
+        if (!paOutputs[i].fEnabled)
+            RTStrPrintf(line, sizeof(line), "--output Virtual%u --off ", i + 1);
+        else
+        {
+            char szModeName[MAX_MODE_NAME_LEN];
+            char szModeLine[MAX_MODE_LINE_LEN];
+            /* Check if there is a default mode for the widthxheight and if not create and add a custom mode. */
+            if (!checkDefaultModes(&(paOutputs[i]), i + 1, szModeName))
+            {
+                getModeNameAndLineFromCVT(paOutputs[i].width, paOutputs[i].height, szModeName, szModeLine);
+                addMode(szModeName, szModeLine);
+            }
+            else
+                RTStrPrintf(szModeName, sizeof(szModeName), "%dx%d ", paOutputs[i].width, paOutputs[i].height);
+
+            RTStrPrintf(line, sizeof(line), "--output Virtual%u --mode %s --pos %dx%d ", i + 1,
+                        szModeName, paOutputs[i].x, paOutputs[i].y);
+        }
+        RTStrCat(szCommand, sizeof(szCommand), line);
+    }
+    system(szCommand);
+    VBClLogInfo("=======xrandr topology command:=====\n%s\n", szCommand);
+    removeCustomModesFromOutputs();
+}
+
+static void drmConnect(struct DRMCONTEXT *pContext)
+{
+    unsigned i;
+    RTFILE hDevice;
+
+    if (pContext->hDevice != NIL_RTFILE)
+        VBClLogFatalError("%s called with bad argument\n", __func__);
+    /* Try to open the SVGA DRM device. */
+    for (i = 0; i < 128; ++i)
+    {
+        char szPath[64];
+        struct DRMVERSION version;
+        char szName[sizeof(DRM_DRIVER_NAME)];
+        int rc;
+
+        /* Control devices for drm graphics driver control devices go from
+         * controlD64 to controlD127.  Render node devices go from renderD128
+         * to renderD192.  The driver takes resize hints via the control device
+         * on pre-4.10 kernels and on the render device on newer ones.  Try
+         * both types. */
+        if (i % 2 == 0)
+            rc = RTStrPrintf(szPath, sizeof(szPath), "/dev/dri/renderD%u", i / 2 + 128);
+        else
+            rc = RTStrPrintf(szPath, sizeof(szPath), "/dev/dri/controlD%u", i / 2 + 64);
+        if (RT_FAILURE(rc))
+            VBClLogFatalError("RTStrPrintf of device path failed, rc=%Rrc\n", rc);
+        rc = RTFileOpen(&hDevice, szPath, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
+        if (RT_FAILURE(rc))
+            continue;
+        RT_ZERO(version);
+        version.cbName = sizeof(szName);
+        version.pszName = szName;
+        rc = RTFileIoCtl(hDevice, DRM_IOCTL_VERSION, &version, sizeof(version), NULL);
+        if (   RT_SUCCESS(rc)
+            && !strncmp(szName, DRM_DRIVER_NAME, sizeof(DRM_DRIVER_NAME) - 1)
+            && (   version.cMajor > 2
+                || (version.cMajor == 2 && version.cMinor >= 9)))
+            break;
+        hDevice = NIL_RTFILE;
+    }
+    pContext->hDevice = hDevice;
+}
+
+static void drmSendHints(struct DRMCONTEXT *pContext, struct DRMVMWRECT *paRects,
+                         unsigned cHeads)
+{
+    int rc;
+    struct DRMVMWUPDATELAYOUT ioctlLayout;
+
+    if (pContext->hDevice == NIL_RTFILE)
+        VBClLogFatalError("%s bad device argument\n", __func__);
+    ioctlLayout.cOutputs = cHeads;
+    ioctlLayout.ptrRects = (uint64_t)paRects;
+    rc = RTFileIoCtl(pContext->hDevice, DRM_IOCTL_VMW_UPDATE_LAYOUT,
+                     &ioctlLayout, sizeof(ioctlLayout), NULL);
+    if (RT_FAILURE(rc) && rc != VERR_INVALID_PARAMETER)
+        VBClLogFatalError("Failure updating layout, rc=%Rrc\n", rc);
+}
+
+#endif /* #ifndef USE_XRANDR_BIN */
+
 static const char *getName()
 {
@@ -237 +611 @@
 static int run(struct VBCLSERVICE **ppInterface, bool fDaemonised)
 {
+    iOutputCount = determineOutputCount();
     (void)ppInterface;
     (void)fDaemonised;
+    int rc;
+    /* Do not acknowledge the first event we query for to pick up old events,
+     * e.g. from before a guest reboot. */
+    bool fAck = false;
     struct X11CONTEXT x11Context = { NULL };
-    unsigned i;
-    int rc;
-    struct X11VMWRECT aRects[VMW_MAX_HEADS];
-    unsigned cHeads;
-
-    if (checkRecentLinuxKernel())
-        return VINF_SUCCESS;
     x11Connect(&x11Context);
     if (x11Context.pDisplay == NULL)
         return VINF_SUCCESS;
+
+#ifndef USE_XRANDR_BIN
+    unsigned cHeads;
+    struct X11VMWRECT aRects[VMW_MAX_HEADS];
+    if (checkRecentLinuxKernel())
+        return VINF_SUCCESS;
+#else //#ifndef USE_XRANDR_BIN
+    static struct VMMDevDisplayDef aMonitors[VMW_MAX_HEADS];
+    struct DRMCONTEXT drmContext = { NIL_RTFILE };
+    drmConnect(&drmContext);
+    if (drmContext.hDevice == NIL_RTFILE)
+        return VINF_SUCCESS;
+    unsigned cEnabledMonitors = 0;
+#endif
+
     rc = VbglR3CtlFilterMask(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 0);
     if (RT_FAILURE(rc))
@@ -258 +645 @@
     if (RT_FAILURE(rc))
         VBClLogFatalError("Failed to register resizing support, rc=%Rrc\n", rc);
+
+    int eventMask = RRScreenChangeNotifyMask;
+    if (x11Context.hRandRMinor >= 2)
+        eventMask |=  RRCrtcChangeNotifyMask |
+            RROutputChangeNotifyMask |
+            RROutputPropertyNotifyMask;
+    if (x11Context.hRandRMinor >= 4)
+        eventMask |= RRProviderChangeNotifyMask |
+            RRProviderPropertyNotifyMask |
+            RRResourceChangeNotifyMask;
+    if (x11Context.hRandRMinor >= 6)
+        eventMask |= RRLeaseNotifyMask;
+
+
     for (;;)
     {
@@ -266 +667 @@
         /* Query the first size without waiting.  This lets us e.g. pick up
          * the last event before a guest reboot when we start again after. */
-        rc = VbglR3GetDisplayChangeRequestMulti(VMW_MAX_HEADS, &cDisplaysOut, aDisplays, true);
+        rc = VbglR3GetDisplayChangeRequestMulti(VMW_MAX_HEADS, &cDisplaysOut, aDisplays, fAck);
+        fAck = true;
+
         if (RT_FAILURE(rc))
             VBClLogFatalError("Failed to get display change request, rc=%Rrc\n", rc);
         if (cDisplaysOut > VMW_MAX_HEADS)
             VBClLogFatalError("Display change request contained, rc=%Rrc\n", rc);
-        for (i = 0, cHeads = 0; i < cDisplaysOut && i < VMW_MAX_HEADS; ++i)
+#ifndef USE_XRANDR_BIN
+        for (unsigned i = 0, cHeads = 0; i < cDisplaysOut && i < VMW_MAX_HEADS; ++i)
         {
             if (!(aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_DISABLED))
@@ -292 +696 @@
         x11SendHints(&x11Context, aRects, cHeads);
         x11GetScreenInfo(&x11Context);
-        rc = VbglR3WaitEvent(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, RT_INDEFINITE_WAIT, &events);
+#else
+        if (cDisplaysOut > 0)
+        {
+            for (unsigned i = 0; i < cDisplaysOut && i < VMW_MAX_HEADS; ++i)
+            {
+                uint32_t idDisplay = aDisplays[i].idDisplay;
+                if (idDisplay >= VMW_MAX_HEADS)
+                    continue;
+                aMonitors[idDisplay].fDisplayFlags = aDisplays[i].fDisplayFlags;
+                if (!(aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_DISABLED))
+                {
+                    if ((idDisplay == 0) || (aDisplays[i].fDisplayFlags & VMMDEV_DISPLAY_ORIGIN))
+                    {
+                        aMonitors[idDisplay].xOrigin = aDisplays[i].xOrigin;
+                        aMonitors[idDisplay].yOrigin = aDisplays[i].yOrigin;
+                    } else {
+                        aMonitors[idDisplay].xOrigin = aMonitors[idDisplay - 1].xOrigin + aMonitors[idDisplay - 1].cx;
+                        aMonitors[idDisplay].yOrigin = aMonitors[idDisplay - 1].yOrigin;
+                    }
+                    aMonitors[idDisplay].cx = aDisplays[i].cx;
+                    aMonitors[idDisplay].cy = aDisplays[i].cy;
+                }
+            }
+
+            /* Create a whole topology and send it to xrandr. */
+            struct RANDROUTPUT aOutputs[VMW_MAX_HEADS];
+            int iRunningX = 0;
+            for (int j = 0; j < iOutputCount; ++j)
+            {
+                aOutputs[j].x = iRunningX;
+                aOutputs[j].y = aMonitors[j].yOrigin;
+                aOutputs[j].width = aMonitors[j].cx;
+                aOutputs[j].height = aMonitors[j].cy;
+                aOutputs[j].fEnabled = !(aMonitors[j].fDisplayFlags & VMMDEV_DISPLAY_DISABLED);
+                if (aOutputs[j].fEnabled)
+                    iRunningX += aOutputs[j].width;
+            }
+            setXrandrModes(aOutputs);
+            /* Disable this for now since we want to fix messed up monitor positions in some other way. */
+            if(0)
+            {
+                /* Additionally update the drm thru ioctl since vmwgfx messes up monitor positions it gets from xserver. */
+                /* Create an dense (consisting of enabled monitors only) array to pass to DRM. */
+                cEnabledMonitors = 0;
+                struct DRMVMWRECT aEnabledMonitors[VMW_MAX_HEADS];
+                for (int j = 0; j < VMW_MAX_HEADS; ++j)
+                {
+                    if (!(aMonitors[j].fDisplayFlags & VMMDEV_DISPLAY_DISABLED))
+                    {
+                        aEnabledMonitors[cEnabledMonitors].x = aMonitors[j].xOrigin;
+                        aEnabledMonitors[cEnabledMonitors].y = aMonitors[j].yOrigin;
+                        aEnabledMonitors[cEnabledMonitors].w = aMonitors[j].cx;
+                        aEnabledMonitors[cEnabledMonitors].h = aMonitors[j].cy;
+                        if (cEnabledMonitors > 0)
+                            aEnabledMonitors[cEnabledMonitors].x = aEnabledMonitors[cEnabledMonitors - 1].x + aEnabledMonitors[cEnabledMonitors - 1].w;
+                        ++cEnabledMonitors;
+                    }
+                }
+                bool fScreenChangeNotifyEvent = false;
+                XRRSelectInput(x11Context.pDisplay, x11Context.rootWindow, eventMask);
+                XSync(x11Context.pDisplay, false);
+                XEvent event;
+                while (XCheckTypedEvent(x11Context.pDisplay, RRScreenChangeNotify + x11Context.hRandREventBase, &event) ||
+                       XCheckTypedEvent(x11Context.pDisplay, RRNotify + x11Context.hRandREventBase, &event))
+                    fScreenChangeNotifyEvent = true;
+                XRRSelectInput(x11Context.pDisplay, x11Context.rootWindow, 0);
+
+                if (!fScreenChangeNotifyEvent)
+                    VBClLogInfo("Did not receive any RRScreenChangeNotify events.\n");
+                else
+                    drmSendHints(&drmContext, aEnabledMonitors, cEnabledMonitors);
+            }
+        }
+
+#endif
+        do
+        {
+            rc = VbglR3WaitEvent(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, RT_INDEFINITE_WAIT, &events);
+        } while (rc == VERR_INTERRUPTED);
         if (RT_FAILURE(rc))
             VBClLogFatalError("Failure waiting for event, rc=%Rrc\n", rc);