Changeset 33171 in vbox

Timestamp:

Oct 15, 2010 11:10:10 PM (14 years ago)

Author:

vboxsync

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

66707

Message:

wddm/3d: chromium hgsmi fixes

Location:

trunk/src/VBox

Files:

• Additions/WINNT/Graphics/Display/wddm/VBoxCrHgsmi.cpp (modified) (4 diffs)
• Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp (modified) (8 diffs)
• Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h (modified) (1 diff)
• Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiBase.h (modified) (3 diffs)
• Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp (modified) (8 diffs)
• Devices/Graphics/DevVGA_VDMA.cpp (modified) (4 diffs)
• GuestHost/OpenGL/util/vboxhgsmi.c (modified) (53 diffs)
• HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxCrHgsmi.cpp

@@ -54 +54 @@
     if (g_hVBoxCrHgsmiProvider)
     {
+        if (g_pfnVBoxDispCrHgsmiInit)
+        {
+            g_pfnVBoxDispCrHgsmiInit(pCallbacks);
+        }
         ++g_cVBoxCrHgsmiProvider;
         return VINF_SUCCESS;
@@ -73 +77 @@
     {
         hClient = g_pfnVBoxDispCrHgsmiQueryClient();
+#ifdef DEBUG_misha
+        Assert(hClient);
+#endif
         if (hClient)
             return hClient;
@@ -78 +85 @@
     PVBOXUHGSMI_PRIVATE_KMT pHgsmiGL = gt_pHgsmiGL;
     if (pHgsmiGL)
+    {
+        Assert(pHgsmiGL->BasePrivate.hClient);
         return pHgsmiGL->BasePrivate.hClient;
+    }
     pHgsmiGL = (PVBOXUHGSMI_PRIVATE_KMT)RTMemAllocZ(sizeof (*pHgsmiGL));
     if (pHgsmiGL)
@@ -84 +94 @@
         HRESULT hr = vboxUhgsmiKmtCreate(pHgsmiGL, TRUE /* bD3D tmp for injection thread*/);
         Assert(hr == S_OK);
-        hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&pHgsmiGL->BasePrivate.Base);
-        Assert(hClient);
-        pHgsmiGL->BasePrivate.hClient = hClient;
-        gt_pHgsmiGL = pHgsmiGL;
+        if (hr == S_OK)
+        {
+            hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&pHgsmiGL->BasePrivate.Base);
+            Assert(hClient);
+            pHgsmiGL->BasePrivate.hClient = hClient;
+            gt_pHgsmiGL = pHgsmiGL;
+        }
     }
     else

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -732 +732 @@
 #endif
 
-VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
-{
-#ifdef VBOX_WITH_CRHGSMI
-    g_VBoxCrHgsmiCallbacks = *pCallbacks;
-#endif
-    return VINF_SUCCESS;
-}
-
 #ifdef VBOX_WITH_CRHGSMI
 static __declspec(thread) PVBOXUHGSMI_PRIVATE_BASE gt_pHgsmi = NULL;
 #endif
 
+VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiInit(PVBOXCRHGSMI_CALLBACKS pCallbacks)
+{
+#ifdef VBOX_WITH_CRHGSMI
+    vboxDispLock(); /* the lock is needed here only to ensure callbacks are not initialized & used concurrently
+                     * @todo: make a separate call used to init the per-thread info and make the VBoxDispCrHgsmiInit be called only once */
+    g_VBoxCrHgsmiCallbacks = *pCallbacks;
+    PVBOXUHGSMI_PRIVATE_BASE pHgsmi = gt_pHgsmi;
+#ifdef DEBUG_misha
+    Assert(pHgsmi);
+#endif
+    if (pHgsmi)
+    {
+        if (!pHgsmi->hClient)
+        {
+            pHgsmi->hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&pHgsmi->Base);
+            Assert(pHgsmi->hClient);
+        }
+    }
+    vboxDispUnlock();
+#endif
+    return VINF_SUCCESS;
+}
+
 VBOXWDDMDISP_DECL(int) VBoxDispCrHgsmiTerm()
 {
@@ -753 +768 @@
 #ifdef VBOX_WITH_CRHGSMI
     PVBOXUHGSMI_PRIVATE_BASE pHgsmi = gt_pHgsmi;
+#ifdef DEBUG_misha
+    Assert(pHgsmi);
+#endif
     if (pHgsmi)
+    {
+        Assert(pHgsmi->hClient);
         return pHgsmi->hClient;
+    }
 #endif
     return NULL;
@@ -760 +781 @@
 
 #ifdef VBOX_WITH_CRHGSMI
-static int vboxUhgsmiGlobalRetain()
-{
-    int rc = VINF_SUCCESS;
+static HRESULT vboxUhgsmiGlobalRetain()
+{
+    HRESULT hr = S_OK;
     vboxDispLock();
     if (!g_cVBoxUhgsmiKmtRefs)
     {
-        rc = vboxUhgsmiKmtCreate(&g_VBoxUhgsmiKmt, TRUE);
-        AssertRC(rc);
-    }
-
-    if (RT_SUCCESS(rc))
+        hr = vboxUhgsmiKmtCreate(&g_VBoxUhgsmiKmt, TRUE);
+        Assert(hr == S_OK);
+        /* can not do it here because callbacks may not be set yet
+         * @todo: need to call the cr lib from here to get the callbacks
+         * rather than making the cr lib call us */
+//        if (hr == S_OK)
+//        {
+//            g_VBoxUhgsmiKmt.BasePrivate.hClient = g_VBoxCrHgsmiCallbacks.pfnClientCreate(&g_VBoxUhgsmiKmt.BasePrivate.Base);
+//            Assert(g_VBoxUhgsmiKmt.BasePrivate.hClient);
+//        }
+    }
+
+    if (hr == S_OK)
     {
         ++g_cVBoxUhgsmiKmtRefs;
@@ -776 +805 @@
     vboxDispUnlock();
 
-    return rc;
-}
-
-static int vboxUhgsmiGlobalRelease()
-{
-    int rc = VINF_SUCCESS;
+    return hr;
+}
+
+static HRESULT vboxUhgsmiGlobalRelease()
+{
+    HRESULT hr = S_OK;
     vboxDispLock();
     --g_cVBoxUhgsmiKmtRefs;
     if (!g_cVBoxUhgsmiKmtRefs)
     {
-        rc = vboxUhgsmiKmtDestroy(&g_VBoxUhgsmiKmt);
-        AssertRC(rc);
+        if (g_VBoxUhgsmiKmt.BasePrivate.hClient)
+            g_VBoxCrHgsmiCallbacks.pfnClientDestroy(g_VBoxUhgsmiKmt.BasePrivate.hClient);
+        hr = vboxUhgsmiKmtDestroy(&g_VBoxUhgsmiKmt);
+        Assert(hr == S_OK);
     }
     vboxDispUnlock();
-    return rc;
+    return hr;
 }
 
@@ -803 +834 @@
 }
 
-int vboxUhgsmiGlobalSetCurrent()
-{
-    int rc = vboxUhgsmiGlobalRetain();
-    AssertRC(rc);
-    if (RT_SUCCESS(rc))
+HRESULT vboxUhgsmiGlobalSetCurrent()
+{
+    HRESULT hr = vboxUhgsmiGlobalRetain();
+    Assert(hr == S_OK);
+    if (hr == S_OK)
         vboxDispCrHgsmiClientSet(&g_VBoxUhgsmiKmt.BasePrivate);
-    return rc;
-}
-
-int vboxUhgsmiGlobalClearCurrent()
+    return hr;
+}
+
+HRESULT vboxUhgsmiGlobalClearCurrent()
 {
     vboxUhgsmiGlobalRelease();
     vboxDispCrHgsmiClientClear();
-    return VINF_SUCCESS;
+    return S_OK;
 }
 
@@ -6967 +6998 @@
         pDevice->pDevice9If->Release();
     }
+
+#ifdef VBOX_WITH_CRHGSMI
+    vboxDispLock();
+    if (pDevice->Uhgsmi.BasePrivate.hClient)
+        g_VBoxCrHgsmiCallbacks.pfnClientDestroy(pDevice->Uhgsmi.BasePrivate.hClient);
+    vboxDispUnlock();
+#endif
 
     HRESULT hr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
@@ -7727 +7765 @@
             {
 #ifdef VBOX_WITH_CRHGSMI
-                int rc = vboxUhgsmiGlobalRetain();
-                AssertRC(rc);
-                if (RT_SUCCESS(rc))
+                hr = vboxUhgsmiGlobalRetain();
+                Assert(hr == S_OK);
+                if (hr == S_OK)
 #endif
                 {
@@ -7772 +7810 @@
 #endif
                 }
-#ifdef VBOX_WITH_CRHGSMI
-                else
-                {
-                    hr = E_FAIL;
-                }
-#endif
             } while (0);
         }

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h

@@ -267 +267 @@
 
 #ifdef VBOX_WITH_CRHGSMI
-int vboxUhgsmiGlobalSetCurrent();
-int vboxUhgsmiGlobalClearCurrent();
+HRESULT vboxUhgsmiGlobalSetCurrent();
+HRESULT vboxUhgsmiGlobalClearCurrent();
 #endif
 

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiBase.h

@@ -93 +93 @@
     fLockFlags.WriteOnly = fFlags.bWriteOnly;
     fLockFlags.DonotWait = fFlags.bDonotWait;
-    fLockFlags.Discard = fFlags.bDiscard;
+//    fLockFlags.Discard = fFlags.bDiscard;
     *pfFlags = fLockFlags;
     return VINF_SUCCESS;
@@ -129 +129 @@
                   NULL, /* LPSECURITY_ATTRIBUTES lpSemaphoreAttributes */
                   0, /* LONG lInitialCount */
-                  ~0L, /* LONG lMaximumCount */
+                  (LONG)((~0UL) >> 1), /* LONG lMaximumCount */
                   NULL /* LPCTSTR lpName */
                 );
@@ -187 +187 @@
         memset(pAllocationList, 0, sizeof (D3DDDI_ALLOCATIONLIST));
         pAllocationList->hAllocation = pBuffer->hAllocation;
+        pAllocationList->Value = 0;
         pAllocationList->WriteOperation = !pBufInfo->fFlags.bHostReadOnly;
         pAllocationList->DoNotRetireInstance = pBufInfo->fFlags.bDoNotRetire;

trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

@@ -60 +60 @@
     {
         pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart;
+        pInfo->segmentIdAlloc = pDmaAlloc->SegmentId;
+    }
+    else
+        pInfo->segmentIdAlloc = 0;
+    pInfo->srcId = pAlloc->SurfDesc.VidPnSourceId;
+}
+
+static void vboxWddmPopulateDmaAllocInfoWithOffset(PVBOXWDDM_DMA_ALLOCINFO pInfo, PVBOXWDDM_ALLOCATION pAlloc, DXGK_ALLOCATIONLIST *pDmaAlloc, uint32_t offStart)
+{
+    pInfo->pAlloc = pAlloc;
+    if (pDmaAlloc->SegmentId)
+    {
+        pInfo->offAlloc = (VBOXVIDEOOFFSET)pDmaAlloc->PhysicalAddress.QuadPart + offStart;
         pInfo->segmentIdAlloc = pDmaAlloc->SegmentId;
     }
@@ -1437 +1450 @@
         case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
         {
-            ObDereferenceObject(pAllocation->pSynchEvent);
+            if (pAllocation->pSynchEvent)
+            {
+                ObDereferenceObject(pAllocation->pSynchEvent);
+            }
             break;
         }
@@ -1577 +1593 @@
                     pAllocation->SurfDesc.cbSize = pAllocInfo->cbBuffer;
                     pAllocationInfo->Flags.CpuVisible = 1;
-                    pAllocationInfo->Flags.SynchronousPaging = 1;
+//                    pAllocationInfo->Flags.SynchronousPaging = 1;
                     pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_MAXIMUM;
                     switch (pAllocInfo->enmSynchType)
@@ -1595 +1611 @@
                         case VBOXUHGSMI_SYNCHOBJECT_TYPE_NONE:
                             pAllocation->pSynchEvent = NULL;
-                            Status == STATUS_SUCCESS;
+                            Status = STATUS_SUCCESS;
                             break;
                         default:
@@ -2033 +2049 @@
                         DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)(pPrivateBuf + pPatchList->PatchOffset);
                         pAllocation2Patch->SegmentId = pAllocationList->SegmentId;
-                        pAllocation2Patch->PhysicalAddress = pAllocationList->PhysicalAddress;
+                        pAllocation2Patch->PhysicalAddress.QuadPart = pAllocationList->PhysicalAddress.QuadPart + pPatchList->AllocationOffset;
+                        Assert(!(pAllocationList->PhysicalAddress.QuadPart & 0xfffUL)); /* <- just a check to ensure allocation offset does not go here */
                     }
                 }
@@ -2543 +2560 @@
 
     NTSTATUS Status = STATUS_SUCCESS;
+    PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
 
     dfprintf(("==> "__FUNCTION__ ", context(0x%x)\n", hAdapter));
@@ -2551 +2569 @@
         case DXGK_OPERATION_TRANSFER:
         {
+            PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Transfer.hAllocation;
+            uint8_t* pvVramBase = pDevExt->pvVisibleVram;
+            SIZE_T cbSize = pBuildPagingBuffer->Transfer.TransferSize;
+            uint8_t *pvSrc, *pvDst;
+            if (pBuildPagingBuffer->Transfer.Source.SegmentId)
+            {
+#ifdef DEBUG_misha
+                Assert(pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart);
+#endif
+                pvSrc  = pvVramBase + pBuildPagingBuffer->Transfer.Source.SegmentAddress.QuadPart;
+                pvSrc += pBuildPagingBuffer->Transfer.TransferOffset;
+            }
+            else
+            {
+                pvSrc  = (uint8_t*)MmGetMdlVirtualAddress(pBuildPagingBuffer->Transfer.Source.pMdl);
+                pvSrc += pBuildPagingBuffer->Transfer.MdlOffset * 0x1000 /* page size */;
+            }
+
+            if (pBuildPagingBuffer->Transfer.Destination.SegmentId)
+            {
+#ifdef DEBUG_misha
+                Assert(pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart);
+#endif
+                pvDst  = pvVramBase + pBuildPagingBuffer->Transfer.Destination.SegmentAddress.QuadPart;
+                pvDst += pBuildPagingBuffer->Transfer.TransferOffset;
+            }
+            else
+            {
+                pvDst  = (uint8_t*)MmGetMdlVirtualAddress(pBuildPagingBuffer->Transfer.Destination.pMdl);
+                pvDst += pBuildPagingBuffer->Transfer.MdlOffset * 0x1000 /* page size */;
+            }
+
+            memcpy(pvDst, pvSrc, cbSize);
 //            pBuildPagingBuffer->pDmaBuffer = (uint8_t*)pBuildPagingBuffer->pDmaBuffer + VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_TRANSFER);
             break;
@@ -4067 +4118 @@
             {
                 PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromAllocList(pDevExt, pAllocationList);
-                vboxWddmPopulateDmaAllocInfo(&pSubmInfo->Alloc, pAlloc, pAllocationList);
+                vboxWddmPopulateDmaAllocInfoWithOffset(&pSubmInfo->Alloc, pAlloc, pAllocationList, pSubmUmInfo->offData);
 
                 pSubmInfo->cbData = pSubmUmInfo->cbData;

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

@@ -247 +247 @@
                 if (pVGAState->pDrv->pfnCrHgsmiCommandProcess)
                 {
+                    VBoxSHGSMICommandMarkAsynchCompletion(pCmd);
                     pVGAState->pDrv->pfnCrHgsmiCommandProcess(pVGAState->pDrv, pCrCmd);
                     return true;
@@ -276 +277 @@
     VBOXVDMACMD *pDmaHdr = VBOXVDMACMD_FROM_BODY(pCmd);
     VBOXVDMACBUF_DR *pDr = VBOXVDMACBUF_DR_FROM_TAIL(pDmaHdr);
+    AssertRC(rc);
     pDr->rc = rc;
 
     Assert(pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD);
-    rc = HGSMICompleteGuestCommand(pIns, pDr, true /* do Irq */);
+    rc = VBoxSHGSMICommandComplete(pIns, pDr);
     AssertRC(rc);
     return rc;
@@ -289 +291 @@
     PVBOXVDMACMD_CHROMIUM_CTL_PRIVATE pCmdPrivate = VBOXVDMACMD_CHROMIUM_CTL_PRIVATE_FROM_CTL(pCmd);
     pCmdPrivate->rc = rc;
+    AssertRC(rc);
     if (pCmdPrivate->pfnCompletion)
     {
@@ -1076 +1079 @@
 #endif
 
+#ifdef DEBUG_misha
+    Assert(0);
+#endif
+
     VBOXVDMACMD_SUBMIT_CONTEXT Context;
     Context.pVdma = pVdma;

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

@@ -39 +39 @@
 
 #include <iprt/thread.h>
+#include <iprt/assert.h>
 
 #include <VBox/VBoxCrHgsmi.h>
@@ -104 +105 @@
 DECLINLINE(PCRVBOXHGSMI_CLIENT) _crVBoxHGSMIClientGet()
 {
-    return (PCRVBOXHGSMI_CLIENT)VBoxCrHgsmiQueryClient();
+    PCRVBOXHGSMI_CLIENT pClient = (PCRVBOXHGSMI_CLIENT)VBoxCrHgsmiQueryClient();
+    Assert(pClient);
+    return pClient;
 }
 
@@ -142 +145 @@
         return VINF_SUCCESS;
     }
+    Assert(0);
     crDebug("vboxCall failed with %x\n", GetLastError());
     return VERR_NOT_SUPPORTED;
@@ -237 +241 @@
     fFlags.bDiscard = 1;
     rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, cbBuffer, fFlags, (void**)&pHdr);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
         crWarning("Failed to Lock the command buffer of size(%d), rc(%d)\n", cbBuffer, rc);
@@ -260 +265 @@
     fFlags.bReadOnly = 1;
     rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, cbBuffer, fFlags, (void**)&pHdr);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
         crWarning("Failed to Lock the command buffer of size(%d), rc(%d)\n", cbBuffer, rc);
@@ -268 +274 @@
 {
     int rc = pClient->pCmdBuffer->pfnUnlock(pClient->pCmdBuffer);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
         crWarning("Failed to Unlock the command buffer rc(%d)\n", rc);
@@ -277 +284 @@
     VBOXUHGSMI_BUFFER_LOCK_FLAGS fFlags;
     int rc;
+
     fFlags.Value = 0;
     fFlags.bReadOnly = 1;
     rc = pClient->pCmdBuffer->pfnLock(pClient->pCmdBuffer, 0, sizeof (*pHdr), fFlags, (void**)&pHdr);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
     {
@@ -287 +296 @@
 
     rc = pHdr->result;
+    AssertRC(rc);
     pClient->pCmdBuffer->pfnUnlock(pClient->pCmdBuffer);
 
@@ -297 +307 @@
     PVBOXUHGSMI_BUFFER pBuf;
     int rc;
+
     CRASSERT(pHdr->magic == CR_VBOXHGSMI_BUFFER_MAGIC);
     pBuf = pHdr->pBuffer;
     rc = pBuf->pfnUnlock(pBuf);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
     {
@@ -311 +323 @@
     PVBOXUHGSMI_BUFFER buf;
     int rc;
+
     buf = (PVBOXUHGSMI_BUFFER ) crBufferPoolPop(pClient->bufpool, cbSize);
 
     if (!buf)
     {
+        Assert(0);
+
         crDebug("Buffer pool %p was empty; allocating new %d byte buffer.",
                         (void *) pClient->bufpool,
@@ -321 +336 @@
                                 VBOXUHGSMI_SYNCHOBJECT_TYPE_NONE, NULL,
                                 &buf);
+        AssertRC(rc);
         if (RT_FAILURE(rc))
             crWarning("Failed to Create a buffer of size(%d), rc(%d)\n", cbSize, rc);
@@ -341 +357 @@
     if (!pBuf)
     {
+        Assert(0);
+
         pBuf = (CRVBOXHGSMIBUFFER*)crAlloc(CRVBOXHGSMI_BUF_HDR_SIZE() + cbSize);
+        Assert(pBuf);
         if (pBuf)
         {
@@ -363 +382 @@
 
     buf = _crVBoxHGSMIBufAlloc(pClient, CRVBOXHGSMI_BUF_SIZE(cbSize));
-
+    Assert(buf);
     if (buf)
     {
@@ -390 +409 @@
 {
     PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
-    return _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
+    void *pvBuf = _crVBoxHGSMIDoAlloc(pClient, conn->buffer_size);
+    Assert(pvBuf);
+    return pvBuf;
 }
 
@@ -422 +443 @@
     {
         CRVBOXHGSMIINJECT *parms = (CRVBOXHGSMIINJECT *)_crVBoxHGSMICmdBufferLock(pClient, sizeof (*parms));
+        Assert(parms);
         if (!parms)
         {
@@ -446 +468 @@
 
         rc = pClient->pHgsmi->pfnBufferSubmitAsynch(pClient->pHgsmi, aSubmit, 2);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
@@ -478 +501 @@
 
         rc = pClient->pHgsmi->pfnBufferSubmitAsynch(pClient->pHgsmi, aSubmit, 2);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
@@ -497 +521 @@
 static void crVBoxHGSMIWriteExact(CRConnection *conn, const void *buf, unsigned int len)
 {
+    Assert(0);
+
     CRASSERT(0);
 //    PCRVBOXHGSMI_CLIENT pClient;
@@ -515 +541 @@
     uint32_t cbBuffer;
 
+    Assert(parms);
+
     parms->hdr.result      = VERR_WRONG_ORDER;
     parms->hdr.u32ClientID = conn->u32ClientID;
@@ -545 +573 @@
 
     rc = pClient->pHgsmi->pfnBufferSubmitAsynch(pClient->pHgsmi, aSubmit, 2);
+    AssertRC(rc);
     if (RT_FAILURE(rc))
     {
@@ -552 +581 @@
 
     parms = (CRVBOXHGSMIREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
+    Assert(parms);
     if (!parms)
     {
@@ -569 +599 @@
         fFlags.Value = 0;
         rc = pClient->pHGBuffer->pfnLock(pClient->pHGBuffer, 0, cbBuffer, fFlags, &pClient->pvHGBuffer);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
@@ -617 +648 @@
         void *pvBuf;
         pBuf = _crVBoxHGSMIBufAlloc(pClient, len);
+        Assert(pBuf);
         if (!pBuf)
             return;
+
+        Assert(!offBuffer);
 
         offBuffer = 0;
@@ -625 +659 @@
         fFlags.bWriteOnly = 1;
         rc = pBuf->pfnLock(pBuf, 0, len, fFlags, &pvBuf);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
             memcpy(pvBuf, buf, len);
             rc = pBuf->pfnUnlock(pBuf);
+            AssertRC(rc);
             CRASSERT(rc);
         }
@@ -637 +673 @@
         }
     }
+    else
+    {
+        pBuf = (PVBOXUHGSMI_BUFFER)buf;
+    }
 
     do
@@ -643 +683 @@
         {
             rc = pClient->pHGBuffer->pfnUnlock(pClient->pHGBuffer);
+            AssertRC(rc);
             if (RT_FAILURE(rc))
                 break;
@@ -660 +701 @@
         aSubmit[2].cbData = pClient->pHGBuffer->cbBuffer;
         aSubmit[2].fFlags.Value = 0;
-        aSubmit[2].fFlags.bHostWriteOnly = 1;
-
-        rc = pClient->pHgsmi->pfnBufferSubmitAsynch(pClient->pHgsmi, aSubmit, 2);
+
+        rc = pClient->pHgsmi->pfnBufferSubmitAsynch(pClient->pHgsmi, aSubmit, 3);
+        AssertRC(rc);
         if (RT_FAILURE(rc))
         {
@@ -670 +711 @@
 
         parms = (CRVBOXHGSMIWRITEREAD *)_crVBoxHGSMICmdBufferLockRo(pClient, sizeof (*parms));
+        Assert(parms);
         if (parms)
         {
@@ -681 +723 @@
                 rc = pClient->pHgsmi->pfnBufferCreate(pClient->pHgsmi, CRVBOXHGSMI_PAGE_ALIGN(cbWriteback),
                                 VBOXUHGSMI_SYNCHOBJECT_TYPE_NONE, NULL, &pClient->pHGBuffer);
+                AssertRC(rc);
                 CRASSERT(RT_SUCCESS(rc));
                 if (RT_SUCCESS(rc))
@@ -713 +756 @@
     PCRVBOXHGSMI_CLIENT pClient;
     PVBOXUHGSMI_BUFFER pBuf;
+
+    Assert(0);
 
     if (!bufp) /* We're sending a user-allocated buffer. */
@@ -735 +780 @@
 
     pBuf = _crVBoxHGSMIBufFromMemPtr(*bufp);
+    Assert(pBuf);
     if (!pBuf)
         return;
@@ -767 +813 @@
     PCRVBOXHGSMI_CLIENT pClient;
     PVBOXUHGSMI_BUFFER pBuf = _crVBoxHGSMIBufFromMemPtr(buf);
+    Assert(pBuf);
+    Assert(0);
     CRASSERT(0);
     if (!pBuf)
@@ -777 +825 @@
 {
     CRVBOXHGSMIBUFFER *hgsmi_buffer = (CRVBOXHGSMIBUFFER *) buf - 1;
+
+    Assert(0);
+
     CRASSERT(hgsmi_buffer->magic == CR_VBOXHGSMI_BUFFER_MAGIC);
 
@@ -809 +860 @@
 
     len = conn->cbBuffer;
+    Assert(len > 0);
+    Assert(conn->pBuffer);
     CRASSERT(len > 0);
     CRASSERT(conn->pBuffer);
@@ -883 +936 @@
 {
     PCRVBOXHGSMI_CLIENT pClient = _crVBoxHGSMIClientGet();
+
+    Assert(pClient);
+    Assert(0);
+
     _crVBoxHGSMIReceiveMessage(conn, pClient);
 }
@@ -890 +947 @@
 static void crVBoxHGSMIAccept( CRConnection *conn, const char *hostname, unsigned short port )
 {
+    Assert(0);
+
     CRASSERT(conn && conn->pHostBuffer);
 #ifdef IN_GUEST
@@ -912 +971 @@
 
     rc = crVBoxHGCMCall(&parms, sizeof(parms));
+
+    AssertRC(rc);
 
     if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
@@ -954 +1015 @@
         if (g_crvboxhgsmi.hGuestDrv == INVALID_HANDLE_VALUE)
         {
+            Assert(0);
             crDebug("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
             return FALSE;
@@ -1004 +1066 @@
         else
         {
+            Assert(0);
             crDebug("HGCM connect failed with rc=0x%x\n", info.result);
         }
@@ -1118 +1181 @@
 static void crVBoxHGSMIInstantReclaim(CRConnection *conn, CRMessage *mess)
 {
+    Assert(0);
+
     crVBoxHGSMIFree(conn, mess);
     CRASSERT(FALSE);
@@ -1124 +1189 @@
 static void crVBoxHGSMIHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len )
 {
+    Assert(0);
+
     CRASSERT(FALSE);
 }
@@ -1130 +1197 @@
 {
     PCRVBOXHGSMI_CLIENT pClient = crAlloc(sizeof (CRVBOXHGSMI_CLIENT));
+
     if (pClient)
     {
@@ -1137 +1205 @@
                                 VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
                                 &pClient->pCmdBuffer);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
         {
@@ -1142 +1211 @@
                                             VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE, NULL,
                                             &pClient->pHGBuffer);
+            AssertRC(rc);
             if (RT_SUCCESS(rc))
             {
@@ -1156 +1226 @@
 DECLCALLBACK(void) _crVBoxHGSMIClientDestroy(HVBOXCRHGSMI_CLIENT hClient)
 {
+    Assert(0);
+
     /* @todo */
 }
@@ -1162 +1234 @@
 bool crVBoxHGSMIInit(CRNetReceiveFuncList *rfl, CRNetCloseFuncList *cfl, unsigned int mtu)
 {
-    /* static */ int bHasHGSMI = -1; /* <- do it for each connection */
+    /* static */ int bHasHGSMI = -1; /* do it for all connections */
     (void) mtu;
 
@@ -1172 +1244 @@
         Callbacks.pfnClientDestroy = _crVBoxHGSMIClientDestroy;
         rc = VBoxCrHgsmiInit(&Callbacks);
+        AssertRC(rc);
         if (RT_SUCCESS(rc))
             bHasHGSMI = 1;
@@ -1178 +1251 @@
     }
 
+    Assert(bHasHGSMI);
+
     if (!bHasHGSMI)
         return false;
@@ -1197 +1272 @@
     /*@todo as we have 2 dll versions, can do it now.*/
 
+#ifdef RT_OS_WINDOWS
+    g_crvboxhgsmi.hGuestDrv = INVALID_HANDLE_VALUE;
+#else
+    g_crvboxhgsmi.iGuestDrv = INVALID_HANDLE_VALUE;
+#endif
 
 #ifdef CHROMIUM_THREADSAFE
@@ -1209 +1289 @@
 void _crVBoxHGSMISysMemFree(void *data)
 {
+    Assert(0);
+
     crFree(data);
 }
@@ -1215 +1297 @@
 {
     int32_t i, cCons;
+
+    Assert(0);
 
     if (!g_crvboxhgsmi.initialized) return;
@@ -1302 +1386 @@
     int32_t i;
 
+    Assert(0);
+
 #ifdef IN_GUEST
     /* we're on guest side, poll host if it got something for us */
@@ -1338 +1424 @@
 CRConnection** crVBoxHGSMIDump( int *num )
 {
+    Assert(0);
     *num = g_crvboxhgsmi.num_conns;
 

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

@@ -461 +461 @@
 {
     int rc;
+
     switch (pCtl->enmType)
     {