Changeset 50973 in vbox for trunk/src/VBox

Timestamp:

Apr 4, 2014 6:31:40 PM (11 years ago)

Author:

vboxsync

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

93141

Message:

crOpenGL: command blocks (disabled for now)

Location:

trunk/src/VBox

Files:

• GuestHost/OpenGL/include/cr_net.h (modified) (2 diffs)
• GuestHost/OpenGL/include/cr_pack.h (modified) (7 diffs)
• GuestHost/OpenGL/include/cr_protocol.h (modified) (1 diff)
• GuestHost/OpenGL/include/cr_unpack.h (modified) (2 diffs)
• GuestHost/OpenGL/packer/opcodes.py (modified) (2 diffs)
• GuestHost/OpenGL/packer/pack_beginend.c (modified) (6 diffs)
• GuestHost/OpenGL/packer/pack_init.c (modified) (2 diffs)
• GuestHost/OpenGL/packer/pack_lists.c (modified) (3 diffs)
• GuestHost/OpenGL/packer/pack_misc.c (modified) (1 diff)
• GuestHost/OpenGL/packer/pack_swap_lists.c (modified) (2 diffs)
• GuestHost/OpenGL/packer/packer_special (modified) (1 diff)
• GuestHost/OpenGL/util/vboxhgcm.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_config.c (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_stream.c (modified) (5 diffs)
• HostServices/SharedOpenGL/unpacker/unpack.py (modified) (1 diff)

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

@@ -36 +36 @@
 #include <iprt/types.h>
 #include <iprt/thread.h>
+#include <iprt/list.h>
     
 #ifdef __cplusplus
@@ -245 +246 @@
     CRVBOXHGSMI_CMDDATA CmdData;
 # endif
+    RTLISTANCHOR PendingMsgList;
 #endif
     /* Used on host side to indicate that we are not allowed to store above pointers for later use

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

@@ -51 +51 @@
 typedef void (*CRPackErrorHandlerFunc)(int line, const char *file, GLenum error, const char *info);
 
-typedef enum
-{
-    CRPackBeginEndStateNone = 0, /* not in begin end */
-    CRPackBeginEndStateStarted,       /* begin issued */
-    CRPackBeginEndStateFlushDone /* begin issued & buffer flash is done thus part of commands is issued to host */
-} CRPackBeginEndState;
+#define CRPACKBLOCKSTATE_OP_BEGIN           0x01
+#define CRPACKBLOCKSTATE_OP_NEWLIST         0x02
+#define CRPACKBLOCKSTATE_OP_BEGINQUERY      0x04
+#define CRPACKBLOCKSTATE_OP_ALL             0x07
+
+#define CRPACKBLOCKSTATE_IS_OP_STARTED(_state, _op)      (!!((_state) & (_op)))
+
+#define CRPACKBLOCKSTATE_IS_STARTED(_state)      (!!(_state))
+
+#define CRPACKBLOCKSTATE_OP_START(_state, _op)      do { \
+            Assert(!CRPACKBLOCKSTATE_IS_OP_STARTED(_state, _op)); \
+            (_state) |= (_op); \
+        } while (0)
+
+#define CRPACKBLOCKSTATE_OP_STOP(_state, _op)      do { \
+            Assert(CRPACKBLOCKSTATE_IS_OP_STARTED(_state, _op)); \
+            (_state) &= ~(_op); \
+        } while (0)
+
 /**
  * Packer context
@@ -68 +81 @@
     CRPackErrorHandlerFunc Error;
     CRCurrentStatePointers current;
-    CRPackBeginEndState enmBeginEndState;
+    uint32_t u32CmdBlockState;
     GLvectorf bounds_min, bounds_max;
     int updateBBOX;
@@ -96 +109 @@
 #  define CR_UNLOCK_PACKER_CONTEXT(PC)
 # endif
+extern int cr_packer_cmd_blocks_enabled;
 #else /* if defined IN_RING0 */
 # define CR_PACKER_CONTEXT_ARGSINGLEDECL CRPackContext *_pCtx
@@ -123 +137 @@
 #endif
         );
+DECLINLINE(bool) crPackBufferIsEmpty(CRPackBuffer *buffer)
+{
+    return (buffer->opcode_current == buffer->data_current -1);
+}
+
 extern DECLEXPORT(void) crPackFlushFunc( CRPackContext *pc, CRPackFlushFunc ff );
 extern DECLEXPORT(void) crPackFlushArg( CRPackContext *pc, void *flush_arg );
@@ -217 +236 @@
 
 
+#define CR_PACK_SPECIAL_OP( _pc, _op)                               \
+  do {                                                              \
+    data_ptr = pc->buffer.data_current;                             \
+    (_pc)->buffer.data_current += 4;                                \
+    WRITE_OPCODE( (_pc), (_op) );                                   \
+    WRITE_DATA( 0, GLuint, 0xdeadbeef );                            \
+    data_ptr = NULL; /* <- sanity*/                                 \
+  } while (0)
+
+#define CR_CMDBLOCK_OP( _pc, _op)                                   \
+  do {                                                              \
+      CR_PACK_SPECIAL_OP( _pc, _op);                                \
+  } while (0)
+
+
+#define CR_CMDBLOCK_BEGIN( pc, op )                                 \
+  do {                                                              \
+    CR_LOCK_PACKER_CONTEXT(pc);                                     \
+    if (!cr_packer_cmd_blocks_enabled) break;                       \
+    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 );            \
+        }                                                           \
+        else {                                                      \
+          (*pc->buffer.opcode_start) = CR_CMDBLOCKBEGIN_OPCODE;     \
+        }                                                           \
+      }                                                             \
+      else {                                                        \
+        Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                   \
+        CR_CMDBLOCK_OP( pc, CR_CMDBLOCKBEGIN_OPCODE );              \
+      }                                                             \
+    }                                                               \
+    CRPACKBLOCKSTATE_OP_START(pc->u32CmdBlockState, op);            \
+  } while (0)
+
+#define CR_CMDBLOCK_END( pc, op )                                   \
+  do {                                                              \
+    if (!cr_packer_cmd_blocks_enabled) break;                       \
+    CRPACKBLOCKSTATE_OP_STOP(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) {\
+          if ( !crPackCanHoldOpcode( pc, 1, 4 ) ) {                 \
+            pc->Flush( pc->flush_arg );                             \
+            Assert(crPackCanHoldOpcode( pc, 1, 4 ) );               \
+          }                                                         \
+          CR_CMDBLOCK_OP( pc, CR_CMDBLOCKEND_OPCODE );              \
+          pc->Flush( pc->flush_arg );                               \
+        }                                                           \
+        else {                                                      \
+          (*pc->buffer.opcode_start) = CR_NOP_OPCODE;               \
+        }                                                           \
+      }                                                             \
+      else {                                                        \
+        Assert(crPackCanHoldOpcode( pc, 1, 4 ) );                   \
+        CR_CMDBLOCK_OP( pc, CR_CMDBLOCKEND_OPCODE );                \
+        pc->Flush( pc->flush_arg );                                 \
+      }                                                             \
+    }                                                               \
+  } while (0)
+
 /**
  * Alloc space for a message of 'len' bytes (plus 1 opcode).
@@ -229 +316 @@
       pc->Flush( pc->flush_arg );                                   \
       CRASSERT(crPackCanHoldOpcode( pc, 1, (len) ) );               \
-      if (pc->enmBeginEndState == CRPackBeginEndStateStarted) {     \
-        pc->enmBeginEndState = CRPackBeginEndStateFlushDone;        \
-      }                                                             \
     }                                                               \
     data_ptr = pc->buffer.data_current;                             \
     pc->buffer.data_current += (len);                               \
   } while (0)
-
 
 /**
@@ -279 +362 @@
       pc->Flush( pc->flush_arg );                       \
       CRASSERT( crPackCanHoldOpcode( pc, 1, (len) ) );  \
-      if (pc->enmBeginEndState == CRPackBeginEndStateStarted) {     \
-        pc->enmBeginEndState = CRPackBeginEndStateFlushDone;        \
-      }                                                             \
     }                                                   \
     data_ptr = pc->buffer.data_current;                 \

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

@@ -24 +24 @@
 
 /* new TexPresent mechanism is available */
-#define CR_VBOX_CAP_TEX_PRESENT    0x00000001
+#define CR_VBOX_CAP_TEX_PRESENT         0x00000001
 /* vbva command submission mechanism supported */
-#define CR_VBOX_CAP_CMDVBVA        0x00000002
+#define CR_VBOX_CAP_CMDVBVA             0x00000002
+/* host supports Command Blocks, i.e. CR_CMDBLOCKBEGIN_OPCODE and CR_CMDBLOCKEND_OPCODE opcodes.
+ * Command Block can be used by guest to prevent clients from blocking each other.
+ * The Command Block allows multiple command buffers to be processed with one run.
+ * Command Block commands have to obey to the following rules:
+ * CR_CMDBLOCKBEGIN_OPCODE - must be the first command in the command buffer, specifying the command block start
+ * CR_CMDBLOCKEND_OPCODE - must be the last command in the command buffer, specifying the command block end
+ * If not placed accordingly, CR_CMDBLOCK** commands are ignored.
+ * Server copies the command block buffer commands to its internal storage
+ * and processes them with one run when the command block end is signalled
+ */
+#define CR_VBOX_CAP_CMDBLOCKS            0x00000004
 
 

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

@@ -12 +12 @@
 #include "cr_protocol.h"
 #include "cr_mem.h"
+#include "cr_opcodes.h"
 
 #include <iprt/types.h>
@@ -28 +29 @@
 DECLEXPORT(void) crUnpackPush(void);
 DECLEXPORT(void) crUnpackPop(void);
+
+typedef enum
+{
+    CR_UNPACK_BUFFER_TYPE_GENERIC = 0,
+    CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN,
+    CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END
+} CR_UNPACK_BUFFER_TYPE;
+
+DECLINLINE(CR_UNPACK_BUFFER_TYPE) crUnpackGetBufferType(const void *opcodes, unsigned int num_opcodes)
+{
+    const uint8_t *pu8Codes = (const uint8_t *)opcodes;
+
+    CR_UNPACK_BUFFER_TYPE enmType;
+    uint8_t first;
+    uint8_t last;
+
+    if (!num_opcodes)
+        return CR_UNPACK_BUFFER_TYPE_GENERIC;
+
+    first = pu8Codes[0];
+    last = pu8Codes[1-(int)num_opcodes];
+
+    enmType = (first != CR_CMDBLOCKBEGIN_OPCODE) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN;
+
+    if (last != CR_CMDBLOCKEND_OPCODE)
+        return enmType;
+
+    /* last is CMDBLOCKEND*/
+    return (enmType == CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN) ? CR_UNPACK_BUFFER_TYPE_GENERIC : CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END;
+}
 
 extern CRNetworkPointer * return_ptr;

trunk/src/VBox/GuestHost/OpenGL/packer/opcodes.py

@@ -34 +34 @@
                 enum_index = enum_index + 1
 
-if enum_index > 255:
+print "\tCR_EXTEND_OPCODE=%d," % enum_index
+enum_index = enum_index + 1
+print "\tCR_CMDBLOCKBEGIN_OPCODE=%d," % enum_index
+enum_index = enum_index + 1
+print "\tCR_CMDBLOCKEND_OPCODE=%d," % enum_index
+print "\tCR_NOP_OPCODE=255"
+if enum_index > 254:
         # This would have saved Mike some grief if it had been here earlier.
         print >> sys.stderr, "You have more than 255 opcodes!  You've been adding functions to"
@@ -46 +52 @@
         print "#error -- more than 255 opcodes!"
         sys.exit(-1)
-print "\tCR_EXTEND_OPCODE=%d" % enum_index
 print "} CROpcode;\n"
 

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

@@ -13 +13 @@
     unsigned char *data_ptr;
     (void) pc;
+
+    CR_CMDBLOCK_BEGIN( pc, CRPACKBLOCKSTATE_OP_BEGIN );
+#ifndef VBOX
     if (pc->buffer.canBarf)
     {
@@ -20 +23 @@
         pc->buffer.holds_BeginEnd = 1;
     }
-    CR_GET_BUFFERED_POINTER( pc, 4 );
-    CRASSERT(pc->enmBeginEndState == CRPackBeginEndStateNone);
-    pc->enmBeginEndState = CRPackBeginEndStateStarted;
+#endif
+    CR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH(pc, 4, GL_FALSE);
     pc->current.begin_data = data_ptr;
     pc->current.begin_op = pc->buffer.opcode_current;
@@ -36 +38 @@
     unsigned char *data_ptr;
     (void) pc;
+#ifndef VBOX
     if (pc->buffer.canBarf)
     {
@@ -43 +46 @@
         pc->buffer.holds_BeginEnd = 1;
     }
-    CR_GET_BUFFERED_POINTER( pc, 4 );
-    CRASSERT(pc->enmBeginEndState == CRPackBeginEndStateNone);
-    pc->enmBeginEndState = CRPackBeginEndStateStarted;
+#endif
+    CR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH(pc, 4, GL_FALSE);
     pc->current.begin_data = data_ptr;
     pc->current.begin_op = pc->buffer.opcode_current;
@@ -62 +64 @@
     WRITE_OPCODE( pc, CR_END_OPCODE );
     pc->buffer.in_BeginEnd = 0;
-    CRASSERT(pc->enmBeginEndState == CRPackBeginEndStateStarted
-            || pc->enmBeginEndState == CRPackBeginEndStateFlushDone);
-    if (pc->enmBeginEndState == CRPackBeginEndStateFlushDone)
-    {
-        pc->Flush( pc->flush_arg );
-    }
-    pc->enmBeginEndState = CRPackBeginEndStateNone;
+    CR_CMDBLOCK_END( pc, CRPACKBLOCKSTATE_OP_BEGIN );
     CR_UNLOCK_PACKER_CONTEXT(pc);
 }
@@ -80 +76 @@
     WRITE_OPCODE( pc, CR_END_OPCODE );
     pc->buffer.in_BeginEnd = 0;
-    CRASSERT(pc->enmBeginEndState == CRPackBeginEndStateStarted
-            || pc->enmBeginEndState == CRPackBeginEndStateFlushDone);
-    if (pc->enmBeginEndState == CRPackBeginEndStateFlushDone)
-    {
-        pc->Flush( pc->flush_arg );
-    }
+    CR_CMDBLOCK_END( pc, CRPACKBLOCKSTATE_OP_BEGIN );
     CR_UNLOCK_PACKER_CONTEXT(pc);
 }

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

@@ -18 +18 @@
 #endif
 
+int cr_packer_cmd_blocks_enabled = 0;
+
 CRPackContext *crPackNewContext( int swapping )
 {
@@ -29 +31 @@
         crMemZero( pc, sizeof(CRPackContext));
 #endif
-    pc->enmBeginEndState = CRPackBeginEndStateNone;
+    pc->u32CmdBlockState = 0;
     pc->swapping = swapping;
     pc->Flush = NULL;

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

@@ -59 +59 @@
 }
 
-
-
 void PACK_APIENTRY crPackNewList( GLuint list, GLenum mode )
 {
@@ -66 +64 @@
     unsigned char *data_ptr;
     (void) pc;
-    CR_GET_BUFFERED_POINTER( pc, 16 );
+    CR_CMDBLOCK_BEGIN( pc, CRPACKBLOCKSTATE_OP_NEWLIST );
+    CR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH( pc, 16, GL_FALSE );
     WRITE_DATA( 0, GLint, 16 );
     WRITE_DATA( 4, GLenum, CR_NEWLIST_EXTEND_OPCODE );
@@ -86 +85 @@
     WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     pc->buffer.in_List = GL_FALSE;
+    CR_CMDBLOCK_END( pc, CRPACKBLOCKSTATE_OP_NEWLIST );
     CR_UNLOCK_PACKER_CONTEXT(pc);
 }

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

@@ -188 +188 @@
     CR_UNLOCK_PACKER_CONTEXT(pc);
 }
+
+void PACK_APIENTRY crPackBeginQueryARB( CR_PACKER_CONTEXT_ARGDECL GLenum target, GLuint id )
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    CR_GET_BUFFERED_POINTER( pc, 16 );
+    WRITE_DATA( 0, GLint, 16 );
+    WRITE_DATA( 4, GLenum, CR_BEGINQUERYARB_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLenum, target );
+    WRITE_DATA( 12, GLuint, id );
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}
+
+void PACK_APIENTRY crPackEndQueryARB( CR_PACKER_CONTEXT_ARGDECL GLenum target )
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pc;
+    CR_GET_BUFFERED_POINTER( pc, 12 );
+    WRITE_DATA( 0, GLint, 12 );
+    WRITE_DATA( 4, GLenum, CR_ENDQUERYARB_EXTEND_OPCODE );
+    WRITE_DATA( 8, GLenum, target );
+    WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}

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

@@ -90 +90 @@
     unsigned char *data_ptr;
     (void) pc;
-    CR_GET_BUFFERED_POINTER( pc, 16 );
+    CR_CMDBLOCK_BEGIN( pc, CRPACKBLOCKSTATE_OP_NEWLIST );
+    CR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH( pc, 16, GL_FALSE );
     WRITE_DATA( 0, GLint, SWAP32(16) );
     WRITE_DATA( 4, GLenum, SWAP32(CR_NEWLIST_EXTEND_OPCODE) );
@@ -112 +113 @@
     WRITE_OPCODE( pc, CR_EXTEND_OPCODE );
     pc->buffer.in_List = GL_FALSE;
+    CR_CMDBLOCK_END( pc, CRPACKBLOCKSTATE_OP_NEWLIST );
     CR_UNLOCK_PACKER_CONTEXT(pc);
 }

trunk/src/VBox/GuestHost/OpenGL/packer/packer_special

@@ -181 +181 @@
 WindowShow
 WindowSize
+BeginQueryARB
+EndQueryARB

trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c

@@ -2441 +2441 @@
     conn->cbHostBuffer = 0;
 
+#if !defined(IN_GUEST)
+    RTListInit(&conn->PendingMsgList);
+#endif
+
 #ifdef CHROMIUM_THREADSAFE
     crLockMutex(&g_crvboxhgcm.mutex);

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

@@ -226 +226 @@
     {
         cr_server.u32Caps = crServerVBoxParseNumerics(env, 0);
-        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA);
+        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS);
     }
     else
     {
-        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT/* | CR_VBOX_CAP_CMDVBVA*/;
+        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT
 #ifdef DEBUG_misha
-        cr_server.u32Caps |= CR_VBOX_CAP_CMDVBVA;
+                | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS
 #endif
+                ;
 
     }
@@ -376 +377 @@
     {
         cr_server.u32Caps = crServerVBoxParseNumerics(env, 0);
-        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA);
+        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS);
     }
     else
     {
-        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT/* | CR_VBOX_CAP_CMDVBVA*/;
+        cr_server.u32Caps = CR_VBOX_CAP_TEX_PRESENT
 #ifdef DEBUG_misha
-        cr_server.u32Caps |= CR_VBOX_CAP_CMDVBVA;
+                | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS
 #endif
+                ;
     }
 

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

@@ -416 +416 @@
 }
 
+typedef struct CR_SERVER_PENDING_MSG
+{
+    RTLISTNODE Node;
+    CRMessage Msg;
+} CR_SERVER_PENDING_MSG;
+
+static int crServerPendMsg(CRConnection *conn, const CRMessage *msg, int cbMsg)
+{
+    CR_SERVER_PENDING_MSG *pMsg = (CR_SERVER_PENDING_MSG*)RTMemAlloc(cbMsg + RT_OFFSETOF(CR_SERVER_PENDING_MSG, Msg));
+    if (!pMsg)
+    {
+        WARN(("RTMemAlloc failed"));
+        return VERR_NO_MEMORY;
+    }
+
+    memcpy(&pMsg->Msg, msg, cbMsg);
+
+    RTListAppend(&conn->PendingMsgList, &pMsg->Node);
+
+    return VINF_SUCCESS;
+}
+
+static void crServerPendProcess(CRConnection *conn)
+{
+    CR_SERVER_PENDING_MSG *pIter, *pNext;
+    RTListForEachSafe(&conn->PendingMsgList, pIter, pNext, CR_SERVER_PENDING_MSG, Node)
+    {
+        CRMessage *msg = &pIter->Msg;
+        const CRMessageOpcodes *msg_opcodes;
+        int opcodeBytes;
+        const char *data_ptr;
+
+        RTListNodeRemove(&pIter->Node);
+
+        CRASSERT(msg->header.type == CR_MESSAGE_OPCODES);
+
+        msg_opcodes = (const CRMessageOpcodes *) msg;
+        opcodeBytes = (msg_opcodes->numOpcodes + 3) & ~0x03;
+
+        data_ptr = (const char *) msg_opcodes + sizeof (CRMessageOpcodes) + opcodeBytes;
+
+        crUnpack(data_ptr,                 /* first command's operands */
+                 data_ptr - 1,             /* first command's opcode */
+                 msg_opcodes->numOpcodes,  /* how many opcodes */
+                 &(cr_server.dispatch));   /* the CR dispatch table */
+
+        RTMemFree(pIter);
+    }
+}
 
 /**
@@ -422 +471 @@
  */
 static void
-crServerDispatchMessage(CRConnection *conn, CRMessage *msg)
+crServerDispatchMessage(CRConnection *conn, CRMessage *msg, int cbMsg)
 {
     const CRMessageOpcodes *msg_opcodes;
@@ -430 +479 @@
     PCRVBOXHGSMI_CMDDATA pCmdData = NULL;
 #endif
+    CR_UNPACK_BUFFER_TYPE enmType;
+    bool fUnpack = true;
 
     if (msg->header.type == CR_MESSAGE_REDIR_PTR)
@@ -450 +501 @@
 
     data_ptr = (const char *) msg_opcodes + sizeof(CRMessageOpcodes) + opcodeBytes;
-    crUnpack(data_ptr,                 /* first command's operands */
-             data_ptr - 1,             /* first command's opcode */
-             msg_opcodes->numOpcodes,  /* how many opcodes */
-             &(cr_server.dispatch));   /* the CR dispatch table */
+
+    enmType = crUnpackGetBufferType(data_ptr - 1,             /* first command's opcode */
+                msg_opcodes->numOpcodes  /* how many opcodes */);
+    switch (enmType)
+    {
+        case CR_UNPACK_BUFFER_TYPE_GENERIC:
+        {
+            if (RTListIsEmpty(&conn->PendingMsgList))
+                break;
+
+            if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
+            {
+                fUnpack = false;
+                break;
+            }
+
+            WARN(("crServerPendMsg failed"));
+            crServerPendProcess(conn);
+            break;
+        }
+        case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_BEGIN:
+        {
+            if (RTListIsEmpty(&conn->PendingMsgList))
+            {
+                if (RT_SUCCESS(crServerPendMsg(conn, msg, cbMsg)))
+                {
+                    Assert(!RTListIsEmpty(&conn->PendingMsgList));
+                    fUnpack = false;
+                    break;
+                }
+                else
+                    WARN(("crServerPendMsg failed"));
+            }
+            else
+                WARN(("Pend List is NOT empty, drain the current list, and ignore this command"));
+
+            crServerPendProcess(conn);
+            break;
+        }
+        case CR_UNPACK_BUFFER_TYPE_CMDBLOCK_END:
+        {
+            CRASSERT(!RTListIsEmpty(&conn->PendingMsgList));
+            crServerPendProcess(conn);
+            Assert(RTListIsEmpty(&conn->PendingMsgList));
+            break;
+        }
+        default:
+            WARN(("unsupported buffer type"));
+            break;
+    }
+
+    if (fUnpack)
+    {
+        crUnpack(data_ptr,                 /* first command's operands */
+                 data_ptr - 1,             /* first command's opcode */
+                 msg_opcodes->numOpcodes,  /* how many opcodes */
+                 &(cr_server.dispatch));   /* the CR dispatch table */
+    }
 
 #ifdef VBOX_WITH_CRHGSMI
@@ -584 +689 @@
 
         /* Commands get dispatched here */
-        crServerDispatchMessage( conn, msg );
+        crServerDispatchMessage( conn, msg, len );
 
         crNetFree( conn, msg );

trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py

@@ -263 +263 @@
                 #endif
                 break;
+            case CR_CMDBLOCKBEGIN_OPCODE:
+            case CR_CMDBLOCKEND_OPCODE:
+            case CR_NOP_OPCODE:
+                INCR_DATA_PTR_NO_ARGS( );
+                break;
             default:
                 crError( "Unknown opcode: %d", *unpack_opcodes );