Changeset 51042 in vbox

Timestamp:

Apr 10, 2014 8:05:24 PM (11 years ago)

Author:

vboxsync

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

93262

Message:

wddm/DevVGA: complex command submission; bugfixes

Location:

trunk

Files:

• include/VBox/VBoxVideo.h (modified) (2 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp (modified) (4 diffs)
• src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h (modified) (1 diff)
• src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp (modified) (9 diffs)
• src/VBox/Devices/Graphics/DevVGA_VDMA.cpp (modified) (2 diffs)

trunk/include/VBox/VBoxVideo.h

@@ -1583 +1583 @@
 /* actual command is stored in guest system memory */
 #define VBOXCMDVBVA_OPTYPE_SYSMEMCMD                    8
+/* complex command - i.e. can contain multiple commands
+ * i.e. the VBOXCMDVBVA_OPTYPE_COMPLEXCMD VBOXCMDVBVA_HDR is followed
+ * by one or more VBOXCMDVBVA_HDR commands.
+ * Each command's size is specified in it's VBOXCMDVBVA_HDR's u32FenceID field */
+#define VBOXCMDVBVA_OPTYPE_COMPLEXCMD                   9
 
 /* nop - is a one-bit command. The buffer size to skip is determined by VBVA buffer size */
@@ -1629 +1634 @@
     } u;
     /* DXGK DDI fence ID */
-    volatile uint32_t u32FenceID;
+    uint32_t u32FenceID;
 } VBOXCMDVBVA_HDR;
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.cpp

@@ -930 +930 @@
 }
 
-int VBoxCmdVbvaSubmit(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, struct VBOXCMDVBVA_HDR *pCmd, uint32_t u32FenceID, uint32_t cbCmd)
-{
-    int rc = VINF_SUCCESS;
-
-    Assert(u32FenceID);
+void VBoxCmdVbvaSubmitUnlock(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, VBOXCMDVBVA_HDR* pCmd, uint32_t u32FenceID)
+{
+    if (u32FenceID)
+        pVbva->u32FenceSubmitted = u32FenceID;
+    else
+        WARN(("no cmd fence specified"));
 
     pCmd->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
-#ifdef DEBUG_misha
-    Assert(u32FenceID == pVbva->u32FenceSubmitted + 1);
-#endif
-    if (VBoxVBVAExGetSize(&pVbva->Vbva) < cbCmd)
-    {
-        WARN(("buffer does not fit the vbva buffer, we do not support splitting buffers"));
-        return VERR_NOT_SUPPORTED;
-    }
-
-    if (!VBoxVBVAExBufferBeginUpdate(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx))
-    {
-        WARN(("VBoxVBVAExBufferBeginUpdate failed!"));
-        return VERR_GENERAL_FAILURE;
-    }
-
-    void* pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbCmd);
-    if (!pvBuffer)
-    {
-        WARN(("failed to allocate contiguous buffer, trying nopping the tail"));
-        uint32_t cbTail = VBoxVBVAExGetFreeTail(&pVbva->Vbva);
-        if (!cbTail)
-        {
-            WARN(("this is not a free tail case, cbTail is NULL"));
-            return VERR_BUFFER_OVERFLOW;
-        }
-
-        Assert(cbTail < cbCmd);
-
-        pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbTail);
-
-        Assert(pvBuffer);
-
-        *((uint8_t*)pvBuffer) = VBOXCMDVBVA_OPTYPE_NOP;
-
-        VBoxVBVAExBufferEndUpdate(&pVbva->Vbva);
-
-        if (!VBoxVBVAExBufferBeginUpdate(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx))
-        {
-            WARN(("VBoxVBVAExBufferBeginUpdate 2 failed!"));
-            return VERR_GENERAL_FAILURE;
-        }
-
-        pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbCmd);
-        if (!pvBuffer)
-        {
-            WARN(("failed to allocate contiguous buffer, failing"));
-            return VERR_GENERAL_FAILURE;
-        }
-    }
-
-    pVbva->u32FenceSubmitted = u32FenceID;
-
-    Assert(pvBuffer);
-
-    memcpy(pvBuffer, pCmd, cbCmd);
-
-    ((VBOXCMDVBVA_HDR*)pvBuffer)->u32FenceID = u32FenceID;
+
+    pCmd->u32FenceID = u32FenceID;
 
     VBoxVBVAExBufferEndUpdate(&pVbva->Vbva);
@@ -1008 +954 @@
         {
             WARN(("VBoxHGSMIBufferAlloc failed\n"));
-            return VERR_OUT_OF_RESOURCES;
+            return;
         }
 
@@ -1017 +963 @@
         VBoxHGSMIBufferFree(pCtx, pSubmit);
     }
+}
+
+VBOXCMDVBVA_HDR* VBoxCmdVbvaSubmitLock(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t cbCmd)
+{
+    if (VBoxVBVAExGetSize(&pVbva->Vbva) < cbCmd)
+    {
+        WARN(("buffer does not fit the vbva buffer, we do not support splitting buffers"));
+        NULL;
+    }
+
+    if (!VBoxVBVAExBufferBeginUpdate(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx))
+    {
+        WARN(("VBoxVBVAExBufferBeginUpdate failed!"));
+        return NULL;
+    }
+
+    void* pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbCmd);
+    if (!pvBuffer)
+    {
+        WARN(("failed to allocate contiguous buffer, trying nopping the tail"));
+        uint32_t cbTail = VBoxVBVAExGetFreeTail(&pVbva->Vbva);
+        if (!cbTail)
+        {
+            WARN(("this is not a free tail case, cbTail is NULL"));
+            return NULL;
+        }
+
+        Assert(cbTail < cbCmd);
+
+        pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbTail);
+
+        Assert(pvBuffer);
+
+        *((uint8_t*)pvBuffer) = VBOXCMDVBVA_OPTYPE_NOP;
+
+        VBoxVBVAExBufferEndUpdate(&pVbva->Vbva);
+
+        if (!VBoxVBVAExBufferBeginUpdate(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx))
+        {
+            WARN(("VBoxVBVAExBufferBeginUpdate 2 failed!"));
+            return NULL;
+        }
+
+        pvBuffer = VBoxVBVAExAllocContiguous(&pVbva->Vbva, &VBoxCommonFromDeviceExt(pDevExt)->guestCtx, cbCmd);
+        if (!pvBuffer)
+        {
+            WARN(("failed to allocate contiguous buffer, failing"));
+            return NULL;
+        }
+    }
+
+    Assert(pvBuffer);
+
+    return (VBOXCMDVBVA_HDR*)pvBuffer;
+}
+
+int VBoxCmdVbvaSubmit(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, struct VBOXCMDVBVA_HDR *pCmd, uint32_t u32FenceID, uint32_t cbCmd)
+{
+    VBOXCMDVBVA_HDR* pHdr = VBoxCmdVbvaSubmitLock(pDevExt, pVbva, cbCmd);
+
+    if (!pHdr)
+    {
+        WARN(("VBoxCmdVbvaSubmitLock failed"));
+        return VERR_GENERAL_FAILURE;
+    }
+
+    memcpy(pHdr, pCmd, cbCmd);
+
+    VBoxCmdVbvaSubmitUnlock(pDevExt, pVbva, pCmd, u32FenceID);
 
     return VINF_SUCCESS;
@@ -1083 +1098 @@
         if (u8State == VBOXCMDVBVA_STATE_IN_PROGRESS)
         {
-            Assert(u32FenceID);
             if (!u32FenceID)
+            {
+                WARN(("fence is NULL"));
                 continue;
-
-#ifdef DEBUG_misha
-            Assert(u32FenceID == pVbva->u32FenceCompleted + 1);
-#endif
+            }
+
             pVbva->u32FenceCompleted = u32FenceID;
         }

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPVbva.h

@@ -213 +213 @@
 int VBoxCmdVbvaCreate(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, ULONG offBuffer, ULONG cbBuffer);
 int VBoxCmdVbvaSubmit(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, struct VBOXCMDVBVA_HDR *pCmd, uint32_t u32FenceID, uint32_t cbCmd);
+void VBoxCmdVbvaSubmitUnlock(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, VBOXCMDVBVA_HDR* pCmd, uint32_t u32FenceID);
+VBOXCMDVBVA_HDR* VBoxCmdVbvaSubmitLock(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t cbCmd);
 bool VBoxCmdVbvaPreempt(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, uint32_t u32FenceID);
 uint32_t VBoxCmdVbvaCheckCompleted(PVBOXMP_DEVEXT pDevExt, VBOXCMDVBVA *pVbva, bool fPingHost);

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

@@ -3111 +3111 @@
     VBOXCMDVBVA_HDR *pHdr;
     VBOXCMDVBVA_HDR NopCmd;
+    uint32_t cbCurCmd, cbCurDma;
     if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
     {
-        if (cbCmd)
+        if (cbCmd || cbDma)
         {
             WARN(("invalid command data"));
             return STATUS_INVALID_PARAMETER;
         }
+        Assert(!cbDma);
         NopCmd.u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
         NopCmd.u8Flags = 0;
@@ -3124 +3126 @@
         cbCmd = sizeof (VBOXCMDVBVA_HDR);
         pHdr = &NopCmd;
+        cbCurCmd = sizeof (VBOXCMDVBVA_HDR);
+        cbCurDma = 0;
     }
     else
     {
         pHdr = (VBOXCMDVBVA_HDR*)(((uint8_t*)pSubmitCommand->pDmaBufferPrivateData) + pSubmitCommand->DmaBufferPrivateDataSubmissionStartOffset);
-        if (cbCmd != pHdr->u32FenceID)
-        {
-            WARN(("partial submission start!"));
-            cbCmd = pHdr->u32FenceID;
-        }
-    }
-
-    switch (pHdr->u8OpCode)
-    {
-        case VBOXCMDVBVA_OPTYPE_SYSMEMCMD:
-        {
-            VBOXCMDVBVA_SYSMEMCMD *pSysMem = (VBOXCMDVBVA_SYSMEMCMD*)pHdr;
-            if (pSubmitCommand->DmaBufferPhysicalAddress.QuadPart & PAGE_OFFSET_MASK)
-            {
-                WARN(("command should be page aligned for now"));
-                return STATUS_INVALID_PARAMETER;
-            }
-            pSysMem->phCmd = (VBOXCMDVBVAPHADDR)(pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset);
+        cbCurCmd = pHdr->u32FenceID & 0xff;
+        cbCurDma = pHdr->u32FenceID >> 16;
+    }
+
+
+    VBOXCMDVBVA_HDR *pDstHdr, *pCurDstCmd;
+    if (cbCmd != cbCurCmd || cbCurDma != cbDma)
+    {
+        if (cbCmd < cbCurCmd || cbDma < cbCurDma)
+        {
+            WARN(("incorrect buffer size"));
+            return STATUS_INVALID_PARAMETER;
+        }
+
+        pDstHdr = VBoxCmdVbvaSubmitLock(pDevExt, &pDevExt->CmdVbva, cbCmd + sizeof (VBOXCMDVBVA_HDR));
+        if (!pDstHdr)
+        {
+            WARN(("VBoxCmdVbvaSubmitLock failed"));
+            return STATUS_UNSUCCESSFUL;
+        }
+
+        pDstHdr->u8OpCode = VBOXCMDVBVA_OPTYPE_COMPLEXCMD;
+        pDstHdr->u8Flags = 0;
+        pDstHdr->u.u8PrimaryID = 0;
+
+        pCurDstCmd = pDstHdr + 1;
+    }
+    else
+    {
+        pDstHdr = VBoxCmdVbvaSubmitLock(pDevExt, &pDevExt->CmdVbva, cbCmd);
+        if (!pDstHdr)
+        {
+            WARN(("VBoxCmdVbvaSubmitLock failed"));
+            return STATUS_UNSUCCESSFUL;
+        }
+        pCurDstCmd = pDstHdr;
+    }
+
+    PHYSICAL_ADDRESS phAddr;
+    phAddr.QuadPart = pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset;
+    NTSTATUS Status = STATUS_SUCCESS;
+    for (;;)
+    {
+        switch (pHdr->u8OpCode)
+        {
+            case VBOXCMDVBVA_OPTYPE_SYSMEMCMD:
+            {
+                VBOXCMDVBVA_SYSMEMCMD *pSysMem = (VBOXCMDVBVA_SYSMEMCMD*)pHdr;
+                if (pSubmitCommand->DmaBufferPhysicalAddress.QuadPart & PAGE_OFFSET_MASK)
+                {
+                    WARN(("command should be page aligned for now"));
+                    return STATUS_INVALID_PARAMETER;
+                }
+                pSysMem->phCmd = (VBOXCMDVBVAPHADDR)(pSubmitCommand->DmaBufferPhysicalAddress.QuadPart + pSubmitCommand->DmaBufferSubmissionStartOffset);
 #ifdef DEBUG
-            {
-                uint32_t cbRealDmaCmd = (pSysMem->Hdr.u8Flags | (pSysMem->Hdr.u.u8PrimaryID << 8));
-                Assert(cbRealDmaCmd >= cbDma);
-                if (cbDma < cbRealDmaCmd)
-                    WARN(("parrtial sysmem transfer"));
-            }
-#endif
+                {
+                    uint32_t cbRealDmaCmd = (pSysMem->Hdr.u8Flags | (pSysMem->Hdr.u.u8PrimaryID << 8));
+                    Assert(cbRealDmaCmd >= cbDma);
+                    if (cbDma < cbRealDmaCmd)
+                        WARN(("parrtial sysmem transfer"));
+                }
+#endif
+                break;
+            }
+            default:
+                break;
+        }
+
+        memcpy(pCurDstCmd, pHdr, cbCurCmd);
+        pCurDstCmd->u32FenceID = cbCurCmd;
+
+        phAddr.QuadPart += cbCurDma;
+        pHdr = (VBOXCMDVBVA_HDR*)(((uint8_t*)pHdr) + cbCurCmd);
+        pCurDstCmd = (VBOXCMDVBVA_HDR*)(((uint8_t*)pCurDstCmd) + cbCurCmd);
+        cbCmd -= cbCurCmd;
+        cbDma -= cbCurDma;
+        if (!cbCmd)
+        {
+            if (cbDma)
+            {
+                WARN(("invalid param"));
+                Status = STATUS_INVALID_PARAMETER;
+            }
             break;
         }
-        default:
+
+        if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
+        {
+            WARN(("invalid param"));
+            Status = STATUS_INVALID_PARAMETER;
             break;
-    }
-
-    int rc = VBoxCmdVbvaSubmit(pDevExt, &pDevExt->CmdVbva, pHdr, pSubmitCommand->SubmissionFenceId, cbCmd);
-    if (RT_SUCCESS(rc))
-        return STATUS_SUCCESS;
-
-    WARN(("VBoxCmdVbvaSubmit failed rc %d", rc));
-    return STATUS_UNSUCCESSFUL;
+        }
+
+        cbCurCmd = pHdr->u32FenceID & 0xff;
+        cbCurDma = pHdr->u32FenceID >> 16;
+
+        if (cbCmd < cbCurCmd)
+        {
+            WARN(("invalid param"));
+            Status = STATUS_INVALID_PARAMETER;
+            break;
+        }
+
+        if (cbDma < cbCurDma)
+        {
+            WARN(("invalid param"));
+            Status = STATUS_INVALID_PARAMETER;
+            break;
+        }
+    }
+
+    uint32_t u32FenceId = pSubmitCommand->SubmissionFenceId;
+
+    if (!NT_SUCCESS(Status))
+    {
+        /* nop the entire command on failure */
+        pDstHdr->u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
+        pDstHdr->u8Flags = 0;
+        pDstHdr->u.i8Result = 0;
+        u32FenceId = 0;
+    }
+
+    VBoxCmdVbvaSubmitUnlock(pDevExt, &pDevExt->CmdVbva, pDstHdr, u32FenceId);
+
+    return Status;
 }
 #endif
@@ -3455 +3546 @@
             if (pAlloc->AllocData.hostID)
             {
+                VBOXCMDVBVA_HDR *pHdr = (VBOXCMDVBVA_HDR*)pBuildPagingBuffer->pDmaBufferPrivateData;
+
                 cbBuffer = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
+                cbPrivateData = sizeof (*pHdr);
+
+                pHdr->u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
+                pHdr->u8Flags = 0;
+                pHdr->u.u8PrimaryID = 0;
+                pHdr->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
+                pHdr->u32FenceID = cbPrivateData | (cbBuffer << 16);
                 break;
             }
@@ -3471 +3571 @@
             pPaging->Hdr.u8Flags = 0;
             pPaging->Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
-            pPaging->Hdr.u32FenceID = 0;
 
             PMDL pMdl;
@@ -3524 +3623 @@
 
             VBOXCMDVBVA_SYSMEMCMD *pSysMemCmd = (VBOXCMDVBVA_SYSMEMCMD*)pBuildPagingBuffer->pDmaBufferPrivateData;
+
+            cbPrivateData = sizeof (*pSysMemCmd);
+
             pSysMemCmd->Hdr.u8OpCode = VBOXCMDVBVA_OPTYPE_SYSMEMCMD;
             pSysMemCmd->Hdr.u8Flags = cbBuffer & 0xff;
             pSysMemCmd->Hdr.u.u8PrimaryID = (cbBuffer >> 8) & 0xff;
             pSysMemCmd->Hdr.u8State = VBOXCMDVBVA_STATE_SUBMITTED;
-            pSysMemCmd->Hdr.u32FenceID = sizeof (*pSysMemCmd);
+            pSysMemCmd->Hdr.u32FenceID = cbPrivateData | (cbBuffer << 16);
             pSysMemCmd->phCmd = 0;
-
-            cbPrivateData = sizeof (*pSysMemCmd);
 
             break;
@@ -3551 +3651 @@
             }
 
+            cbBuffer = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
+
             VBOXCMDVBVA_HDR *pHdr = (VBOXCMDVBVA_HDR*)pBuildPagingBuffer->pDmaBufferPrivateData;
+
+            cbPrivateData = sizeof (*pHdr);
+
             pHdr->u8OpCode = VBOXCMDVBVA_OPTYPE_NOPCMD;
             pHdr->u8Flags = 0;
             pHdr->u.u8PrimaryID = 0;
             pHdr->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
-            pHdr->u32FenceID = sizeof (*pHdr);
-
-            cbPrivateData = sizeof (*pHdr);
+            pHdr->u32FenceID = cbPrivateData | (cbBuffer << 16);
+
             /** @todo: add necessary bits */
 //            WARN(("Impl!"));
-            cbBuffer = VBOXWDDM_DUMMY_DMABUFFER_SIZE;
             break;
         }
@@ -3582 +3685 @@
     }
 
+    Assert(cbPrivateData >= sizeof (VBOXCMDVBVA_HDR) || pBuildPagingBuffer->Operation == DXGK_OPERATION_DISCARD_CONTENT);
     Assert(pBuildPagingBuffer->Operation == DXGK_OPERATION_DISCARD_CONTENT || cbBuffer);
     Assert(cbBuffer <= pBuildPagingBuffer->DmaSize);
@@ -5981 +6085 @@
         }
 
+        Assert(cbPrivateData >= sizeof (VBOXCMDVBVA_HDR));
         pRender->pDmaBufferPrivateData = ((uint8_t*)pRender->pDmaBufferPrivateData) + cbPrivateData;
         pRender->pDmaBuffer = ((uint8_t*)pRender->pDmaBuffer) + cbBuffer;
 
         pCmd->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
-        pCmd->u32FenceID = cbPrivateData;
+        pCmd->u32FenceID = cbPrivateData | (cbBuffer << 16);
     }
     __except (EXCEPTION_EXECUTE_HANDLER)
@@ -6538 +6643 @@
     pHdr->u8State = VBOXCMDVBVA_STATE_SUBMITTED;
 
-    pHdr->u32FenceID = cbPrivateData;
+    pHdr->u32FenceID = cbPrivateData | (cbBuffer << 16);
 
     Assert(cbBuffer);
     Assert(cbPrivateData);
+    Assert(cbPrivateData >= sizeof (VBOXCMDVBVA_HDR));
     pPresent->pDmaBuffer = ((uint8_t*)pPresent->pDmaBuffer) + cbBuffer;
     pPresent->pDmaBufferPrivateData = ((uint8_t*)pPresent->pDmaBufferPrivateData) + cbPrivateData;

trunk/src/VBox/Devices/Graphics/DevVGA_VDMA.cpp

@@ -1557 +1557 @@
         case VBOXCMDVBVA_OPTYPE_SYSMEMCMD:
         {
+            if (cbCmd < sizeof (VBOXCMDVBVA_SYSMEMCMD))
+            {
+                WARN(("invalid command size"));
+                return -1;
+            }
             VBOXCMDVBVA_SYSMEMCMD *pSysmemCmd = (VBOXCMDVBVA_SYSMEMCMD*)pCmd;
             const VBOXCMDVBVA_HDR *pRealCmdHdr;
@@ -1700 +1705 @@
             PDMDevHlpPhysReleasePageMappingLock(pDevIns, &Lock);
             return i8Result;
+        }
+        case VBOXCMDVBVA_OPTYPE_COMPLEXCMD:
+        {
+            Assert(cbCmd >= sizeof (VBOXCMDVBVA_HDR));
+            ++pCmd;
+            cbCmd -= sizeof (*pCmd);
+            uint32_t cbCurCmd = 0;
+            for ( ; cbCmd; cbCmd -= cbCurCmd, pCmd = (VBOXCMDVBVA_HDR*)(((uint8_t*)pCmd) + cbCurCmd))
+            {
+                if (cbCmd < sizeof (VBOXCMDVBVA_HDR))
+                {
+                    WARN(("invalid command size"));
+                    return -1;
+                }
+
+                cbCurCmd = pCmd->u32FenceID;
+                if (cbCmd < cbCurCmd)
+                {
+                    WARN(("invalid command size"));
+                    return -1;
+                }
+
+                int8_t i8Result = vboxVDMACrCmdVbvaProcess(pVdma, pCmd, cbCurCmd);
+                if (i8Result < 0)
+                {
+                    WARN(("vboxVDMACrCmdVbvaProcess failed"));
+                    return i8Result;
+                }
+            }
+            return 0;
         }
         default: