Changeset 34140 in vbox

Timestamp:

Nov 17, 2010 3:56:34 PM (14 years ago)

Author:

vboxsync

Message:

2d: saved state as part of vga state

Location:

trunk

Files:

• include/VBox/VBoxVideo.h (modified) (2 diffs)
• src/VBox/Devices/Graphics/DevVGASavedState.h (modified) (1 diff)
• src/VBox/Devices/Graphics/DevVGA_VBVA.cpp (modified) (4 diffs)
• src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp (modified) (7 diffs)
• src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h (modified) (2 diffs)
• src/VBox/Main/DisplayImpl.cpp (modified) (2 diffs)

trunk/include/VBox/VBoxVideo.h

@@ -281 +281 @@
     , VBOXVHWACMD_TYPE_HH_DISABLE
     , VBOXVHWACMD_TYPE_HH_ENABLE
+    , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN
+    , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND
+    , VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM
+    , VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM
 } VBOXVHWACMD_TYPE;
 
@@ -775 +779 @@
     uint32_t cbVRAM;
 } VBOXVHWACMD_HH_CONSTRUCT;
+
+typedef struct _VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM
+{
+    struct SSMHANDLE * pSSM;
+} VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM;
+
+typedef struct _VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM
+{
+    struct SSMHANDLE * pSSM;
+} VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM;
 
 typedef DECLCALLBACK(void) FNVBOXVHWA_HH_CALLBACK(void*);

trunk/src/VBox/Devices/Graphics/DevVGASavedState.h

@@ -23 +23 @@
 #define Graphics_DevVGASavedState_h
 
-#define VGA_SAVEDSTATE_VERSION              7
+#define VGA_SAVEDSTATE_VERSION              8
 #define VGA_SAVEDSTATE_VERSION_WDDM         7
 #define VGA_SAVEDSTATE_VERSION_PRE_WDDM     6

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

@@ -726 +726 @@
 #endif /* DEBUG_sunlover */
 
-int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
-    PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
+#define VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC   0x12345678
+#define VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC 0x9abcdef0
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
+{
+    memset(pHdr, 0, VBOXVHWACMD_HEADSIZE());
+    pHdr->cRefs = 1;
+    pHdr->iDisplay = iDisplay;
+    pHdr->rc = VERR_NOT_IMPLEMENTED;
+    pHdr->enmCmd = enmCmd;
+    pHdr->Flags = VBOXVHWACMD_FLAG_HH_CMD;
+}
+
+static VBOXVHWACMD* vbvaVHWAHHCommandCreate (PVGASTATE pVGAState, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
+{
+    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)RTMemAlloc(cbCmd + VBOXVHWACMD_HEADSIZE());
+    Assert(pHdr);
+    if (pHdr)
+        vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
+
+    return pHdr;
+}
+
+DECLINLINE(void) vbvaVHWAHHCommandRelease (VBOXVHWACMD* pCmd)
+{
+    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
+    if(!cRefs)
+    {
+        RTMemFree(pCmd);
+    }
+}
+
+DECLINLINE(void) vbvaVHWAHHCommandRetain (VBOXVHWACMD* pCmd)
+{
+    ASMAtomicIncU32(&pCmd->cRefs);
+}
+
+static unsigned vbvaVHWAHandleCommand (PVGASTATE pVGAState, VBVACONTEXT *pCtx, PVBOXVHWACMD pCmd)
+{
+    if (pVGAState->pDrv->pfnVHWACommandProcess)
+        pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, pCmd);
+#ifdef DEBUG_misha
+    else
+        AssertFailed();
+#endif
+    return 0;
+}
+
+static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
+{
+    RTSemEventSignal((RTSEMEVENT)pContext);
+}
+
+static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD* pCmd)
+{
+    RTSEMEVENT hComplEvent;
+    int rc = RTSemEventCreate(&hComplEvent);
+    AssertRC(rc);
+    if(RT_SUCCESS(rc))
+    {
+        /* ensure the cmd is not deleted until we process it */
+        vbvaVHWAHHCommandRetain (pCmd);
+        VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void*)hComplEvent);
+        vbvaVHWAHandleCommand(pVGAState, NULL, pCmd);
+        if((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
+        {
+            rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT);
+        }
+        else
+        {
+            /* the command is completed */
+        }
+
+        AssertRC(rc);
+        if(RT_SUCCESS(rc))
+        {
+            RTSemEventDestroy(hComplEvent);
+        }
+        vbvaVHWAHHCommandRelease(pCmd);
+    }
+    return rc;
+}
+
+int vbvaVHWAConstruct (PVGASTATE pVGAState)
+{
+    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
+    Assert(pCmd);
+    if(pCmd)
+    {
+        uint32_t iDisplay = 0;
+        int rc = VINF_SUCCESS;
+        VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
+
+        do
+        {
+            memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
+
+            PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
+            PVM pVM = PDMDevHlpGetVM(pDevIns);
+
+            pBody->pVM = pVM;
+            pBody->pvVRAM = pVGAState->vram_ptrR3;
+            pBody->cbVRAM = pVGAState->vram_size;
+
+            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            AssertRC(rc);
+            if(RT_SUCCESS(rc))
+            {
+                rc = pCmd->rc;
+                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
+                if(rc == VERR_NOT_IMPLEMENTED)
+                {
+                    /* @todo: set some flag in pVGAState indicating VHWA is not supported */
+                    /* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
+                    rc = VINF_SUCCESS;
+                }
+
+                if (!RT_SUCCESS(rc))
+                    break;
+            }
+            else
+                break;
+
+            ++iDisplay;
+            if (iDisplay >= pVGAState->cMonitors)
+                break;
+            vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
+        } while (true);
+
+        vbvaVHWAHHCommandRelease(pCmd);
+
+        return rc;
+    }
+    return VERR_OUT_OF_RESOURCES;
+}
+
+int vbvaVHWAReset (PVGASTATE pVGAState)
+{
+    /* ensure we have all pending cmds processed and h->g cmds disabled */
+    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
+    Assert(pCmd);
+    if(pCmd)
+    {
+        int rc = VINF_SUCCESS;
+        uint32_t iDisplay = 0;
+
+        do
+        {
+            rc =vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            AssertRC(rc);
+            if(RT_SUCCESS(rc))
+            {
+                rc = pCmd->rc;
+                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
+                if (rc == VERR_NOT_IMPLEMENTED)
+                    rc = VINF_SUCCESS;
+            }
+
+            if (!RT_SUCCESS(rc))
+                break;
+
+            ++iDisplay;
+            if (iDisplay >= pVGAState->cMonitors)
+                break;
+            vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
+
+        } while (true);
+
+        vbvaVHWAHHCommandRelease(pCmd);
+
+        return rc;
+    }
+    return VERR_OUT_OF_RESOURCES;
+}
+
+typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext);
+typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
+
+typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext);
+typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
+
+int vbvaVHWAHHPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void *pvContext)
+{
+    const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
+    int rc = VINF_SUCCESS;
+    uint32_t iDisplay = 0;
+
+    do
+    {
+        if (!pfnPre || pfnPre(pVGAState, pCmd, iDisplay, pvContext))
+        {
+            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
+            AssertRC(rc);
+            if (pfnPost)
+            {
+                if (!pfnPost(pVGAState, pCmd, iDisplay, rc, pvContext))
+                {
+                    rc = VINF_SUCCESS;
+                    break;
+                }
+                rc = VINF_SUCCESS;
+            }
+            else if(RT_SUCCESS(rc))
+            {
+                rc = pCmd->rc;
+                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
+                if(rc == VERR_NOT_IMPLEMENTED)
+                {
+                    rc = VINF_SUCCESS;
+                }
+            }
+
+            if (!RT_SUCCESS(rc))
+                break;
+        }
+
+        ++iDisplay;
+        if (iDisplay >= pVGAState->cMonitors)
+            break;
+        vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
+    } while (true);
+
+    return rc;
+}
+
+/* @todo call this also on reset? */
+int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
+{
+    const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
+    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState,
+                        enmType,
+                    0, 0);
+    Assert(pCmd);
+    if(pCmd)
+    {
+        int rc = vbvaVHWAHHPost (pVGAState, pCmd, NULL, NULL, NULL);
+        vbvaVHWAHHCommandRelease(pCmd);
+        return rc;
+    }
+    return VERR_OUT_OF_RESOURCES;
+}
+
+int vboxVBVASaveStatePrep (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
+    /* ensure we have no pending commands */
+    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
+}
+
+int vboxVBVASaveStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
+    /* ensure we have no pending commands */
+    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
+}
+
+int vbvaVHWACommandCompleteAsynch(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVHWACMD pCmd)
+{
+    int rc;
+    if((pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD) == 0)
+    {
+        PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
+        PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
+
+        Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
+#ifdef VBOX_WITH_WDDM
+        if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
+        {
+            rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
+            AssertRC(rc);
+        }
+        else
+#endif
+        {
+            VBVAHOSTCMD *pHostCmd;
+            int32_t iDisplay = pCmd->iDisplay;
+
+            if(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
+            {
+                rc = HGSMIHostCommandAlloc (pIns,
+                                              (void**)&pHostCmd,
+                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
+                                              HGSMI_CH_VBVA,
+                                              VBVAHG_EVENT);
+                AssertRC(rc);
+                if(RT_SUCCESS(rc))
+                {
+                    memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
+                    pHostCmd->iDstID = pCmd->iDisplay;
+                    pHostCmd->customOpCode = 0;
+                    VBVAHOSTCMDEVENT *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
+                    pBody->pEvent = pCmd->GuestVBVAReserved1;
+                }
+            }
+            else
+            {
+                HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost (pIns, pCmd);
+                Assert(offCmd != HGSMIOFFSET_VOID);
+                if(offCmd != HGSMIOFFSET_VOID)
+                {
+                    rc = HGSMIHostCommandAlloc (pIns,
+                                              (void**)&pHostCmd,
+                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
+                                              HGSMI_CH_VBVA,
+                                              VBVAHG_DISPLAY_CUSTOM);
+                    AssertRC(rc);
+                    if(RT_SUCCESS(rc))
+                    {
+                        memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
+                        pHostCmd->iDstID = pCmd->iDisplay;
+                        pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
+                        VBVAHOSTCMDVHWACMDCOMPLETE *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
+                        pBody->offCmd = offCmd;
+                    }
+                }
+                else
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                }
+            }
+
+            if(RT_SUCCESS(rc))
+            {
+                rc = HGSMIHostCommandProcessAndFreeAsynch(pIns, pHostCmd, (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ) != 0);
+                AssertRC(rc);
+                if(RT_SUCCESS(rc))
+                {
+                    return rc;
+                }
+                HGSMIHostCommandFree (pIns, pHostCmd);
+            }
+        }
+    }
+    else
+    {
+        PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
+        if(pfn)
+        {
+            pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
+        }
+        rc = VINF_SUCCESS;
+    }
+    return rc;
+}
+
+typedef struct VBOXVBVASAVEDSTATECBDATA
+{
+    PSSMHANDLE pSSM;
+    int rc;
+    bool ab2DOn[VBOX_VIDEO_MAX_SCREENS];
+} VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
+
+static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
+{
+    PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
+    if (RT_FAILURE(pData->rc))
+        return false;
+    if (RT_FAILURE(rc))
+    {
+        pData->rc = rc;
+        return false;
+    }
+
+    Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
+    if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
+    {
+        pData->rc = VERR_INVALID_PARAMETER;
+        return false;
+    }
+
+    Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
+    if (RT_SUCCESS(pCmd->rc))
+    {
+        pData->ab2DOn[iDisplay] = true;
+    }
+    else if (pCmd->rc != VERR_NOT_IMPLEMENTED)
+    {
+        pData->rc = pCmd->rc;
+        return false;
+    }
+
+    return true;
+}
+
+static DECLCALLBACK(bool) vboxVBVASaveStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
+    if (RT_FAILURE(pData->rc))
+        return false;
+
+    Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
+    if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
+    {
+        pData->rc = VERR_INVALID_PARAMETER;
+        return false;
+    }
+
+    int rc;
+
+    if (pData->ab2DOn[iDisplay])
+    {
+        rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
+        if (RT_FAILURE(rc))
+        {
+            pData->rc = rc;
+            return false;
+        }
+        return true;
+    }
+
+    rc = SSMR3PutU32 (pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
+    if (RT_FAILURE(rc))
+    {
+        pData->rc = rc;
+        return false;
+    }
+
+    return false;
+}
+
+static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
+    Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
+    if (pData->ab2DOn[iDisplay])
+    {
+        return true;
+    }
+
+    return false;
+}
+
+static DECLCALLBACK(bool) vboxVBVALoadStatePerformPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
+{
+    PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
+    if (RT_FAILURE(pData->rc))
+        return false;
+    if (RT_FAILURE(rc))
+    {
+        pData->rc = rc;
+        return false;
+    }
+
+    Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
+    if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
+    {
+        pData->rc = VERR_INVALID_PARAMETER;
+        return false;
+    }
+
+    Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
+    if (pCmd->rc == VERR_NOT_IMPLEMENTED)
+    {
+        pData->rc = SSMR3SkipToEndOfUnit(pData->pSSM);
+        AssertRC(pData->rc);
+        return false;
+    }
+    if (RT_FAILURE(pCmd->rc))
+    {
+        pData->rc = pCmd->rc;
+        return false;
+    }
+
+    return true;
+}
+
+static DECLCALLBACK(bool) vboxVBVALoadStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
+{
+    PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
+    if (RT_FAILURE(pData->rc))
+        return false;
+
+    Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
+    if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
+    {
+        pData->rc = VERR_INVALID_PARAMETER;
+        return false;
+    }
+
+    int rc;
+    uint32_t u32;
+    rc = SSMR3GetU32(pData->pSSM, &u32); AssertRC(rc);
+    if (RT_FAILURE(rc))
+    {
+        pData->rc = rc;
+        return false;
+    }
+
+    switch (u32)
+    {
+        case VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC:
+            return true;
+        case VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC:
+            return false;
+        default:
+            pData->rc = VERR_INVALID_STATE;
+            return false;
+    }
+}
+#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
+
+int vboxVBVASaveDevStateExec (PVGASTATE pVGAState, PSSMHANDLE pSSM)
+{
     PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
-
     int rc = HGSMIHostSaveStateExec (pIns, pSSM);
     if (RT_SUCCESS(rc))
@@ -832 +1330 @@
 }
 
+int vboxVBVASaveStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
+{
+    PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
+    int rc;
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
+    VhwaData.pSSM = pSSM;
+    uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); /* maximum cmd size */
+    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
+    Assert(pCmd);
+    if(pCmd)
+    {
+        vbvaVHWAHHPost (pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
+        rc = VhwaData.rc;
+        AssertRC(rc);
+        if (RT_SUCCESS(rc))
+        {
+#endif
+            rc = vboxVBVASaveDevStateExec (pVGAState, pSSM);
+            AssertRC(rc);
+#ifdef VBOX_WITH_VIDEOHWACCEL
+            if (RT_SUCCESS(rc))
+            {
+                vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0);
+                VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
+                pSave->pSSM = pSSM;
+                vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
+                rc = VhwaData.rc;
+                AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                {
+                    vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
+                    vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
+                    rc = VhwaData.rc;
+                    AssertRC(rc);
+                }
+            }
+        }
+
+        vbvaVHWAHHCommandRelease(pCmd);
+        return rc;
+    }
+#else
+    for (UINT i = 0; i < pVGAState->cMonitors; ++i)
+    {
+        rc = SSMR3PutU32 (pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
+        AssertRCReturn(rc, rc);
+    }
+#endif
+    return VERR_OUT_OF_RESOURCES;
+}
+
 int vboxVBVALoadStateExec (PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t u32Version)
 {
@@ -980 +1530 @@
             LogFlowFunc(("%d views loaded\n", pCtx->cViews));
 
+            if (u32Version > VGA_SAVEDSTATE_VERSION_WDDM)
+            {
+#ifdef VBOX_WITH_VIDEOHWACCEL
+                uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); /* maximum cmd size */
+                VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM, 0, cbCmd);
+                Assert(pCmd);
+                if(pCmd)
+                {
+                    VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
+                    VhwaData.pSSM = pSSM;
+                    VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
+                    pLoad->pSSM = pSSM;
+                    vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
+                    rc = VhwaData.rc;
+                    AssertRC(rc);
+                    vbvaVHWAHHCommandRelease(pCmd);
+                }
+                else
+                {
+                    rc = VERR_OUT_OF_RESOURCES;
+                }
+#else
+                rc = SSMR3SkipToEndOfUnit(pSSM);
+                AssertRCReturn(rc, rc);
+#endif
+            }
+
 #ifdef DEBUG_sunlover
             dumpctx(pCtx);
@@ -1016 +1593 @@
     return VINF_SUCCESS;
 }
-
-#ifdef VBOX_WITH_VIDEOHWACCEL
-static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
-{
-    memset(pHdr, 0, VBOXVHWACMD_HEADSIZE());
-    pHdr->cRefs = 1;
-    pHdr->iDisplay = iDisplay;
-    pHdr->rc = VERR_NOT_IMPLEMENTED;
-    pHdr->enmCmd = enmCmd;
-    pHdr->Flags = VBOXVHWACMD_FLAG_HH_CMD;
-}
-
-static VBOXVHWACMD* vbvaVHWAHHCommandCreate (PVGASTATE pVGAState, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
-{
-    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)RTMemAlloc(cbCmd + VBOXVHWACMD_HEADSIZE());
-    Assert(pHdr);
-    if (pHdr)
-        vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
-
-    return pHdr;
-}
-
-DECLINLINE(void) vbvaVHWAHHCommandRelease (VBOXVHWACMD* pCmd)
-{
-    uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
-    if(!cRefs)
-    {
-        RTMemFree(pCmd);
-    }
-}
-
-DECLINLINE(void) vbvaVHWAHHCommandRetain (VBOXVHWACMD* pCmd)
-{
-    ASMAtomicIncU32(&pCmd->cRefs);
-}
-
-static unsigned vbvaVHWAHandleCommand (PVGASTATE pVGAState, VBVACONTEXT *pCtx, PVBOXVHWACMD pCmd)
-{
-    if (pVGAState->pDrv->pfnVHWACommandProcess)
-        pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, pCmd);
-#ifdef DEBUG_misha
-    else
-        AssertFailed();
-#endif
-    return 0;
-}
-
-static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
-{
-    RTSemEventSignal((RTSEMEVENT)pContext);
-}
-
-static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD* pCmd)
-{
-    RTSEMEVENT hComplEvent;
-    int rc = RTSemEventCreate(&hComplEvent);
-    AssertRC(rc);
-    if(RT_SUCCESS(rc))
-    {
-        /* ensure the cmd is not deleted until we process it */
-        vbvaVHWAHHCommandRetain (pCmd);
-        VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void*)hComplEvent);
-        vbvaVHWAHandleCommand(pVGAState, NULL, pCmd);
-        if((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
-        {
-            rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT);
-        }
-        else
-        {
-            /* the command is completed */
-        }
-
-        AssertRC(rc);
-        if(RT_SUCCESS(rc))
-        {
-            RTSemEventDestroy(hComplEvent);
-        }
-        vbvaVHWAHHCommandRelease(pCmd);
-    }
-    return rc;
-}
-
-int vbvaVHWAConstruct (PVGASTATE pVGAState)
-{
-    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
-    Assert(pCmd);
-    if(pCmd)
-    {
-        uint32_t iDisplay = 0;
-        int rc = VINF_SUCCESS;
-        VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
-
-        do
-        {
-            memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
-
-            PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
-            PVM pVM = PDMDevHlpGetVM(pDevIns);
-
-            pBody->pVM = pVM;
-            pBody->pvVRAM = pVGAState->vram_ptrR3;
-            pBody->cbVRAM = pVGAState->vram_size;
-
-            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
-            AssertRC(rc);
-            if(RT_SUCCESS(rc))
-            {
-                rc = pCmd->rc;
-                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
-                if(rc == VERR_NOT_IMPLEMENTED)
-                {
-                    /* @todo: set some flag in pVGAState indicating VHWA is not supported */
-                    /* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
-                    rc = VINF_SUCCESS;
-                }
-
-                if (!RT_SUCCESS(rc))
-                    break;
-            }
-            else
-                break;
-
-            ++iDisplay;
-            if (iDisplay >= pVGAState->cMonitors)
-                break;
-            vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
-        } while (true);
-
-        vbvaVHWAHHCommandRelease(pCmd);
-
-        return rc;
-    }
-    return VERR_OUT_OF_RESOURCES;
-}
-
-int vbvaVHWAReset (PVGASTATE pVGAState)
-{
-    /* ensure we have all pending cmds processed and h->g cmds disabled */
-    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
-    Assert(pCmd);
-    if(pCmd)
-    {
-        int rc = VINF_SUCCESS;
-        uint32_t iDisplay = 0;
-
-        do
-        {
-            rc =vbvaVHWAHHCommandPost(pVGAState, pCmd);
-            AssertRC(rc);
-            if(RT_SUCCESS(rc))
-            {
-                rc = pCmd->rc;
-                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
-                if (rc == VERR_NOT_IMPLEMENTED)
-                    rc = VINF_SUCCESS;
-            }
-
-            if (!RT_SUCCESS(rc))
-                break;
-
-            ++iDisplay;
-            if (iDisplay >= pVGAState->cMonitors)
-                break;
-            vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
-
-        } while (true);
-
-        vbvaVHWAHHCommandRelease(pCmd);
-
-        return rc;
-    }
-    return VERR_OUT_OF_RESOURCES;
-}
-
-/* @todo call this also on reset? */
-int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
-{
-    const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
-    VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState,
-                        enmType,
-                    0, 0);
-    Assert(pCmd);
-    if(pCmd)
-    {
-        int rc = VINF_SUCCESS;
-        uint32_t iDisplay = 0;
-
-        do
-        {
-            rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
-            AssertRC(rc);
-            if(RT_SUCCESS(rc))
-            {
-                rc = pCmd->rc;
-                AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
-                if(rc == VERR_NOT_IMPLEMENTED)
-                {
-                    rc = VINF_SUCCESS;
-                }
-            }
-
-            if (!RT_SUCCESS(rc))
-                break;
-
-            ++iDisplay;
-            if (iDisplay >= pVGAState->cMonitors)
-                break;
-            vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
-
-        } while (true);
-
-        vbvaVHWAHHCommandRelease(pCmd);
-
-        return rc;
-    }
-    return VERR_OUT_OF_RESOURCES;
-}
-
-int vboxVBVASaveStatePrep (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
-    /* ensure we have no pending commands */
-    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
-}
-
-int vboxVBVASaveStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
-{
-    /* ensure we have no pending commands */
-    return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
-}
-
-int vbvaVHWACommandCompleteAsynch(PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVHWACMD pCmd)
-{
-    int rc;
-    if((pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD) == 0)
-    {
-        PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
-        PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
-
-        Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
-#ifdef VBOX_WITH_WDDM
-        if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
-        {
-            rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
-            AssertRC(rc);
-        }
-        else
-#endif
-        {
-            VBVAHOSTCMD *pHostCmd;
-            int32_t iDisplay = pCmd->iDisplay;
-
-            if(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
-            {
-                rc = HGSMIHostCommandAlloc (pIns,
-                                              (void**)&pHostCmd,
-                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
-                                              HGSMI_CH_VBVA,
-                                              VBVAHG_EVENT);
-                AssertRC(rc);
-                if(RT_SUCCESS(rc))
-                {
-                    memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
-                    pHostCmd->iDstID = pCmd->iDisplay;
-                    pHostCmd->customOpCode = 0;
-                    VBVAHOSTCMDEVENT *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
-                    pBody->pEvent = pCmd->GuestVBVAReserved1;
-                }
-            }
-            else
-            {
-                HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost (pIns, pCmd);
-                Assert(offCmd != HGSMIOFFSET_VOID);
-                if(offCmd != HGSMIOFFSET_VOID)
-                {
-                    rc = HGSMIHostCommandAlloc (pIns,
-                                              (void**)&pHostCmd,
-                                              VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
-                                              HGSMI_CH_VBVA,
-                                              VBVAHG_DISPLAY_CUSTOM);
-                    AssertRC(rc);
-                    if(RT_SUCCESS(rc))
-                    {
-                        memset(pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
-                        pHostCmd->iDstID = pCmd->iDisplay;
-                        pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
-                        VBVAHOSTCMDVHWACMDCOMPLETE *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
-                        pBody->offCmd = offCmd;
-                    }
-                }
-                else
-                {
-                    rc = VERR_INVALID_PARAMETER;
-                }
-            }
-
-            if(RT_SUCCESS(rc))
-            {
-                rc = HGSMIHostCommandProcessAndFreeAsynch(pIns, pHostCmd, (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ) != 0);
-                AssertRC(rc);
-                if(RT_SUCCESS(rc))
-                {
-                    return rc;
-                }
-                HGSMIHostCommandFree (pIns, pHostCmd);
-            }
-        }
-    }
-    else
-    {
-        PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
-        if(pfn)
-        {
-            pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
-        }
-        rc = VINF_SUCCESS;
-    }
-    return rc;
-}
-#endif
-
 
 /*

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp

@@ -4272 +4272 @@
             pCmd->rc = VINF_SUCCESS;
             return VINF_SUCCESS;
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
+            mCmdPipe.disable();
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = VINF_SUCCESS;
+            return VINF_SUCCESS;
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
+            mCmdPipe.enable();
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = VINF_SUCCESS;
+            return VINF_SUCCESS;
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
+        {
+            VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
+            PSSMHANDLE pSSM = pSave->pSSM;
+            int rc = SSMR3PutU32(pSSM, VBOXQGL_STATE_VERSION); AssertRC(rc);
+            if (RT_SUCCESS(rc))
+            {
+                vhwaSaveExec(pSSM);
+            }
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = rc;
+            return VINF_SUCCESS;
+        }
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
+        {
+            VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
+            PSSMHANDLE pSSM = pLoad->pSSM;
+            uint32_t u32Version;
+            int rc = SSMR3GetU32(pSSM, &u32Version); Assert(RT_SUCCESS(rc) || rc == VERR_SSM_LOADED_TOO_MUCH);
+            if (RT_SUCCESS(rc))
+            {
+                rc = vhwaLoadExec(pSSM, u32Version); AssertRC(rc);
+            }
+            else if (rc == VERR_SSM_LOADED_TOO_MUCH)
+            {
+                rc = VINF_SUCCESS;
+            }
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = rc;
+            return VINF_SUCCESS;
+        }
         default:
             break;
@@ -4743 +4784 @@
 void VBoxQGLOverlay::vhwaSaveExec(struct SSMHANDLE * pSSM)
 {
-    mCmdPipe.lock();
     mOverlayImage.vhwaSaveExec(pSSM);
     mCmdPipe.saveExec(pSSM, mOverlayImage.vramBase());
-    mCmdPipe.unlock();
 }
 
@@ -4768 +4807 @@
             NULL, NULL, NULL, /* pfnLiveXxx */
             NULL,            /* Prepare save callback, optional. */
-            vboxQGLOverlaySaveExec, /* Execute save callback, optional. */
+            NULL, //vboxQGLOverlaySaveExec, /* Execute save callback, optional. */
             NULL,            /* Done save callback, optional. */
             NULL,            /* Prepare load callback, optional. */
@@ -4858 +4897 @@
     m_pNotifyObject(pNotifyObject),
     mbNewEvent (false),
-    mbProcessingList (false)
+    mbProcessingList (false),
+    mcDisabled (0)
 {
     int rc = RTCritSectInit(&mCritSect);
@@ -5061 +5101 @@
 {
     VBoxVHWACommandElement * pList = NULL;
+    QObject * pNotifyObject = NULL;
     RTCritSectEnter(&mCritSect);
     if (pFirst2Free)
@@ -5071 +5112 @@
 #endif
 
-    pList = m_CmdPipe.detachList(ppLast);
-
-    if (pList)
-    {
-        /* assume the caller atimically calls detachCmdList to free the elements obtained now those and reset the state */
-        mbProcessingList = true;
-        RTCritSectLeave(&mCritSect);
-        return pList;
+    if (!mcDisabled)
+    {
+        pList = m_CmdPipe.detachList(ppLast);
+
+        if (pList)
+        {
+            /* assume the caller atimically calls detachCmdList to free the elements obtained now those and reset the state */
+            mbProcessingList = true;
+            RTCritSectLeave(&mCritSect);
+            return pList;
+        }
+        else
+        {
+            mbProcessingList = false;
+        }
     }
     else
     {
-        mbProcessingList = false;
+        Assert(!mbProcessingList);
+        if (!m_CmdPipe.isEmpty())
+        {
+            Assert(m_pNotifyObject);
+            if (m_pNotifyObject)
+            {
+                m_NotifyObjectRefs.inc(); /* ensure the parent does not get destroyed while we are using it */
+                pNotifyObject = m_pNotifyObject;
+#ifdef DEBUG_misha
+                checkConsistence();
+#endif
+            }
+        }
     }
 
     RTCritSectLeave(&mCritSect);
+
+    if (pNotifyObject)
+    {
+        VBoxVHWACommandProcessEvent *pCurrentEvent = new VBoxVHWACommandProcessEvent();
+        QApplication::postEvent(pNotifyObject, pCurrentEvent);
+        m_NotifyObjectRefs.dec();
+    }
     return NULL;
 }
@@ -5274 +5341 @@
 }
 
+void VBoxVHWACommandElementProcessor::disable()
+{
+    lock();
+    ++mcDisabled;
+    unlock();
+}
+
+void VBoxVHWACommandElementProcessor::enable()
+{
+    lock();
+    --mcDisabled;
+    unlock();
+}
+
 VBoxVHWATextureImage::VBoxVHWATextureImage(const QRect &size, const VBoxVHWAColorFormat &format, class VBoxVHWAGlProgramMngr * aMgr, VBOXVHWAIMG_TYPE flags) :
         mVisibleDisplay(0),

trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.h

@@ -1424 +1424 @@
     int loadExec (struct SSMHANDLE * pSSM, uint32_t u32Version, void *pvVRAM);
     void saveExec (struct SSMHANDLE * pSSM, void *pvVRAM);
+    void disable();
+    void enable();
     void lock();
     void unlock();
@@ -1436 +1438 @@
     bool mbNewEvent;
     bool mbProcessingList;
+    uint32_t mcDisabled;
     VBoxVHWACommandElementStack mFreeElements;
     VBoxVHWACommandElement mElementsBuffer[2048];

trunk/src/VBox/Main/DisplayImpl.cpp

@@ -3459 +3459 @@
         if (pFramebuffer != NULL)
         {
-            pFramebuffer->Lock();
-
             HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
             if (FAILED(hr))
@@ -3466 +3464 @@
                 rc = (hr == E_NOTIMPL) ? VERR_NOT_IMPLEMENTED : VERR_GENERAL_FAILURE;
             }
-
-            pFramebuffer->Unlock();
         }
         else