Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispCm.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispCm.cpp	(revision 33928)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispCm.cpp	(revision 33929)
@@ -137,4 +137,9 @@
         pContext->pDevice = pDevice;
     }
+    else
+    {
+        exit(1);
+    }
+
     return hr;
 }
@@ -190,4 +195,8 @@
             if (!pCmd->Hdr.cbCmdsReturned && !pCmd->Hdr.cbRemainingFirstCmd)
                 hr = S_FALSE;
+        }
+        else
+        {
+            exit(1);
         }
     }
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.cpp	(revision 33928)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.cpp	(revision 33929)
@@ -572,25 +572,73 @@
 }
 
+HRESULT vboxDispKmtAdpHdcCreate(HDC *phDc)
+{
+    HRESULT hr = E_FAIL;
+    DISPLAY_DEVICE DDev;
+    memset(&DDev, 0, sizeof (DDev));
+    DDev.cb = sizeof (DDev);
+
+    for (int i = 0; ; ++i)
+    {
+        if (EnumDisplayDevices(NULL, /* LPCTSTR lpDevice */ i, /* DWORD iDevNum */
+                &DDev, 0 /* DWORD dwFlags*/))
+        {
+            if (DDev.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
+            {
+                HDC hDc = CreateDC(NULL, DDev.DeviceName, NULL, NULL);
+                if (hDc)
+                {
+                    *phDc = hDc;
+                    return S_OK;
+                }
+                else
+                {
+                    DWORD winEr = GetLastError();
+                    Assert(0);
+                    hr = HRESULT_FROM_WIN32(winEr);
+                    Assert(FAILED(hr));
+                    break;
+                }
+            }
+        }
+        else
+        {
+            DWORD winEr = GetLastError();
+            Assert(0);
+            hr = HRESULT_FROM_WIN32(winEr);
+            Assert(FAILED(hr));
+            break;
+        }
+    }
+
+    return hr;
+}
+
 HRESULT vboxDispKmtOpenAdapter(PVBOXDISPKMT_CALLBACKS pCallbacks, PVBOXDISPKMT_ADAPTER pAdapter)
 {
-    D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME OpenAdapterData = {0};
-    wcsncpy(OpenAdapterData.DeviceName, L"\\\\.\\DISPLAY1", RT_ELEMENTS(OpenAdapterData.DeviceName) - 1 /* the last one is always \0 */);
-    HRESULT hr = S_OK;
-    NTSTATUS Status = pCallbacks->pfnD3DKMTOpenAdapterFromGdiDisplayName(&OpenAdapterData);
-    Assert(!Status);
-    if (!Status)
-    {
-        pAdapter->hAdapter = OpenAdapterData.hAdapter;
-        pAdapter->pCallbacks = pCallbacks;
-        return S_OK;
-    }
-    else
-    {
-        Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName failed, Status (0x%x)\n", Status));
-        hr = E_FAIL;
+    D3DKMT_OPENADAPTERFROMHDC OpenAdapterData = {0};
+    OpenAdapterData.hDc = GetWindowDC(NULL);
+    HRESULT hr = vboxDispKmtAdpHdcCreate(&OpenAdapterData.hDc);
+    if (OpenAdapterData.hDc)
+    {
+        NTSTATUS Status = pCallbacks->pfnD3DKMTOpenAdapterFromHdc(&OpenAdapterData);
+        Assert(!Status);
+        if (!Status)
+        {
+            pAdapter->hAdapter = OpenAdapterData.hAdapter;
+            pAdapter->hDc = OpenAdapterData.hDc;
+            pAdapter->pCallbacks = pCallbacks;
+            return S_OK;
+        }
+        else
+        {
+            Log((__FUNCTION__": pfnD3DKMTOpenAdapterFromGdiDisplayName failed, Status (0x%x)\n", Status));
+            hr = E_FAIL;
+        }
+
+        ReleaseDC(NULL, OpenAdapterData.hDc);
     }
 
     return hr;
-
 }
 
@@ -603,10 +651,10 @@
     if (!Status)
     {
+        ReleaseDC(NULL, pAdapter->hDc);
         return S_OK;
     }
 
     Log((__FUNCTION__": pfnD3DKMTCloseAdapter failed, Status (0x%x)\n", Status));
-    /* ignore */
-    Status = 0;
+
     return E_FAIL;
 }
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.h	(revision 33928)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxUhgsmiKmt.h	(revision 33929)
@@ -52,4 +52,5 @@
 {
     D3DKMT_HANDLE hAdapter;
+    HDC hDc;
     PVBOXDISPKMT_CALLBACKS pCallbacks;
 }VBOXDISPKMT_ADAPTER, *PVBOXDISPKMT_ADAPTER;
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp	(revision 33928)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVidPn.cpp	(revision 33929)
@@ -1717,2 +1717,194 @@
     return Status == STATUS_SUCCESS;
 }
+
+#define VBOXVIDPNDUMP_STRCASE(_t) \
+        case _t: return #_t;
+#define VBOXVIDPNDUMP_STRCASE_UNKNOWN() \
+        default: return "Unknown";
+
+#define VBOXVIDPNDUMP_STRFLAGS(_v, _t) \
+        if ((_v)._t return #_t;
+
+const char* vboxVidPnDumpStrImportance(D3DKMDT_VIDPN_PRESENT_PATH_IMPORTANCE ImportanceOrdinal)
+{
+    switch (ImportanceOrdinal)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_PRIMARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_SECONDARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_TERTIARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_QUATERNARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_QUINARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_SENARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_SEPTENARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_OCTONARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_NONARY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPI_DENARY);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrScaling(D3DKMDT_VIDPN_PRESENT_PATH_SCALING Scaling)
+{
+    switch (Scaling)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_IDENTITY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_CENTERED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_STRETCHED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_UNPINNED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPS_NOTSPECIFIED);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrRotation(D3DKMDT_VIDPN_PRESENT_PATH_ROTATION Rotation)
+{
+    switch (Rotation)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_IDENTITY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_ROTATE90);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_ROTATE180);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_ROTATE270);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_UNPINNED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPR_NOTSPECIFIED);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrColorBasis(D3DKMDT_COLOR_BASIS ColorBasis)
+{
+    switch (ColorBasis)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_INTENSITY);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_SRGB);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_SCRGB);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_YCBCR);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_CB_YPBPR);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrContent(D3DKMDT_VIDPN_PRESENT_PATH_CONTENT Content)
+{
+    switch (Content)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPC_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPC_GRAPHICS);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPC_VIDEO);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPC_NOTSPECIFIED);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrCopyProtectionType(D3DKMDT_VIDPN_PRESENT_PATH_COPYPROTECTION_TYPE CopyProtectionType)
+{
+    switch (CopyProtectionType)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPMT_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPMT_NOPROTECTION);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPMT_MACROVISION_APSTRIGGER);
+        VBOXVIDPNDUMP_STRCASE(D3DKMDT_VPPMT_MACROVISION_FULLSUPPORT);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+const char* vboxVidPnDumpStrGammaRampType(D3DDDI_GAMMARAMP_TYPE Type)
+{
+    switch (Type)
+    {
+        VBOXVIDPNDUMP_STRCASE(D3DDDI_GAMMARAMP_UNINITIALIZED);
+        VBOXVIDPNDUMP_STRCASE(D3DDDI_GAMMARAMP_DEFAULT);
+        VBOXVIDPNDUMP_STRCASE(D3DDDI_GAMMARAMP_RGB256x3x16);
+        VBOXVIDPNDUMP_STRCASE(D3DDDI_GAMMARAMP_DXGI_1);
+        VBOXVIDPNDUMP_STRCASE_UNKNOWN();
+    }
+}
+
+
+void vboxVidPnDumpCopyProtectoin(const D3DKMDT_VIDPN_PRESENT_PATH_COPYPROTECTION *pCopyProtection)
+{
+    drprintf(("CopyProtection: CopyProtectionType(%s),  TODO: Dump All the rest\n",
+            vboxVidPnDumpStrCopyProtectionType(pCopyProtection->CopyProtectionType)));
+}
+
+
+void vboxVidPnDumpPathTransformation(const D3DKMDT_VIDPN_PRESENT_PATH_TRANSFORMATION *pContentTransformation)
+{
+    drprintf(("Transformation: Scaling(%s),  ScalingSupport(%d), Rotation(%s), RotationSupport(%d)\n",
+            vboxVidPnDumpStrScaling(pContentTransformation->Scaling), pContentTransformation->ScalingSupport,
+            vboxVidPnDumpStrRotation(pContentTransformation->Rotation), pContentTransformation->RotationSupport));
+}
+
+void vboxVidPnDumpRegion(const char *pPrefix, const D3DKMDT_2DREGION *pRegion, const char *pSuffix)
+{
+    drprintf(("%scx(%d), cy(%d)%s", pPrefix, pRegion->cx, pRegion->cy, pSuffix));
+}
+
+void vboxVidPnDumpRanges(const char *pPrefix, const D3DKMDT_COLOR_COEFF_DYNAMIC_RANGES *pDynamicRanges, const char *pSuffix)
+{
+    drprintf(("%sFirstChannel(%d), SecondChannel(%d), ThirdChannel(%d), FourthChannel(%d)%s", pPrefix,
+            pDynamicRanges->FirstChannel,
+            pDynamicRanges->SecondChannel,
+            pDynamicRanges->ThirdChannel,
+            pDynamicRanges->FourthChannel,
+            pSuffix));
+}
+
+void vboxVidPnDumpGammaRamp(const char *pPrefix, const D3DKMDT_GAMMA_RAMP *pGammaRamp, const char *pSuffix)
+{
+    drprintf(("%Type(%s), DataSize(%d), TODO: dump the rest%s", pPrefix,
+            vboxVidPnDumpStrGammaRampType(pGammaRamp->Type), pGammaRamp->DataSize,
+            pSuffix));
+}
+
+
+void vboxVidPnDumpPath(struct _DEVICE_EXTENSION* pDevExt, const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
+        const D3DKMDT_VIDPN_PRESENT_PATH *pVidPnPresentPathInfo)
+{
+    drprintf((" >>Start Dump VidPn Path>>\n"));
+    drprintf(("VidPnSourceId(%d),  VidPnTargetId(%d), ImportanceOrdinal(%s), VidPnTargetColorBasis(%s), Content(%s)\n",
+            pVidPnPresentPathInfo->VidPnSourceId, pVidPnPresentPathInfo->VidPnTargetId,
+            vboxVidPnDumpStrImportance(pVidPnPresentPathInfo->ImportanceOrdinal),
+            vboxVidPnDumpStrColorBasis(pVidPnPresentPathInfo->VidPnTargetColorBasis),
+            vboxVidPnDumpStrContent(pVidPnPresentPathInfo->Content)));
+    vboxVidPnDumpPathTransformation(&pVidPnPresentPathInfo->ContentTransformation);
+    vboxVidPnDumpRegion("VisibleFromActiveTLOffset: ", &pVidPnPresentPathInfo->VisibleFromActiveTLOffset, "\n");
+    vboxVidPnDumpRegion("VisibleFromActiveBROffset: ", &pVidPnPresentPathInfo->VisibleFromActiveBROffset, "\n");
+    vboxVidPnDumpRanges("VidPnTargetColorCoeffDynamicRanges: ", &pVidPnPresentPathInfo->VidPnTargetColorCoeffDynamicRanges, "\n");
+    vboxVidPnDumpCopyProtectoin(&pVidPnPresentPathInfo->CopyProtection);
+    vboxVidPnDumpGammaRamp("GammaRamp: ", &pVidPnPresentPathInfo->GammaRamp, "\n");
+
+    drprintf((" <<Stop Dump VidPn Path<<\n"));
+}
+
+static DECLCALLBACK(BOOLEAN) vboxVidPnDumpPathEnum(struct _DEVICE_EXTENSION* pDevExt, const D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface,
+        D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface,
+        const D3DKMDT_VIDPN_PRESENT_PATH *pVidPnPresentPathInfo, PVOID pContext)
+{
+    vboxVidPnDumpPath(pDevExt, hVidPn, pVidPnInterface, pVidPnPresentPathInfo);
+
+    pVidPnTopologyInterface->pfnReleasePathInfo(hVidPnTopology, pVidPnPresentPathInfo);
+    return TRUE;
+}
+
+void vboxVidPnDumpVidPn(PDEVICE_EXTENSION pDevExt, D3DKMDT_HVIDPN hVidPn, const DXGK_VIDPN_INTERFACE* pVidPnInterface)
+{
+    drprintf ((">>>>>>>>>>>>>>>>>Start Dumping VidPn>>>>>>>>>>>>>>>>>>>>>>\n"));
+
+    D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology;
+    const DXGK_VIDPNTOPOLOGY_INTERFACE* pVidPnTopologyInterface;
+    NTSTATUS Status = pVidPnInterface->pfnGetTopology(hVidPn, &hVidPnTopology, &pVidPnTopologyInterface);
+    Assert(Status == STATUS_SUCCESS);
+    if (Status == STATUS_SUCCESS)
+    {
+        Status = vboxVidPnEnumPaths(pDevExt, hVidPn, pVidPnInterface,
+                                        hVidPnTopology, pVidPnTopologyInterface,
+                                        vboxVidPnDumpPathEnum, NULL);
+        Assert(Status == STATUS_SUCCESS);
+    }
+
+    drprintf (("<<<<<<<<<<<<<<<<<Stop Dumping VidPn<<<<<<<<<<<<<<<<<<<<<<\n"));
+}
Index: /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp	(revision 33928)
+++ /trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxDispIf.cpp	(revision 33929)
@@ -115,4 +115,5 @@
     DWORD err = NO_ERROR;
     NTSTATUS Status = pIf->modeData.wddm.pfnD3DKMTOpenAdapterFromGdiDisplayName(&OpenAdapterData);
+    Assert(!Status);
     if (!Status)
     {
Index: /trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c
===================================================================
--- /trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c	(revision 33928)
+++ /trunk/src/VBox/GuestHost/OpenGL/util/vboxhgcm.c	(revision 33929)
@@ -1237,4 +1237,6 @@
     if (RT_FAILURE(rc) || RT_FAILURE(parms.hdr.result))
     {
+        Assert(0);
+
         crWarning("Host doesn't accept our version %d.%d. Make sure you have appropriate additions installed!",
                   parms.vMajor.u.value32, parms.vMinor.u.value32);
@@ -1278,4 +1280,5 @@
         if (g_crvboxhgcm.hGuestDrv == INVALID_HANDLE_VALUE)
         {
+            Assert(0);
             crDebug("could not open VBox Guest Additions driver! rc = %d\n", GetLastError());
             VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
@@ -1292,4 +1295,5 @@
             crDebug("could not open Guest Additions kernel module! rc = %d\n", errno);
             VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
+            Assert(0);
             return FALSE;
         }
@@ -1333,4 +1337,5 @@
         {
             crDebug("HGCM connect failed with rc=0x%x\n", info.result);
+            Assert(0);
 
             VBOXCRHGSMIPROFILE_FUNC_EPILOGUE();
@@ -1341,5 +1346,7 @@
     {
 #ifdef RT_OS_WINDOWS
-        crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", GetLastError());
+        DWORD winEr = GetLastError();
+        Assert(0);
+        crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", winEr);
 #else
         crDebug("IOCTL for HGCM connect failed with rc=0x%x\n", errno);
@@ -1627,5 +1634,5 @@
     if (RT_FAILURE(rc))
     {
-        crWarning("pfnBufferSubmitAsynch failed with %d \n", rc);
+        crError("pfnBufferSubmitAsynch failed with %d \n", rc);
         return;
     }
@@ -1761,5 +1768,5 @@
         if (RT_FAILURE(rc))
         {
-            crWarning("pfnBufferSubmitAsynch failed with %d \n", rc);
+            crError("pfnBufferSubmitAsynch failed with %d \n", rc);
             break;
         }
@@ -1881,4 +1888,9 @@
             callRes = _crVBoxHGSMICmdBufferGetRc(pClient);
         }
+        else
+        {
+            /* we can not recover at this point, report error & exit */
+            crError("pfnBufferSubmitAsynch failed with %d \n", rc);
+        }
     }
     else
@@ -1914,4 +1926,9 @@
 
             callRes = _crVBoxHGSMICmdBufferGetRc(pClient);
+        }
+        else
+        {
+            /* we can not recover at this point, report error & exit */
+            crError("Failed to submit CrHhgsmi buffer");
         }
     }