Changeset 33988 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

Timestamp:

Nov 11, 2010 1:03:17 PM (14 years ago)

Author:

vboxsync

Message:

crOpenGL/wddm: more multithreading fixes, vista expirience index works now

Location:

trunk/src/VBox/HostServices/SharedOpenGL

Files:

• crserver/crservice.cpp (modified) (2 diffs)
• crserverlib/server_context.c (modified) (4 diffs)
• crserverlib/server_main.c (modified) (11 diffs)
• crserverlib/server_stream.c (modified) (4 diffs)
• crserverlib/server_window.c (modified) (5 diffs)

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

@@ -463 +463 @@
         }
 
+        case SHCRGL_GUEST_FN_SET_PID:
+        {
+            Log(("svcCall: SHCRGL_GUEST_FN_SET_PID\n"));
+
+            /* Verify parameter count and types. */
+            if (cParms != SHCRGL_CPARMS_SET_PID)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            if (paParms[0].type != VBOX_HGCM_SVC_PARM_64BIT)
+            {
+                rc = VERR_INVALID_PARAMETER;
+            }
+            else
+            {
+                /* Fetch parameters. */
+                uint64_t pid    = paParms[0].u.uint64;
+
+                /* Execute the function. */
+                rc = crVBoxServerClientSetPID(u32ClientID, pid);
+            }
+
+            break;
+        }
+
         default:
         {
@@ -675 +701 @@
 
         case SHCRGL_GUEST_FN_SET_VERSION:
+        {
+            Assert(0);
+            rc = VERR_NOT_IMPLEMENTED;
+            break;
+        }
+
+        case SHCRGL_GUEST_FN_SET_PID:
         {
             Assert(0);

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

@@ -111 +111 @@
 }
 
+static int crServerRemoveClientContext(CRClient *pClient, GLint ctx)
+{
+    int pos;
+
+    for (pos = 0; pos < CR_MAX_CONTEXTS; ++pos)
+    {
+        if (pClient->contextList[pos] == ctx)
+        {
+            pClient->contextList[pos] = 0;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void SERVER_DISPATCH_APIENTRY
 crServerDispatchDestroyContext( GLint ctx )
 {
     CRContext *crCtx;
+    int32_t client;
+    CRClientNode *pNode;
+    int found=false;
 
     crCtx = (CRContext *) crHashtableSearch(cr_server.contextTable, ctx);
@@ -130 +149 @@
     if (cr_server.curClient)
     {
-        int32_t pos;
-
         /* If we delete our current context, default back to the null context */
         if (cr_server.curClient->currentCtx == crCtx) {
@@ -138 +155 @@
         }
 
-        for (pos = 0; pos < CR_MAX_CONTEXTS; ++pos)
-            if (cr_server.curClient->contextList[pos] == ctx)
-            {
-                cr_server.curClient->contextList[pos] = 0;
-                break;
-            }
+        found = crServerRemoveClientContext(cr_server.curClient, ctx);
 
         /*Some application call destroy context not in a thread where it was created...have do deal with it.*/
-        if (CR_MAX_CONTEXTS==pos)
-        {
-            int32_t client;
-
+        if (!found)
+        {
             for (client=0; client<cr_server.numClients; ++client)
             {
@@ -155 +165 @@
                     continue;
 
-                for (pos = 0; pos < CR_MAX_CONTEXTS; ++pos)
-                    if (cr_server.clients[client]->contextList[pos] == ctx)
-                    {
-                        cr_server.clients[client]->contextList[pos] = 0;
-                        break;
-                    }
-
-                if (pos<CR_MAX_CONTEXTS)
-                {
-                    if (cr_server.clients[client]->currentCtx == crCtx)
-                    {
-                        cr_server.clients[client]->currentContextNumber = -1;
-                        cr_server.clients[client]->currentCtx = cr_server.DummyContext;
-                    }
-                    break;
-                }
+                found = crServerRemoveClientContext(cr_server.clients[client], ctx);
+
+                if (found) break;
             }
         }
 
-        CRASSERT(pos<CR_MAX_CONTEXTS);
+        if (!found)
+        {
+            pNode=cr_server.pCleanupClient;
+
+            while (pNode && !found)
+            {
+                found = crServerRemoveClientContext(pNode->pClient, ctx);
+                pNode = pNode->next;
+            }
+        }
+
+        CRASSERT(found);
+    }
+
+    /*Make sure this context isn't active in other clients*/
+    for (client=0; client<cr_server.numClients; ++client)
+    {
+        if (cr_server.clients[client]->currentCtx == crCtx)
+        {
+            cr_server.clients[client]->currentContextNumber = -1;
+            cr_server.clients[client]->currentCtx = cr_server.DummyContext;
+        }
+    }
+
+    pNode=cr_server.pCleanupClient;
+    while (pNode)
+    {
+        if (pNode->pClient->currentCtx == crCtx)
+        {
+            pNode->pClient->currentContextNumber = -1;
+            pNode->pClient->currentCtx = cr_server.DummyContext;
+        }
+        pNode = pNode->next;
     }
 }

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

@@ -78 +78 @@
 {
     GLint i;
+    CRClientNode *pNode, *pNext;
 
     /* avoid a race condition */
@@ -119 +120 @@
     }
     cr_server.numClients = 0;
+
+    pNode = cr_server.pCleanupClient;
+    while (pNode)
+    {
+        pNext=pNode->next;
+        crFree(pNode->pClient);
+        crFree(pNode);
+        pNode=pNext;
+    }
+    cr_server.pCleanupClient = NULL;
 
 #if 1
@@ -289 +300 @@
     cr_server.bIsInLoadingState = GL_FALSE;
     cr_server.bIsInSavingState  = GL_FALSE;
+
+    cr_server.pCleanupClient = NULL;
 
     /*
@@ -358 +371 @@
 void crVBoxServerRemoveClient(uint32_t u32ClientID)
 {
-    CRClient *pClient;
+    CRClient *pClient=NULL;
     int32_t i;
 
@@ -368 +381 @@
             && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
         {
+            pClient = cr_server.clients[i];
             break;
         }
     }
-    pClient = cr_server.clients[i];
-    CRASSERT(pClient);
+    //if (!pClient) return VERR_INVALID_PARAMETER;
+    if (!pClient)
+    {
+        crWarning("Invalid client id %u passed to crVBoxServerRemoveClient", u32ClientID);
+        return;
+    }
 
     /* Disconnect the client */
@@ -475 +493 @@
 int32_t crVBoxServerClientRead(uint32_t u32ClientID, uint8_t *pBuffer, uint32_t *pcbBuffer)
 {
-    CRClient *pClient;
+    CRClient *pClient=NULL;
     int32_t i;
 
@@ -485 +503 @@
             && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
         {
+            pClient = cr_server.clients[i];
             break;
         }
     }
-    pClient = cr_server.clients[i];
-    CRASSERT(pClient);
+    if (!pClient) return VERR_INVALID_PARAMETER;    
 
     if (!pClient->conn->vMajor) return VERR_NOT_SUPPORTED;
@@ -519 +537 @@
 int32_t crVBoxServerClientSetVersion(uint32_t u32ClientID, uint32_t vMajor, uint32_t vMinor)
 {
-    CRClient *pClient;
+    CRClient *pClient=NULL;
     int32_t i;
 
@@ -527 +545 @@
             && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
         {
+            pClient = cr_server.clients[i];
             break;
         }
     }
-    pClient = cr_server.clients[i];
-    CRASSERT(pClient);
+    if (!pClient) return VERR_INVALID_PARAMETER;
 
     pClient->conn->vMajor = vMajor;
@@ -542 +560 @@
     }
     else return VINF_SUCCESS;
+}
+
+int32_t crVBoxServerClientSetPID(uint32_t u32ClientID, uint64_t pid)
+{
+    CRClient *pClient=NULL;
+    int32_t i;
+
+    for (i = 0; i < cr_server.numClients; i++)
+    {
+        if (cr_server.clients[i] && cr_server.clients[i]->conn
+            && cr_server.clients[i]->conn->u32ClientID==u32ClientID)
+        {
+            pClient = cr_server.clients[i];
+            break;
+        }
+    }
+    if (!pClient) return VERR_INVALID_PARAMETER;
+
+    pClient->pid = pid;
+
+    return VINF_SUCCESS;
 }
 
@@ -722 +761 @@
     /* Save cr_server.muralTable
      * @todo we don't need it all, just geometry info actually
-     * @todo store visible regions as well
      */
     ui32 = crHashtableNumElements(cr_server.muralTable);

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

@@ -109 +109 @@
 }
 
-
+static void crServerCleanupClient(CRClient *client)
+{
+    int32_t pos;
+    CRClient *oldclient = cr_server.curClient;
+
+    cr_server.curClient = client;
+
+    /* Destroy any windows created by the client */
+    for (pos = 0; pos<CR_MAX_WINDOWS && client->windowList[pos]; pos++) 
+    {
+        cr_server.dispatch.WindowDestroy(client->windowList[pos]);
+    }
+
+    /* Check if we have context(s) made by this client left, could happen if client side code is lazy */
+    for (pos = 0; pos<CR_MAX_CONTEXTS && client->contextList[pos]; pos++) 
+    {
+        cr_server.dispatch.DestroyContext(client->contextList[pos]);
+    }
+
+    cr_server.curClient = oldclient;
+}
+
+static void crServerCleanupByPID(uint64_t pid)
+{
+    CRClientNode *pNode=cr_server.pCleanupClient, *pNext;
+
+    while (pNode)
+    {
+        if (pNode->pClient->pid==pid)
+        {
+            crServerCleanupClient(pNode->pClient);
+            crFree(pNode->pClient);
+            if (pNode->prev)
+            {
+                pNode->prev->next=pNode->next;
+            }
+            else
+            {
+                cr_server.pCleanupClient=pNode->next;
+            }
+            if (pNode->next)
+            {
+                pNode->next->prev = pNode->prev;
+            }
+
+            pNext=pNode->next;
+            crFree(pNode);
+            pNode=pNext;
+        }
+        else
+        {
+            pNode=pNode->next;
+        }
+    }
+}
 
 void
@@ -115 +169 @@
 {
     int i, j;
-    int32_t pos;
-    CRClient *oldclient = cr_server.curClient;
+    int cleanup=1;
 
     crDebug("Deleting client %p (%d msgs left)", client, crNetNumMessages(client->conn));
@@ -143 +196 @@
     }
 
-    cr_server.curClient = client;
-
-    /* Destroy any windows created by the client */
-    for (pos = 0; pos<CR_MAX_WINDOWS && client->windowList[pos]; pos++) 
-    {
-        cr_server.dispatch.WindowDestroy(client->windowList[pos]);
-    }
-
-    /* Check if we have context(s) made by this client left, could happen if client side code is lazy */
-    for (pos = 0; pos<CR_MAX_CONTEXTS && client->contextList[pos]; pos++) 
-    {
-        cr_server.dispatch.DestroyContext(client->contextList[pos]);
-    }
-
-    cr_server.curClient = oldclient;
+    /* check if there're any other guest threads in same process */
+    for (i=0; i < cr_server.numClients; i++)
+    {
+        if (cr_server.clients[i]->pid==client->pid)
+        {
+            cleanup=0;
+            break;
+        }
+    }
+
+    if (cleanup)
+    {
+        crServerCleanupClient(client);
+    }
 
     /* remove from the run queue */
@@ -195 +247 @@
 
     crNetFreeConnection(client->conn);
-
-    crFree(client);
-}
-
+    client->conn = NULL;
+
+    if (cleanup)
+    {
+        crServerCleanupByPID(client->pid);
+        crFree(client);
+    }
+    else
+    {
+        CRClientNode *pNode = (CRClientNode *)crAlloc(sizeof(CRClientNode));
+        if (!pNode)
+        {
+            crWarning("Not enough memory, forcing client cleanup");
+            crServerCleanupClient(client);
+            crServerCleanupByPID(client->pid);
+            crFree(client);
+            return;
+        }
+        pNode->pClient = client;
+        pNode->prev = NULL;
+        pNode->next = cr_server.pCleanupClient;
+        cr_server.pCleanupClient = pNode;
+    }
+}
 
 /**

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

@@ -117 +117 @@
 }
 
+static int crServerRemoveClientWindow(CRClient *pClient, GLint window)
+{
+    int pos;
+
+    for (pos = 0; pos < CR_MAX_WINDOWS; ++pos)
+    {
+        if (pClient->windowList[pos] == window)
+        {
+            pClient->windowList[pos] = 0;
+            return true;
+        }
+    }
+
+    return false;
+}
+
 void SERVER_DISPATCH_APIENTRY
 crServerDispatchWindowDestroy( GLint window )
@@ -122 +138 @@
     CRMuralInfo *mural;
     int32_t client;
-    int pos;
+    CRClientNode *pNode;
+    int found=false;
 
     mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
@@ -148 +165 @@
         }
 
-        for (pos = 0; pos < CR_MAX_WINDOWS; ++pos)
-            if (cr_server.curClient->windowList[pos] == window)
-            {
-                cr_server.curClient->windowList[pos] = 0;
-                break;
-            }
+        found = crServerRemoveClientWindow(cr_server.curClient, window);
 
         /*Same as with contexts, some apps destroy it not in a thread where it was created*/
-        if (CR_MAX_WINDOWS==pos)
+        if (!found)
         {
             for (client=0; client<cr_server.numClients; ++client)
@@ -163 +175 @@
                     continue;
 
-                for (pos = 0; pos < CR_MAX_WINDOWS; ++pos)
-                    if (cr_server.clients[client]->windowList[pos] == window)
-                    {
-                        cr_server.clients[client]->windowList[pos] = 0;
-                        break;
-                    }
-
-                if (pos<CR_MAX_WINDOWS)
-                {
-                    if (cr_server.clients[client]->currentMural == mural)
-                    {
-                        cr_server.clients[client]->currentMural = NULL;
-                        cr_server.clients[client]->currentWindow = -1;
-                    }
-                    break;
-                }
-            }
-        }
-
-        CRASSERT(pos<CR_MAX_WINDOWS);
+                found = crServerRemoveClientWindow(cr_server.clients[client], window);
+
+                if (found) break;
+            }
+        }
+
+        if (!found)
+        {
+            pNode=cr_server.pCleanupClient;
+
+            while (pNode && !found)
+            {
+                found = crServerRemoveClientWindow(pNode->pClient, window);
+                pNode = pNode->next;
+            }
+        }
+
+        CRASSERT(found);
     }
 
@@ -195 +205 @@
     }
 
+    pNode=cr_server.pCleanupClient;
+    while (pNode)
+    {
+        if (pNode->pClient->currentMural == mural)
+        {
+            pNode->pClient->currentMural = NULL;
+            pNode->pClient->currentWindow = -1;
+        }
+        pNode = pNode->next;
+    }
+
     crHashtableDelete(cr_server.pWindowCreateInfoTable, window, crServerCreateInfoDeleteCB);