Changeset 35770 in vbox for trunk/src

Timestamp:

Jan 28, 2011 3:23:22 PM (14 years ago)

Author:

vboxsync

Message:

crOpenGL: fix deadlock with multiply screens (#5462)

Location:

trunk/src/VBox/HostServices/SharedOpenGL

Files:

• crserver/crservice.cpp (modified) (6 diffs)
• crserverlib/server_muralfbo.c (modified) (4 diffs)

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -58 +58 @@
 
 #include <VBox/com/errorprint.h>
+#include <iprt/thread.h>
+#include <iprt/critsect.h>
+#include <iprt/semaphore.h>
+#include <iprt/asm.h>
+
+#include "cr_mem.h"
 
 PVBOXHGCMSVCHELPERS g_pHelpers;
@@ -73 +79 @@
 static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
 
+/* Used to process guest calls exceeding maximum allowed HGCM call size in a sequence of smaller calls */
 typedef struct _CRVBOXSVCBUFFER_t {
     uint32_t uiId;
@@ -83 +90 @@
 static uint32_t g_CRVBoxSVCBufferID = 0;
 
+/* svcPresentFBO related data */
+typedef struct _CRVBOXSVCPRESENTFBOCMD_t {
+    void *pData;
+    int32_t screenId, x, y, w, h;
+    _CRVBOXSVCPRESENTFBOCMD_t *pNext;
+} CRVBOXSVCPRESENTFBOCMD_t, *PCRVBOXSVCPRESENTFBOCMD_t;
+
+typedef struct _CRVBOXSVCPRESENTFBO_t {
+    PCRVBOXSVCPRESENTFBOCMD_t pQueueHead, pQueueTail;   /* Head/Tail of FIFO cmds queue */
+    RTCRITSECT                hQueueLock;       /* Queue lock */
+    RTTHREAD                  hWorkerThread;    /* Worker thread */
+    bool volatile             bShutdownWorker;  /* Shutdown flag */
+    RTSEMEVENT                hEventProcess;    /* Signalled when worker thread should process data or exit */
+} CRVBOXSVCPRESENTFBO_t;
+
+static CRVBOXSVCPRESENTFBO_t g_SvcPresentFBO;
+
+/* Schedule a call to a separate worker thread to avoid deadlock on EMT thread when the screen configuration changes
+   and we're processing crServerPresentFBO caused by guest application command.
+   To avoid unnecessary memcpy, worker thread frees the data passed.
+*/
+static DECLCALLBACK(void) svcPresentFBO(void *data, int32_t screenId, int32_t x, int32_t y, uint32_t w, uint32_t h)
+{
+    PCRVBOXSVCPRESENTFBOCMD_t pCmd;
+
+    pCmd = (PCRVBOXSVCPRESENTFBOCMD_t) RTMemAlloc(sizeof(CRVBOXSVCPRESENTFBOCMD_t));
+    if (!pCmd)
+    {
+        LogRel(("SHARED_CROPENGL svcPresentFBO: not enough memory (%d)\n", sizeof(CRVBOXSVCPRESENTFBOCMD_t)));
+        return;
+    }
+    pCmd->pData = data;
+    pCmd->screenId = screenId;
+    pCmd->x = x;
+    pCmd->y = y;
+    pCmd->w = w;
+    pCmd->h = h;
+    pCmd->pNext = NULL;
+
+    RTCritSectEnter(&g_SvcPresentFBO.hQueueLock);
+
+    if (g_SvcPresentFBO.pQueueTail)
+    {
+        g_SvcPresentFBO.pQueueTail->pNext = pCmd;
+    }
+    else
+    {
+        Assert(!g_SvcPresentFBO.pQueueHead);
+        g_SvcPresentFBO.pQueueHead = pCmd;
+    }
+    g_SvcPresentFBO.pQueueTail = pCmd;
+
+    RTCritSectLeave(&g_SvcPresentFBO.hQueueLock);
+
+    RTSemEventSignal(g_SvcPresentFBO.hEventProcess);
+    /*
+    HRESULT rc;
+    ComPtr<IDisplay> pDisplay;
+
+    CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
+    CHECK_ERROR(pDisplay, DrawToScreen(screenId, (BYTE*)data, x, y, w, h));
+    */
+}
+
+static DECLCALLBACK(int) svcPresentFBOWorkerThreadProc(RTTHREAD ThreadSelf, void *pvUser)
+{
+    int rc = VINF_SUCCESS;
+    PCRVBOXSVCPRESENTFBOCMD_t pCmd;
+
+    Log(("SHARED_CROPENGL svcPresentFBOWorkerThreadProc started\n"));
+
+    for (;;)
+    {
+        rc = RTSemEventWait(g_SvcPresentFBO.hEventProcess, RT_INDEFINITE_WAIT);
+        AssertRCReturn(rc, rc);
+
+        if (g_SvcPresentFBO.bShutdownWorker)
+        {
+            break;
+        }
+
+        rc = RTCritSectEnter(&g_SvcPresentFBO.hQueueLock);
+        AssertRCReturn(rc, rc);
+
+        pCmd = g_SvcPresentFBO.pQueueHead;
+        while (pCmd)
+        {
+            ComPtr<IDisplay> pDisplay;
+
+            /*remove from queue*/
+            g_SvcPresentFBO.pQueueHead = pCmd->pNext;
+            if (!g_SvcPresentFBO.pQueueHead)
+            {
+                g_SvcPresentFBO.pQueueTail = NULL;
+            }
+
+            CHECK_ERROR_RET(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()), rc);
+
+            RTCritSectLeave(&g_SvcPresentFBO.hQueueLock);
+
+            CHECK_ERROR_RET(pDisplay, DrawToScreen(pCmd->screenId, (BYTE*)pCmd->pData, pCmd->x, pCmd->y, pCmd->w, pCmd->h), rc);
+
+            crFree(pCmd->pData);
+            RTMemFree(pCmd);
+
+            rc = RTCritSectEnter(&g_SvcPresentFBO.hQueueLock);
+            AssertRCReturn(rc, rc);
+            pCmd = g_SvcPresentFBO.pQueueHead;
+        }
+
+        RTCritSectLeave(&g_SvcPresentFBO.hQueueLock);
+    }
+
+    Log(("SHARED_CROPENGL svcPresentFBOWorkerThreadProc finished\n"));
+
+    return rc;
+}
+
+static int svcPresentFBOInit(void)
+{
+    int rc = VINF_SUCCESS;
+
+    g_SvcPresentFBO.pQueueHead = NULL;
+    g_SvcPresentFBO.pQueueTail = NULL;
+    g_SvcPresentFBO.bShutdownWorker = false;
+
+    rc = RTCritSectInit(&g_SvcPresentFBO.hQueueLock);
+    AssertRCReturn(rc, rc);
+
+    rc = RTSemEventCreate(&g_SvcPresentFBO.hEventProcess);
+    AssertRCReturn(rc, rc);
+
+    rc = RTThreadCreate(&g_SvcPresentFBO.hWorkerThread, svcPresentFBOWorkerThreadProc, NULL, 0,
+                        RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "OpenGLWorker");
+    AssertRCReturn(rc, rc);
+
+    crVBoxServerSetPresentFBOCB(svcPresentFBO);
+
+    return rc;
+}
+
+static int svcPresentFBOTearDown(void)
+{
+    int rc = VINF_SUCCESS;
+    PCRVBOXSVCPRESENTFBOCMD_t pQueue, pTmp;
+
+    ASMAtomicWriteBool(&g_SvcPresentFBO.bShutdownWorker, true);
+    RTSemEventSignal(g_SvcPresentFBO.hEventProcess);
+    rc = RTThreadWait(g_SvcPresentFBO.hWorkerThread, 5000, NULL);
+    AssertRCReturn(rc, rc);
+
+    RTCritSectDelete(&g_SvcPresentFBO.hQueueLock);
+    RTSemEventDestroy(g_SvcPresentFBO.hEventProcess);
+
+    pQueue = g_SvcPresentFBO.pQueueHead;
+    while (pQueue)
+    {
+        pTmp = pQueue->pNext;
+        crFree(pQueue->pData);
+        RTMemFree(pQueue);
+        pQueue = pTmp;
+    }
+    g_SvcPresentFBO.pQueueHead = NULL;
+    g_SvcPresentFBO.pQueueTail = NULL;
+
+    return rc;
+}
+
 static DECLCALLBACK(int) svcUnload (void *)
 {
@@ -90 +265 @@
 
     crVBoxServerTearDown();
+
+    svcPresentFBOTearDown();
 
     return rc;
@@ -303 +480 @@
         shown = 1;
     }
-}
-
-static DECLCALLBACK(void) svcPresentFBO(void *data, int32_t screenId, int32_t x, int32_t y, uint32_t w, uint32_t h)
-{
-#if 0
-    ComPtr<IDisplay> pDisplay;
-    BYTE *data;
-    int i,j;
-    CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
-
-    data = (BYTE*) RTMemTmpAllocZ(100*100*4);
-
-    for (i=0; i<100; i+=2)
-    {
-        for (j=0; j<100; ++j)
-        {
-            *(data+i*100*4+j*4+0) = 0xFF;
-            *(data+i*100*4+j*4+1) = 0xFF;
-            *(data+i*100*4+j*4+2) = 0xFF;
-            *(data+i*100*4+j*4+3) = 0xFF;
-        }
-    }
-
-    CHECK_ERROR(pDisplay, DrawToScreen(screenId, data, 0, 0, 100, 100));
-
-    RTMemTmpFree(data);
-#endif
-    HRESULT rc;
-    ComPtr<IDisplay> pDisplay;
-
-    CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
-    CHECK_ERROR(pDisplay, DrawToScreen(screenId, (BYTE*)data, x, y, w, h));
 }
 
@@ -1258 +1403 @@
                 return VERR_NOT_SUPPORTED;
 
-            crVBoxServerSetPresentFBOCB(svcPresentFBO);
+            rc = svcPresentFBOInit();
         }
     }

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.c

@@ -337 +337 @@
         if (crServerIntersectScreen(mural, i, &rect))
         {
-            tmppixels = crAlloc(4*(rect.x2-rect.x1)*(rect.y2-rect.y1));
-            if (!tmppixels)
-            {
-                crWarning("Out of memory in crServerPresentFBO");
-                crFree(pixels);
-                return;
-            }
-
             /* rect in window relative coords */
             crServerTransformRect(&rectwr, &rect, -mural->gX, -mural->gY);
@@ -350 +342 @@
             if (!mural->pVisibleRects)
             {
+                tmppixels = crAlloc(4*(rect.x2-rect.x1)*(rect.y2-rect.y1));
+                if (!tmppixels)
+                {
+                    crWarning("Out of memory in crServerPresentFBO");
+                    crFree(pixels);
+                    return;
+                }
+
                 crServerCopySubImage(tmppixels, pixels, &rectwr, mural->fboWidth, mural->fboHeight);
+                /*Note: pfnPresentFBO would free tmppixels*/
                 cr_server.pfnPresentFBO(tmppixels, i, rect.x1-cr_server.screen[i].x, rect.y1-cr_server.screen[i].y, rect.x2-rect.x1, rect.y2-rect.y1);
             }
@@ -359 +360 @@
                     if (crServerIntersectRect(&rectwr, (CRrecti*) &mural->pVisibleRects[4*j], &sectr))
                     {
+                        tmppixels = crAlloc(4*(sectr.x2-sectr.x1)*(sectr.y2-sectr.y1));
+                        if (!tmppixels)
+                        {
+                            crWarning("Out of memory in crServerPresentFBO");
+                            crFree(pixels);
+                            return;
+                        }
+
                         crServerCopySubImage(tmppixels, pixels, &sectr, mural->fboWidth, mural->fboHeight);
+                        /*Note: pfnPresentFBO would free tmppixels*/
                         cr_server.pfnPresentFBO(tmppixels, i,
                                                 sectr.x1+mural->gX-cr_server.screen[i].x,
@@ -367 +377 @@
                 }
             }
-
-            crFree(tmppixels);
         }
     }