Changeset 42028 in vbox for trunk/src/VBox/Additions

Timestamp:

Jul 5, 2012 3:22:55 PM (12 years ago)

Author:

vboxsync

Message:

wddm/crOpenGL: moreon kernel-based cr commands submission

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp

Files:

• Makefile.kmk (modified) (2 diffs)
• wddm/VBoxMPCr.cpp (modified) (4 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/Makefile.kmk

@@ -94 +94 @@
  endif
  
- VBoxVideoWddm_INCS       += ../../../include .. . ../../../../common/VBoxGuestLib $(VBOX_PATH_CROGL_INCLUDE) $(VBOX_PATH_CROGL_GENFILES)
+ VBoxVideoWddm_INCS       += \
+    ../../../include \
+    .. \
+    . \
+    ../../../../common/VBoxGuestLib \
+    $(VBOX_PATH_CROGL_INCLUDE) \
+    $(VBOX_PATH_CROGL_GENFILES) \
+    $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer
  VBoxVideoWddm_LDFLAGS.x86 += /Entry:DriverEntry@8
  VBoxVideoWddm_LDFLAGS.amd64 += /Entry:DriverEntry
@@ -114 +121 @@
         $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp \
         $(PATH_ROOT)/src/VBox/Additions/common/VBoxVideo/Modesetting.cpp
+ if defined(VBOX_WITH_CROGL) && defined(VBOX_WDDM_WITH_CRCMD)
+   VBoxVideoWddm_SOURCES   += \
+        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_buffer.c \
+        $(PATH_ROOT)/src/VBox/GuestHost/OpenGL/packer/pack_bounds.c \
+        $(VBOX_PATH_CROGL_GENFILES)/pack_bounds_swap.c \
+        wddm/VBoxMPCrUtil.cpp
+   VBoxVideoWddm_DEFS       + VBOX_WDDM_WITH_CRCMD
+ endif
  ifdef VBOXWDDM_WITH_VBVA
   VBoxVideoWddm_SOURCES   += \

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

@@ -25 +25 @@
 #include <cr_protocol.h>
 
-# if 0
+# ifdef VBOX_WDDM_WITH_CRCMD
 #  include <cr_pack.h>
 
-typedef struct PVBOXMP_SHGSMIPACKER
+typedef struct VBOXMP_CRSHGSMICON_BUFDR
+{
+    uint32_t cbBuf;
+    void *pvBuf;
+} VBOXMP_CRSHGSMICON_BUFDR, *PVBOXMP_CRSHGSMICON_BUFDR;
+
+typedef struct VBOXMP_CRSHGSMICON_BUFDR_CACHE
+{
+    volatile PVBOXMP_CRSHGSMICON_BUFDR pBufDr;
+} VBOXMP_CRSHGSMICON_BUFDR_CACHE, *PVBOXMP_CRSHGSMICON_BUFDR_CACHE;
+
+typedef struct VBOXMP_CRSHGSMICON
 {
     PVBOXMP_DEVEXT pDevExt;
+    PVBOXMP_CRCTLCON pCtlCon;
+    uint32_t u32ClientID;
+    VBOXMP_CRSHGSMICON_BUFDR_CACHE CmdDrCache;
+    VBOXMP_CRSHGSMICON_BUFDR_CACHE WbDrCache;
+} VBOXMP_CRSHGSMICON, *PVBOXMP_CRSHGSMICON;
+
+typedef struct VBOXMP_CRSHGSMIPACKER
+{
+    PVBOXMP_CRSHGSMICON pCon;
     CRPackContext CrPacker;
     CRPackBuffer CrBuffer;
-} PVBOXMP_SHGSMIPACKER, *PPVBOXMP_SHGSMIPACKER;
+} VBOXMP_CRSHGSMIPACKER, *PVBOXMP_CRSHGSMIPACKER;
 
 static void* vboxMpCrShgsmiBufferAlloc(PVBOXMP_DEVEXT pDevExt, HGSMISIZE cbData)
@@ -40 +60 @@
 }
 
+static VBOXVIDEOOFFSET vboxMpCrShgsmiBufferOffset(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
+{
+    return HGSMIPointerToOffset(&VBoxCommonFromDeviceExt(pDevExt)->guestCtx.heapCtx.Heap.area, (const HGSMIBUFFERHEADER *)pvBuffer);
+}
+
 static void vboxMpCrShgsmiBufferFree(PVBOXMP_DEVEXT pDevExt, void *pvBuffer)
 {
@@ -45 +70 @@
 }
 
+static void* vboxMpCrShgsmiConAlloc(PVBOXMP_CRSHGSMICON pCon, uint32_t cbBuffer)
+{
+    return vboxMpCrShgsmiBufferAlloc(pCon->pDevExt, cbBuffer);
+}
+
+static VBOXVIDEOOFFSET vboxMpCrShgsmiConBufOffset(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
+{
+    return vboxMpCrShgsmiBufferOffset(pCon->pDevExt, pvBuffer);
+}
+
+
+static void vboxMpCrShgsmiConFree(PVBOXMP_CRSHGSMICON pCon, void* pvBuffer)
+{
+    vboxMpCrShgsmiBufferFree(pCon->pDevExt, pvBuffer);
+}
+
+#define VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) VBOXWDDM_ROUNDBOUND((VBOXVDMACMD_SIZE_FROMBODYSIZE(RT_OFFSETOF(VBOXVDMACMD_CHROMIUM_CMD, aBuffers[_cBuffers]))), 8)
+#define VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(_pDr, _cBuffers, _type) ((_type*)(((uint8_t*)(_pDr)) + VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers)))
+#define VBOXMP_CRSHGSMICON_DR_SIZE(_cBuffers, _cbCmdBuf) ( VBOXMP_CRSHGSMICON_DR_CMDBUF_OFFSET(_cBuffers) + _cbCmdBuf)
+
+static int vboxMpCrShgsmiBufCacheBufReinit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr, uint32_t cbRequested)
+{
+    if (pDr->cbBuf >= cbRequested)
+        return VINF_SUCCESS;
+
+    if (pDr->pvBuf)
+        vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
+
+    pDr->pvBuf = vboxMpCrShgsmiConAlloc(pCon, cbRequested);
+    if (!pDr->pvBuf)
+    {
+        WARN(("vboxMpCrShgsmiConAlloc failed"));
+        pDr->cbBuf = 0;
+        return VERR_NO_MEMORY;
+    }
+
+    pDr->cbBuf = cbRequested;
+    return VINF_SUCCESS;
+}
+
+static void vboxMpCrShgsmiBufCacheFree(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, PVBOXMP_CRSHGSMICON_BUFDR pDr)
+{
+    if (ASMAtomicCmpXchgPtr(&pCache->pBufDr, pDr, NULL))
+        return;
+
+    /* the value is already cached, free the current one */
+    vboxMpCrShgsmiConFree(pCon, pDr->pvBuf);
+    vboxWddmMemFree(pDr);
+}
+
+static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheGetAllocDr(PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
+{
+    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = (PVBOXMP_CRSHGSMICON_BUFDR)ASMAtomicXchgPtr((void * volatile *)&pCache->pBufDr, NULL);
+    if (!pBufDr)
+    {
+        pBufDr = (PVBOXMP_CRSHGSMICON_BUFDR)vboxWddmMemAllocZero(sizeof (*pBufDr));
+        if (!pBufDr)
+        {
+            WARN(("vboxWddmMemAllocZero failed!"));
+            return NULL;
+        }
+    }
+    return pBufDr;
+}
+
+static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAlloc(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
+{
+    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
+    int rc = vboxMpCrShgsmiBufCacheBufReinit(pCon, pCache, pBufDr, cbBuffer);
+    if (RT_SUCCESS(rc))
+        return pBufDr;
+
+    WARN(("vboxMpCrShgsmiBufCacheBufReinit failed, rc %d", rc));
+
+    vboxMpCrShgsmiBufCacheFree(pCon, pCache, pBufDr);
+    return NULL;
+}
+
+static PVBOXMP_CRSHGSMICON_BUFDR vboxMpCrShgsmiBufCacheAllocAny(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache, uint32_t cbBuffer)
+{
+    PVBOXMP_CRSHGSMICON_BUFDR pBufDr = vboxMpCrShgsmiBufCacheGetAllocDr(pCache);
+
+    if (pBufDr->cbBuf)
+        return pBufDr;
+
+    int rc = vboxMpCrShgsmiBufCacheBufReinit(pCon, pCache, pBufDr, cbBuffer);
+    if (RT_SUCCESS(rc))
+        return pBufDr;
+
+    WARN(("vboxMpCrShgsmiBufCacheBufReinit failed, rc %d", rc));
+
+    vboxMpCrShgsmiBufCacheFree(pCon, pCache, pBufDr);
+    return NULL;
+}
+
+
+static int vboxMpCrShgsmiBufCacheInit(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
+{
+    memset(pCache, 0, sizeof (*pCache));
+    return VINF_SUCCESS;
+}
+
+static void vboxMpCrShgsmiBufCacheTerm(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_CRSHGSMICON_BUFDR_CACHE pCache)
+{
+    if (pCache->pBufDr)
+        vboxMpCrShgsmiBufCacheFree(pCon, pCache, pCache->pBufDr);
+}
+
+static int vboxMpCrShgsmiConConnect(PVBOXMP_CRSHGSMICON pCon, PVBOXMP_DEVEXT pDevExt, PVBOXMP_CRCTLCON pCrCtlCon)
+{
+    memset(pCon, 0, sizeof (*pCon));
+    int rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->CmdDrCache);
+    if (RT_SUCCESS(rc))
+    {
+        rc = vboxMpCrShgsmiBufCacheInit(pCon, &pCon->WbDrCache);
+        if (RT_SUCCESS(rc))
+        {
+            rc = VBoxMpCrCtlConConnect(pCrCtlCon, CR_PROTOCOL_VERSION_MAJOR, CR_PROTOCOL_VERSION_MINOR, &pCon->u32ClientID);
+            if (RT_SUCCESS(rc))
+            {
+                pCon->pDevExt = pDevExt;
+                pCon->pCtlCon = pCrCtlCon;
+                return VINF_SUCCESS;
+            }
+            else
+            {
+                WARN(("VBoxMpCrCtlConConnect failed rc %d", rc));
+            }
+            vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
+        }
+        else
+        {
+            WARN(("vboxMpCrShgsmiBufCacheInit2 failed rc %d", rc));
+        }
+        vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
+    }
+    else
+    {
+        WARN(("vboxMpCrShgsmiBufCacheInit1 failed rc %d", rc));
+    }
+
+    return rc;
+}
+
+static int vboxMpCrShgsmiConDisconnect(PVBOXMP_CRSHGSMICON pCon)
+{
+    int rc = VBoxMpCrCtlConDisconnect(pCon->pCtlCon, pCon->u32ClientID);
+    if (RT_FAILURE(rc))
+    {
+        WARN(("VBoxMpCrCtlConDisconnect failed rc %d", rc));
+        return rc;
+    }
+
+    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->WbDrCache);
+    vboxMpCrShgsmiBufCacheTerm(pCon, &pCon->CmdDrCache);
+
+    return VINF_SUCCESS;
+}
+
+typedef DECLCALLBACK(void) FNVBOXMP_CRSHGSMICON_SEND_COMPLETION(PVBOXMP_CRSHGSMICON pCon, void *pvRx, uint32_t cbRx, void *pvCtx);
+typedef FNVBOXMP_CRSHGSMICON_SEND_COMPLETION *PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION;
+
+typedef struct VBOXMP_CRSHGSMICON_SEND_COMPLETION
+{
+    PVBOXMP_CRSHGSMICON pCon;
+    PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pvnCompletion;
+    void *pvCompletion;
+} VBOXMP_CRSHGSMICON_SEND_COMPLETION, *PVBOXMP_CRSHGSMICON_SEND_COMPLETION;
+
+static DECLCALLBACK(VOID) vboxMpCrShgsmiConSendAsyncCompletion(PVBOXMP_DEVEXT pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
+{
+    /* we should be called from our DPC routine */
+    Assert(KeGetCurrentIrql() == DISPATCH_LEVEL);
+
+    PVBOXMP_CRSHGSMICON_SEND_COMPLETION pData = (PVBOXMP_CRSHGSMICON_SEND_COMPLETION)pvContext;
+    PVBOXVDMACBUF_DR pDr = VBOXVDMACBUF_DR_FROM_DDI_CMD(pCmd);
+    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
+    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
+    UINT cBufs = pBody->cBuffers;
+    /* the first one is a command buffer: obtain it and get the result */
+
+    /* if write back buffer is too small, issue read command.
+     * we can use exactly the same command buffer for it */
+    /* impl */
+    Assert(0);
+}
+
+static int vboxMpCrShgsmiConSendAsync(PVBOXMP_CRSHGSMICON pCon, void *pvTx, uint32_t cbTx, PFNVBOXMP_CRSHGSMICON_SEND_COMPLETION pfnCompletion, void *pvCompletion)
+{
+    const uint32_t cBuffers = 3;
+    const uint32_t cbCmd = VBOXMP_CRSHGSMICON_DR_SIZE(cBuffers, sizeof (CRVBOXHGSMIWRITEREAD));
+    PVBOXMP_CRSHGSMICON_BUFDR pCmdDr = vboxMpCrShgsmiBufCacheAlloc(pCon, &pCon->CmdDrCache, cbCmd);
+    if (!pCmdDr)
+    {
+        WARN(("vboxMpCrShgsmiBufCacheAlloc for cmd dr failed"));
+        return VERR_NO_MEMORY;
+    }
+    PVBOXMP_CRSHGSMICON_BUFDR pWbDr = vboxMpCrShgsmiBufCacheAllocAny(pCon, &pCon->WbDrCache, 1000);
+    if (!pWbDr)
+    {
+        WARN(("vboxMpCrShgsmiBufCacheAlloc for wb dr failed"));
+        vboxMpCrShgsmiBufCacheFree(pCon, &pCon->CmdDrCache, pCmdDr);
+        return VERR_NO_MEMORY;
+    }
+
+    PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pCmdDr->pvBuf;
+    pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
+    pDr->cbBuf = cbCmd;
+    pDr->rc = VERR_NOT_IMPLEMENTED;
+
+    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
+    pHdr->enmType = VBOXVDMACMD_TYPE_CHROMIUM_CMD;
+    pHdr->u32CmdSpecific = 0;
+    VBOXVDMACMD_CHROMIUM_CMD *pBody = VBOXVDMACMD_BODY(pHdr, VBOXVDMACMD_CHROMIUM_CMD);
+    pBody->cBuffers = cBuffers;
+    CRVBOXHGSMIWRITEREAD *pCmd = VBOXMP_CRSHGSMICON_DR_GET_CMDBUF(pDr, cBuffers, CRVBOXHGSMIWRITEREAD);
+    pCmd->hdr.result      = VERR_WRONG_ORDER;
+    pCmd->hdr.u32ClientID = pCon->u32ClientID;
+    pCmd->hdr.u32Function = SHCRGL_GUEST_FN_WRITE_READ;
+    //    pCmd->hdr.u32Reserved = 0;
+    pCmd->iBuffer = 1;
+    pCmd->iWriteback = 2;
+    pCmd->cbWriteback = 0;
+
+    VBOXVDMACMD_CHROMIUM_BUFFER *pBufCmd = &pBody->aBuffers[0];
+    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pCmd);
+    pBufCmd->cbBuffer = sizeof (*pCmd);
+    pBufCmd->u32GuestData = 0;
+    pBufCmd->u64GuestData = (uint64_t)pCmdDr;
+
+    pBufCmd = &pBody->aBuffers[1];
+    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pvTx);
+    pBufCmd->cbBuffer = cbTx;
+    pBufCmd->u32GuestData = 0;
+    pBufCmd->u64GuestData = 0;
+
+    pBufCmd = &pBody->aBuffers[2];
+    pBufCmd->offBuffer = vboxMpCrShgsmiConBufOffset(pCon, pWbDr->pvBuf);
+    pBufCmd->cbBuffer = pWbDr->cbBuf;
+    pBufCmd->u32GuestData = 0;
+    pBufCmd->u64GuestData = (uint64_t)pWbDr;
+
+    PVBOXMP_DEVEXT pDevExt = pCon->pDevExt;
+    PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
+    vboxVdmaDdiCmdInit(pDdiCmd, 0, 0, vboxMpCrShgsmiConSendAsyncCompletion, pDr);
+    /* mark command as submitted & invisible for the dx runtime since dx did not originate it */
+    vboxVdmaDdiCmdSubmittedNotDx(pDdiCmd);
+    int rc = vboxVdmaCBufDrSubmit(pDevExt, &pDevExt->u.primary.Vdma, pDr);
+    if (RT_SUCCESS(rc))
+    {
+        return STATUS_SUCCESS;
+    }
+
+    /* impl failure branch */
+    Assert(0);
+    return rc;
+}
+
+static CRMessageOpcodes *
+vboxMpCrPackerPrependHeader( CRPackBuffer *buf, unsigned int *len, unsigned int senderID )
+{
+    UINT num_opcodes;
+    CRMessageOpcodes *hdr;
+
+    Assert(buf);
+    Assert(buf->opcode_current < buf->opcode_start);
+    Assert(buf->opcode_current >= buf->opcode_end);
+    Assert(buf->data_current > buf->data_start);
+    Assert(buf->data_current <= buf->data_end);
+
+    num_opcodes = (UINT)(buf->opcode_start - buf->opcode_current);
+    hdr = (CRMessageOpcodes *)
+        ( buf->data_start - ( ( num_opcodes + 3 ) & ~0x3 ) - sizeof(*hdr) );
+
+    Assert((void *) hdr >= buf->pack);
+
+    hdr->header.type = CR_MESSAGE_OPCODES;
+    hdr->numOpcodes  = num_opcodes;
+
+    *len = (UINT)(buf->data_current - (unsigned char *) hdr);
+
+    return hdr;
+}
+
 static void vboxMpCrShgsmiPackerCbFlush(void *pvFlush)
 {
-    PPVBOXMP_SHGSMIPACKER pPacker = (PPVBOXMP_SHGSMIPACKER)pvFlush;
+    PVBOXMP_CRSHGSMIPACKER pPacker = (PVBOXMP_CRSHGSMIPACKER)pvFlush;
 
     crPackReleaseBuffer(&pPacker->CrPacker);
@@ -65 +374 @@
 }
 
-static int vboxMpCrShgsmiPackerInit(PPVBOXMP_SHGSMIPACKER pPacker, PVBOXMP_DEVEXT pDevExt)
+int vboxMpCrShgsmiPackerInit(PVBOXMP_CRSHGSMIPACKER pPacker, PVBOXMP_CRSHGSMICON pCon)
 {
     memset(pPacker, 0, sizeof (*pPacker));
 
-    static const cbBuffer = 1000;
-    void *pvBuffer = vboxMpCrShgsmiBufferAlloc(pDevExt, cbBuffer);
+    static const HGSMISIZE cbBuffer = 1000;
+    void *pvBuffer = vboxMpCrShgsmiConAlloc(pCon, cbBuffer);
     if (!pvBuffer)
     {
-        WARN(("vboxMpCrShgsmiBufferAlloc failed"));
+        WARN(("vboxMpCrShgsmiConAlloc failed"));
         return VERR_NO_MEMORY;
     }
+    pPacker->pCon = pCon;
     crPackInitBuffer(&pPacker->CrBuffer, pvBuffer, cbBuffer, cbBuffer);
     crPackSetBuffer(&pPacker->CrPacker, &pPacker->CrBuffer);