Changeset 52260 in vbox

Timestamp:

Aug 4, 2014 11:59:46 AM (11 years ago)

Author:

vboxsync

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

95357

Message:

crOpenGL: proper support of GetErr being called from display list, better error handling

Location:

trunk

Files:

• . (modified) (1 prop)
• src/VBox (modified) (1 prop)
• src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c (modified) (1 diff)
• src/VBox/Additions/common/crOpenGL/pack/packspu_special (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/include/cr_pack.h (modified) (4 diffs)
• src/VBox/GuestHost/OpenGL/include/cr_server.h (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/packer/pack_beginend.c (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/packer/pack_lists.c (modified) (1 diff)
• src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_lists.c (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (2 diffs)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_retval.py (modified) (1 diff)
• src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.c (modified) (2 diffs)

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

@@ -206 +206 @@
         crUnlockMutex(&_PackMutex);
     }
+}
+
+void PACKSPU_APIENTRY packspu_NewList(GLuint list, GLenum mode)
+{
+    crStateNewList(list, mode);
+    crPackNewList(list, mode);
+}
+
+void PACKSPU_APIENTRY packspu_EndList()
+{
+    crStateEndList();
+    crPackEndList();
 }
 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special

@@ -134 +134 @@
 GenTextures
 CompileShader
+NewList
+EndList

trunk/src/VBox/GuestHost/OpenGL/include/cr_pack.h

@@ -252 +252 @@
   } while (0)
 
+#define CR_CMDBLOCK_IS_STARTED( pc, op )  CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, op)
 
 #define CR_CMDBLOCK_BEGIN( pc, op )                                 \
@@ -257 +258 @@
     CR_LOCK_PACKER_CONTEXT(pc);                                     \
     if (!cr_packer_cmd_blocks_enabled) break;                       \
-    if (!CRPACKBLOCKSTATE_IS_STARTED(pc->u32CmdBlockState)) {       \
+    if (!CRPACKBLOCKSTATE_IS_STARTED((pc)->u32CmdBlockState)) {       \
       THREADASSERT( pc );                                           \
-      CRASSERT( pc->currentBuffer );                                \
-      if (!crPackBufferIsEmpty(&pc->buffer)) {                      \
-        if ((*pc->buffer.opcode_start) != CR_NOP_OPCODE) {          \
-          pc->Flush( pc->flush_arg );                               \
-          Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                 \
-          CR_CMDBLOCK_OP( pc, CR_CMDBLOCKBEGIN_OPCODE );            \
+      CRASSERT( (pc)->currentBuffer );                                \
+      if (!crPackBufferIsEmpty(&(pc)->buffer)) {                      \
+        if ((*(pc)->buffer.opcode_start) != CR_NOP_OPCODE) {          \
+          (pc)->Flush( (pc)->flush_arg );                               \
+          Assert(crPackCanHoldOpcode( (pc), 1, 4 ) );                 \
+          CR_CMDBLOCK_OP( (pc), CR_CMDBLOCKBEGIN_OPCODE );            \
         }                                                           \
         else {                                                      \
-          (*pc->buffer.opcode_start) = CR_CMDBLOCKBEGIN_OPCODE;     \
+          (*(pc)->buffer.opcode_start) = CR_CMDBLOCKBEGIN_OPCODE;     \
         }                                                           \
       }                                                             \
       else {                                                        \
-        Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                   \
-        CR_CMDBLOCK_OP( pc, CR_CMDBLOCKBEGIN_OPCODE );              \
+        Assert(crPackCanHoldOpcode( (pc), 1, 4 ) );                   \
+        CR_CMDBLOCK_OP( (pc), CR_CMDBLOCKBEGIN_OPCODE );              \
       }                                                             \
     }                                                               \
-    CRPACKBLOCKSTATE_OP_START(pc->u32CmdBlockState, op);            \
+    Assert(!CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, op)); \
+    CRPACKBLOCKSTATE_OP_START((pc)->u32CmdBlockState, op);            \
+    Assert(CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, op)); \
   } while (0)
 
@@ -281 +284 @@
   do {                                                              \
     if (!cr_packer_cmd_blocks_enabled) break;                       \
-    CRPACKBLOCKSTATE_OP_STOP(pc->u32CmdBlockState, op);             \
-    if (!CRPACKBLOCKSTATE_IS_STARTED(pc->u32CmdBlockState)) {       \
+    Assert(CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, op)); \
+    CRPACKBLOCKSTATE_OP_STOP((pc)->u32CmdBlockState, op);             \
+    Assert(!CRPACKBLOCKSTATE_IS_OP_STARTED((pc)->u32CmdBlockState, op)); \
+    if (!CRPACKBLOCKSTATE_IS_STARTED((pc)->u32CmdBlockState)) {     \
       THREADASSERT( pc );                                           \
-      CRASSERT( pc->currentBuffer );                                \
-      if (!crPackBufferIsEmpty(&pc->buffer)) {                      \
-        if ((*pc->buffer.opcode_start) != CR_CMDBLOCKBEGIN_OPCODE) {\
+      CRASSERT( (pc)->currentBuffer );                              \
+      if (!crPackBufferIsEmpty(&(pc)->buffer)) {                    \
+        if ((*(pc)->buffer.opcode_start) != CR_CMDBLOCKBEGIN_OPCODE) {\
           if ( !crPackCanHoldOpcode( pc, 1, 4 ) ) {                 \
-            pc->Flush( pc->flush_arg );                             \
+            (pc)->Flush( (pc)->flush_arg );                         \
             Assert(crPackCanHoldOpcode( pc, 1, 4 ) );               \
           }                                                         \
           CR_CMDBLOCK_OP( pc, CR_CMDBLOCKEND_OPCODE );              \
-          pc->Flush( pc->flush_arg );                               \
+          (pc)->Flush( (pc)->flush_arg );                           \
         }                                                           \
         else {                                                      \
-          (*pc->buffer.opcode_start) = CR_NOP_OPCODE;               \
+          (*(pc)->buffer.opcode_start) = CR_NOP_OPCODE;             \
         }                                                           \
       }                                                             \
@@ -301 +306 @@
         Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                   \
         CR_CMDBLOCK_OP( pc, CR_CMDBLOCKEND_OPCODE );                \
-        pc->Flush( pc->flush_arg );                                 \
+        (pc)->Flush( pc->flush_arg );                               \
       }                                                             \
     }                                                               \

trunk/src/VBox/GuestHost/OpenGL/include/cr_server.h

@@ -356 +356 @@
 
     GLboolean fCrCmdEnabled;
+
+    GLboolean fProcessingPendedCommands;
 
     int numClients;

trunk/src/VBox/GuestHost/OpenGL/packer/pack_beginend.c

@@ -13 +13 @@
     unsigned char *data_ptr;
     (void) pc;
+
+    if (CR_CMDBLOCK_IS_STARTED(pc, CRPACKBLOCKSTATE_OP_BEGIN))
+    {
+        WARN(("recursive begin?"));
+        return;
+    }
 
     CR_CMDBLOCK_BEGIN( pc, CRPACKBLOCKSTATE_OP_BEGIN );

trunk/src/VBox/GuestHost/OpenGL/packer/pack_lists.c

@@ -64 +64 @@
     unsigned char *data_ptr;
     (void) pc;
+
+    if (CR_CMDBLOCK_IS_STARTED(pc, CRPACKBLOCKSTATE_OP_NEWLIST))
+    {
+        WARN(("recursive NewList?"));
+        return;
+    }
+
     CR_CMDBLOCK_BEGIN( pc, CRPACKBLOCKSTATE_OP_NEWLIST );
     CR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH( pc, 16, GL_FALSE );

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_lists.c

@@ -174 +174 @@
     CRStateBits *sb = GetCurrentBits();
     CRbitvalue *bitID=g->bitid, *negbitID=g->neg_bitid;
+
+    CRASSERT(g_bVBoxEnableDiffOnMakeCurrent);
 
     if (CHECKDIRTY(sb->buffer.dirty, negbitID))

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

@@ -71 +71 @@
 static void crServerQueryHWState()
 {
-    GLuint fbFbo, bbFbo;
-    CRClient *client = cr_server.curClient;
-    CRMuralInfo *mural = client ? client->currentMural : NULL;
-    if (mural && mural->fRedirected)
-    {
-        fbFbo = mural->aidFBOs[CR_SERVER_FBO_FB_IDX(mural)];
-        bbFbo = mural->aidFBOs[CR_SERVER_FBO_BB_IDX(mural)];
-    }
-    else
-    {
-        fbFbo = bbFbo = 0;
-    }
-    crStateQueryHWState(fbFbo, bbFbo);
+    if (!cr_server.bUseMultipleContexts)
+    {
+        GLuint fbFbo, bbFbo;
+        CRClient *client = cr_server.curClient;
+        CRMuralInfo *mural = client ? client->currentMural : NULL;
+        if (mural && mural->fRedirected)
+        {
+            fbFbo = mural->aidFBOs[CR_SERVER_FBO_FB_IDX(mural)];
+            bbFbo = mural->aidFBOs[CR_SERVER_FBO_BB_IDX(mural)];
+        }
+        else
+        {
+            fbFbo = bbFbo = 0;
+        }
+        crStateQueryHWState(fbFbo, bbFbo);
+    }
 }
 

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

@@ -384 +384 @@
 
     cr_server.fCrCmdEnabled = GL_FALSE;
+    cr_server.fProcessingPendedCommands = GL_FALSE;
     CrHTableCreate(&cr_server.clientTable, CR_MAX_CLIENTS);
 
@@ -491 +492 @@
 
     cr_server.fCrCmdEnabled = GL_FALSE;
+    cr_server.fProcessingPendedCommands = GL_FALSE;
     CrHTableCreate(&cr_server.clientTable, CR_MAX_CLIENTS);
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_retval.py

@@ -21 +21 @@
 void crServerReturnValue( const void *payload, unsigned int payload_len )
 {
-    CRMessageReadback *rb;
-    int msg_len = sizeof( *rb ) + payload_len;
-
-    /* Don't reply to client if we're loading VM snapshot*/
-    if (cr_server.bIsInLoadingState)
-        return;
-
-    if (cr_server.curClient->conn->type == CR_FILE)
-    {
+    if (!cr_server.fProcessingPendedCommands)
+    { 
+        CRMessageReadback *rb;
+        int msg_len = sizeof( *rb ) + payload_len;
+    
+        /* Don't reply to client if we're loading VM snapshot*/
+        if (cr_server.bIsInLoadingState)
+            return;
+    
+        if (cr_server.curClient->conn->type == CR_FILE)
+        {
+            return;
+        }
+    
+        rb = (CRMessageReadback *) crAlloc( msg_len );
+    
+        rb->header.type = CR_MESSAGE_READBACK;
+        CRDBGPTR_PRINTRB(cr_server.curClient->conn->u32ClientID, &cr_server.writeback_ptr);
+        CRDBGPTR_CHECKNZ(&cr_server.writeback_ptr);
+        CRDBGPTR_CHECKNZ(&cr_server.return_ptr);
+        crMemcpy( &(rb->writeback_ptr), &(cr_server.writeback_ptr), sizeof( rb->writeback_ptr ) );
+        crMemcpy( &(rb->readback_ptr), &(cr_server.return_ptr), sizeof( rb->readback_ptr ) );
+        crMemcpy( rb+1, payload, payload_len );
+        crNetSend( cr_server.curClient->conn, NULL, rb, msg_len );
+        CRDBGPTR_SETZ(&cr_server.writeback_ptr);
+        CRDBGPTR_SETZ(&cr_server.return_ptr);
+        crFree( rb );
         return;
     }
-
-    rb = (CRMessageReadback *) crAlloc( msg_len );
-
-    rb->header.type = CR_MESSAGE_READBACK;
-    CRDBGPTR_PRINTRB(cr_server.curClient->conn->u32ClientID, &cr_server.writeback_ptr);
-    CRDBGPTR_CHECKNZ(&cr_server.writeback_ptr);
-    CRDBGPTR_CHECKNZ(&cr_server.return_ptr);
-    crMemcpy( &(rb->writeback_ptr), &(cr_server.writeback_ptr), sizeof( rb->writeback_ptr ) );
-    crMemcpy( &(rb->readback_ptr), &(cr_server.return_ptr), sizeof( rb->readback_ptr ) );
-    crMemcpy( rb+1, payload, payload_len );
-    crNetSend( cr_server.curClient->conn, NULL, rb, msg_len );
+#ifdef DEBUG_misha
+    WARN(("Pending command returns value"));
+#endif
     CRDBGPTR_SETZ(&cr_server.writeback_ptr);
     CRDBGPTR_SETZ(&cr_server.return_ptr);
-    crFree( rb );
 }
 """

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

@@ -551 +551 @@
 {
     CR_SERVER_PENDING_MSG *pIter, *pNext;
+
+    cr_server.fProcessingPendedCommands = GL_TRUE;
+
     RTListForEachSafe(&conn->PendingMsgList, pIter, pNext, CR_SERVER_PENDING_MSG, Node)
     {
@@ -574 +577 @@
         RTMemFree(pIter);
     }
+
+    cr_server.fProcessingPendedCommands = GL_FALSE;
 }