Changeset 49420 in vbox for trunk/src

Timestamp:

Nov 8, 2013 3:54:02 PM (11 years ago)

Author:

vboxsync

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

90501

Message:

forward-port and adopt VHWA fixes

Location:

trunk/src/VBox

Files:

• Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp (modified) (2 diffs)
• Devices/Graphics/DevVGA.cpp (modified) (1 diff)
• Devices/Graphics/DevVGA.h (modified) (4 diffs)
• Devices/Graphics/DevVGA_VBVA.cpp (modified) (9 diffs)
• Frontends/VirtualBox/src/VBoxFBOverlay.cpp (modified) (50 diffs)
• Frontends/VirtualBox/src/VBoxFBOverlay.h (modified) (14 diffs)
• Frontends/VirtualBox/src/runtime/UIMachineView.cpp (modified) (1 diff)
• Main/include/DisplayImpl.h (modified) (2 diffs)
• Main/src-client/DisplayImpl.cpp (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/xpdm/VBoxDispDDraw.cpp

@@ -67 +67 @@
                 if(pBody->u.out.ErrInfo)
                 {
+                    WARN(("pBody->u.out.ErrInfo = %#x", pBody->u.out.ErrInfo));
                     lpCanCreateSurface->ddRVal = DDERR_GENERIC;
                 }
                 else
                 {
-                    WARN(("pBody->u.out.ErrInfo = %#x", pBody->u.out.ErrInfo));
                     lpCanCreateSurface->ddRVal = DD_OK;
                 }
@@ -275 +275 @@
                 pBody->u.in.hSurf = pDesc->hHostHandle;
 
-                /* we're not interested in completion, just send the command */
-                VBoxDispVHWACommandSubmitAsynchAndComplete(pDev, pCmd);
+                VBoxDispVHWACommandSubmit(pDev, pCmd);
+
+                VBoxDispVHWACommandRelease(pDev, pCmd);
 
                 VBoxDispVHWASurfDescFree(pDesc);

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

@@ -4965 +4965 @@
     if (pThis->cMilliesRefreshInterval)
         TMTimerSetMillies(pTimer, pThis->cMilliesRefreshInterval);
+
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    vbvaTimerCb(pThis);
+#endif
+
 }
 

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

@@ -64 +64 @@
 #endif /* VBOX_WITH_HGSMI */
 #include "DevVGASavedState.h"
+
+# include <iprt/list.h>
 
 #define MSR_COLOR_EMULATION 0x01
@@ -196 +198 @@
 #endif
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+#define VBOX_VHWA_MAX_PENDING_COMMANDS 1000
+
+typedef struct _VBOX_VHWA_PENDINGCMD
+{
+    RTLISTNODE Node;
+    PVBOXVHWACMD pCommand;
+} VBOX_VHWA_PENDINGCMD;
+#endif
+
 typedef struct VGAState {
 #ifndef VBOX
@@ -420 +432 @@
 #  endif
 # endif /* VBOX_WITH_HGSMI */
+
+    struct {
+        uint32_t cPending;
+        uint32_t Padding1;
+        union
+        {
+            RTLISTNODE PendingList;
+            /* make sure the structure sized cross different contexts correctly */
+            struct
+            {
+                R3PTRTYPE(void *) dummy1;
+                R3PTRTYPE(void *) dummy2;
+            } dummy;
+        };
+    } pendingVhwaCommands;
 #endif /* VBOX */
 } VGAState;
@@ -496 +523 @@
 int vbvaVHWAReset (PVGASTATE pVGAState);
 
+void vbvaTimerCb(PVGASTATE pVGAState);
+
 int vboxVBVASaveStatePrep (PPDMDEVINS pDevIns, PSSMHANDLE pSSM);
 int vboxVBVASaveStateDone (PPDMDEVINS pDevIns, PSSMHANDLE pSSM);

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

@@ -767 +767 @@
 static VBOXVHWACMD* vbvaVHWAHHCommandCreate (PVGASTATE pVGAState, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
 {
-    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)RTMemAlloc(cbCmd + VBOXVHWACMD_HEADSIZE());
+    VBOXVHWACMD* pHdr = (VBOXVHWACMD*)RTMemAllocZ(cbCmd + VBOXVHWACMD_HEADSIZE());
     Assert(pHdr);
     if (pHdr)
@@ -789 +789 @@
 }
 
-static unsigned vbvaVHWAHandleCommand (PVGASTATE pVGAState, VBVACONTEXT *pCtx, PVBOXVHWACMD pCmd)
-{
+static void vbvaVHWACommandComplete(PVGASTATE pVGAState, PVBOXVHWACMD pCommand, bool fAsyncCommand)
+{
+    if (fAsyncCommand)
+    {
+        Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
+        vbvaVHWACommandCompleteAsynch(&pVGAState->IVBVACallbacks, pCommand);
+    }
+    else
+    {
+        Log(("VGA Command <<< Sync rc %d %#p, %d\n", pCommand->rc, pCommand, pCommand->enmCmd));
+        pCommand->Flags &= (~VBOXVHWACMD_FLAG_HG_ASYNCH);
+    }
+
+}
+
+static void vbvaVHWACommandCompleteAllPending(PVGASTATE pVGAState, int rc)
+{
+    if (!pVGAState->pendingVhwaCommands.cPending)
+        return;
+
+    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
+    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        pIter->pCommand->rc = rc;
+        vbvaVHWACommandComplete(pVGAState, pIter->pCommand, true);
+
+        /* the command is submitted/processed, remove from the pend list */
+        RTListNodeRemove(&pIter->Node);
+        --pVGAState->pendingVhwaCommands.cPending;
+        RTMemFree(pIter);
+    }
+}
+
+static void vbvaVHWACommandCClearAllPending(PVGASTATE pVGAState)
+{
+    if (!pVGAState->pendingVhwaCommands.cPending)
+        return;
+
+    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
+    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        RTListNodeRemove(&pIter->Node);
+        --pVGAState->pendingVhwaCommands.cPending;
+        RTMemFree(pIter);
+    }
+}
+
+static void vbvaVHWACommandPend(PVGASTATE pVGAState, PVBOXVHWACMD pCommand)
+{
+    int rc = VERR_BUFFER_OVERFLOW;
+
+    if (pVGAState->pendingVhwaCommands.cPending < VBOX_VHWA_MAX_PENDING_COMMANDS)
+    {
+        VBOX_VHWA_PENDINGCMD *pPend = (VBOX_VHWA_PENDINGCMD*)RTMemAlloc(sizeof (*pPend));
+        if (pPend)
+        {
+            pCommand->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pPend->pCommand = pCommand;
+            RTListAppend(&pVGAState->pendingVhwaCommands.PendingList, &pPend->Node);
+            ++pVGAState->pendingVhwaCommands.cPending;
+            return;
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else
+    {
+        LogRel(("Pending command count has reached its threshold, completing them all.."));
+    }
+
+    vbvaVHWACommandCompleteAllPending(pVGAState, rc);
+
+    pCommand->rc = rc;
+
+    vbvaVHWACommandComplete(pVGAState, pCommand, false);
+}
+
+static bool vbvaVHWACommandCanPend(PVBOXVHWACMD pCommand)
+{
+    switch (pCommand->enmCmd)
+    {
+        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
+        case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
+            return false;
+        default:
+            return true;
+    }
+}
+
+static int vbvaVHWACommandSavePending(PVGASTATE pVGAState, PSSMHANDLE pSSM)
+{
+    int rc = SSMR3PutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
+    AssertRCReturn(rc, rc);
+    VBOX_VHWA_PENDINGCMD *pIter;
+    RTListForEach(&pVGAState->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        rc = SSMR3PutU32(pSSM, (uint32_t)(((uint8_t*)pIter->pCommand) - ((uint8_t*)pVGAState->vram_ptrR3)));
+        AssertRCReturn(rc, rc);
+    }
+    return rc;
+}
+
+static int vbvaVHWACommandLoadPending(PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
+{
+    if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
+        return VINF_SUCCESS;
+
+    int rc;
+    uint32_t u32;
+    rc = SSMR3GetU32(pSSM, &u32);
+    AssertRCReturn(rc, rc);
+    for (uint32_t i = 0; i < u32; ++i)
+    {
+        uint32_t off32;
+        rc = SSMR3GetU32(pSSM, &off32);
+        AssertRCReturn(rc, rc);
+        PVBOXVHWACMD pCommand = (PVBOXVHWACMD)(((uint8_t*)pVGAState->vram_ptrR3) + off32);
+        vbvaVHWACommandPend(pVGAState, pCommand);
+    }
+    return rc;
+}
+
+
+static bool vbvaVHWACommandSubmit(PVGASTATE pVGAState, PVBOXVHWACMD pCommand, bool fAsyncCommand)
+{
+    unsigned id = (unsigned)pCommand->iDisplay;
+    int rc = VINF_SUCCESS;
+    bool fPend = false;
+
     if (pVGAState->pDrv->pfnVHWACommandProcess)
-        pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, pCmd);
-#ifdef DEBUG_misha
+    {
+        Log(("VGA Command >>> %#p, %d\n", pCommand, pCommand->enmCmd));
+        int rc = pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, pCommand);
+        if (rc == VINF_CALLBACK_RETURN)
+        {
+            Log(("VGA Command --- Going Async %#p, %d\n", pCommand, pCommand->enmCmd));
+            return true; /* command will be completed asynchronously, return right away */
+        }
+        else if (rc == VERR_INVALID_STATE)
+        {
+            Log(("VGA Command --- Trying Pend %#p, %d\n", pCommand, pCommand->enmCmd));
+            fPend = vbvaVHWACommandCanPend(pCommand);
+            if (!fPend)
+            {
+                Log(("VGA Command --- Can NOT Pend %#p, %d\n", pCommand, pCommand->enmCmd));
+                pCommand->rc = rc;
+            }
+            else
+                Log(("VGA Command --- Can Pend %#p, %d\n", pCommand, pCommand->enmCmd));
+        }
+        else
+        {
+            Log(("VGA Command --- Going Complete Sync rc %d %#p, %d\n", rc, pCommand, pCommand->enmCmd));
+            pCommand->rc = rc;
+        }
+
+        /* the command was completed, take a special care about it (seee below) */
+    }
     else
+    {
         AssertFailed();
-#endif
-    return 0;
+        pCommand->rc = VERR_INVALID_STATE;
+    }
+
+    if (fPend)
+        return false;
+
+    vbvaVHWACommandComplete(pVGAState, pCommand, fAsyncCommand);
+
+    return true;
+}
+
+static bool vbvaVHWACheckPendingCommands(PVGASTATE pVGAState)
+{
+    if (!pVGAState->pendingVhwaCommands.cPending)
+        return true;
+
+    VBOX_VHWA_PENDINGCMD *pIter, *pNext;
+    RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
+    {
+        if (!vbvaVHWACommandSubmit(pVGAState, pIter->pCommand, true))
+            return false; /* the command should be pended still */
+
+        /* the command is submitted/processed, remove from the pend list */
+        RTListNodeRemove(&pIter->Node);
+        --pVGAState->pendingVhwaCommands.cPending;
+        RTMemFree(pIter);
+    }
+
+    return true;
+}
+
+void vbvaTimerCb(PVGASTATE pVGAState)
+{
+    vbvaVHWACheckPendingCommands(pVGAState);
+}
+static void vbvaVHWAHandleCommand(PVGASTATE pVGAState, PVBOXVHWACMD pCmd)
+{
+    if (vbvaVHWACheckPendingCommands(pVGAState))
+    {
+        if (vbvaVHWACommandSubmit(pVGAState, pCmd, false))
+            return;
+    }
+
+    vbvaVHWACommandPend(pVGAState, pCmd);
 }
 
@@ -815 +1014 @@
         vbvaVHWAHHCommandRetain (pCmd);
         VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void*)hComplEvent);
-        vbvaVHWAHandleCommand(pVGAState, NULL, pCmd);
+        vbvaVHWAHandleCommand(pVGAState, pCmd);
         if((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags)  & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
         {
@@ -837 +1036 @@
 int vbvaVHWAConstruct (PVGASTATE pVGAState)
 {
+    pVGAState->pendingVhwaCommands.cPending = 0;
+    RTListInit(&pVGAState->pendingVhwaCommands.PendingList);
     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
     Assert(pCmd);
@@ -890 +1091 @@
 int vbvaVHWAReset (PVGASTATE pVGAState)
 {
+    vbvaVHWACommandCClearAllPending(pVGAState);
+
     /* ensure we have all pending cmds processed and h->g cmds disabled */
     VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(pVGAState, VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
@@ -1009 +1212 @@
 {
     int rc;
+    Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
+
     if((pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD) == 0)
     {
@@ -1394 +1599 @@
                 if (RT_SUCCESS(rc))
                 {
+                    rc = vbvaVHWACommandSavePending(pVGAState, pSSM);
+                    AssertRCReturn(rc, rc);
+
                     vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
                     vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
@@ -1588 +1796 @@
                     vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
                     rc = VhwaData.rc;
-                    AssertRC(rc);
                     vbvaVHWAHHCommandRelease(pCmd);
+                    AssertRCReturn(rc, rc);
+
+                    rc = vbvaVHWACommandLoadPending(pVGAState, pSSM, u32Version);
+                    AssertRCReturn(rc, rc);
                 }
                 else
@@ -1973 +2184 @@
         case VBVA_VHWA_CMD:
         {
-            rc = vbvaVHWAHandleCommand (pVGAState, pCtx, (PVBOXVHWACMD)pvBuffer);
+            if (cbBuffer < sizeof (VBOXVHWACMD))
+            {
+                rc = VERR_INVALID_PARAMETER;
+                break;
+            }
+            vbvaVHWAHandleCommand(pVGAState, (PVBOXVHWACMD)pvBuffer);
+            rc = VINF_SUCCESS;
+            break;
         } break;
 #endif

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

@@ -43 +43 @@
 #include <iprt/asm.h>
 #include <iprt/semaphore.h>
+#include <iprt/memcache.h>
+
 #include <VBox/VBoxGL2D.h>
 #include <VBox/err.h>
@@ -67 +69 @@
 
 #define VBOXQGL_STATE_NAMEBASE "QGLVHWAData"
-#define VBOXQGL_STATE_VERSION           3
-#define VBOXQGL_STATE_VERSION_PIPESAVED 3
+#define VBOXQGL_STATE_VERSION_PIPESAVED    3
+#define VBOXQGL_STATE_VERSION              3
 
 #ifdef DEBUG
@@ -175 +177 @@
 static bool g_bVBoxVHWASupported = false;
 
+class VBoxVHWAEntriesCache
+{
+public:
+    VBoxVHWAEntriesCache()
+    {
+        int rc = RTMemCacheCreate(&mVBoxCmdEntryCache, sizeof (VBoxVHWACommandElement),
+                                    0, /* size_t cbAlignment */
+                                    UINT32_MAX, /* uint32_t cMaxObjects */
+                                    NULL, /* PFNMEMCACHECTOR pfnCtor*/
+                                    NULL, /* PFNMEMCACHEDTOR pfnDtor*/
+                                    NULL, /* void *pvUser*/
+                                    0 /* uint32_t fFlags*/
+                                    );
+        AssertRC(rc);
+    }
+
+    ~VBoxVHWAEntriesCache()
+    {
+        RTMemCacheDestroy(mVBoxCmdEntryCache);
+    }
+
+    VBoxVHWACommandElement * alloc()
+    {
+        return (VBoxVHWACommandElement*)RTMemCacheAlloc(mVBoxCmdEntryCache);
+    }
+
+    void free(VBoxVHWACommandElement * pEl)
+    {
+        RTMemCacheFree(mVBoxCmdEntryCache, pEl);
+    }
+
+private:
+    RTMEMCACHE mVBoxCmdEntryCache;
+};
+
+static VBoxVHWAEntriesCache g_VBoxCmdEntriesCache;
+
 static struct VBOXVHWACMD * vhwaHHCmdCreate(VBOXVHWACMD_TYPE type, size_t size)
 {
@@ -211 +250 @@
 public:
     VBoxVHWACommandProcessEvent ()
-        : QEvent ((QEvent::Type) VHWACommandProcessType)
+        : QEvent ((QEvent::Type) VHWACommandProcessType),
+          fProcessed(false)
     {
 #ifdef DEBUG_misha
@@ -217 +257 @@
 #endif
     }
+
+    void setProcessed()
+    {
+        fProcessed = true;
+    }
+
+    ~VBoxVHWACommandProcessEvent()
+    {
+        if (!fProcessed)
+        {
+            AssertMsgFailed(("VHWA command beinf destroyed unproceessed!"));
+            LogRel(("VHWA command being destroyed unproceessed!"));
+        }
 #ifdef DEBUG_misha
-    ~VBoxVHWACommandProcessEvent()
-    {
         g_EventCounter.dec();
-    }
-
+#endif
+    }
+#ifdef DEBUG_misha
     static uint32_t cPending() { return g_EventCounter.refs(); }
+#endif
+
 private:
+    bool fProcessed;
+#ifdef DEBUG_misha
     static VBoxVHWARefCounter g_EventCounter;
 #endif
@@ -4176 +4232 @@
 int VBoxQGLOverlay::reset()
 {
-    VBoxVHWACommandElement * pHead, * pTail;
-    mCmdPipe.reset(&pHead, &pTail);
-    if(pHead)
-    {
-        CDisplay display = mpSession->GetConsole().GetDisplay();
-        Assert (!display.isNull());
-
-        /* complete aborted commands */
-        for(VBoxVHWACommandElement * pCur = pHead; pCur; pCur = pCur->mpNext)
-        {
-            switch(pCur->type())
-            {
-#ifdef VBOX_WITH_VIDEOHWACCEL
-            case VBOXVHWA_PIPECMD_VHWA:
-                {
-                    struct VBOXVHWACMD * pCmd = pCur->vhwaCmd();
-                    pCmd->rc = VERR_INVALID_STATE;
-                    display.CompleteVHWACommand((BYTE*)pCmd);
-                }
-                break;
-            case VBOXVHWA_PIPECMD_FUNC:
-                /* should not happen, don't handle this for now */
-                Assert(0);
-                break;
-#endif
-            case VBOXVHWA_PIPECMD_PAINT:
-                break;
-            default:
-                /* should not happen, don't handle this for now */
-                Assert(0);
-                break;
-            }
-        }
-
-        VBoxVHWACommandElement *pTest = mCmdPipe.detachCmdList(NULL, pHead, pTail);
-        Assert(!pTest);
-        NOREF(pTest);
-    }
+    CDisplay display = mpSession->GetConsole().GetDisplay();
+    Assert (!display.isNull());
+
+    mCmdPipe.reset(&display);
 
     resetGl();
@@ -4237 +4259 @@
             VBOXVHWACMD *pCmd = (*sIt);
             VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandFreeCmd, pCmd);
-            mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, 0);
+            mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd);
         }
     }
@@ -4245 +4267 @@
 int VBoxQGLOverlay::onVHWACommand(struct VBOXVHWACMD * pCmd)
 {
-    uint32_t flags = 0;
+    Log(("VHWA Command >>> %#p, %d\n", pCmd, pCmd->enmCmd));
     switch(pCmd->enmCmd)
     {
@@ -4251 +4273 @@
         case VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE:
         case VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION:
-            flags |= VBOXVHWACMDPIPEC_COMPLETEEVENT;
             break;
+        case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
+        {
+            VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = vhwaConstruct(pBody);
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
+            return VINF_SUCCESS;
+        }
         case VBOXVHWACMD_TYPE_HH_RESET:
         {
@@ -4259 +4288 @@
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = reset();
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         }
@@ -4264 +4294 @@
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = VINF_SUCCESS;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         case VBOXVHWACMD_TYPE_HH_DISABLE:
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = VINF_SUCCESS;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
@@ -4273 +4305 @@
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = VINF_SUCCESS;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
@@ -4278 +4311 @@
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = VINF_SUCCESS;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
@@ -4290 +4324 @@
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = rc;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
         }
@@ -4296 +4331 @@
             VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
             PSSMHANDLE pSSM = pLoad->pSSM;
-            uint32_t u32Version;
+            uint32_t u32Version = 0;
             int rc = SSMR3GetU32(pSSM, &u32Version); Assert(RT_SUCCESS(rc) || rc == VERR_SSM_LOADED_TOO_MUCH);
             if (RT_SUCCESS(rc))
@@ -4302 +4337 @@
                 rc = vhwaLoadExec(pSSM, u32Version); AssertRC(rc);
             }
-            else if (rc == VERR_SSM_LOADED_TOO_MUCH)
+            else
             {
-                rc = VINF_SUCCESS;
+                /* sanity */
+                u32Version = 0;
+
+                if (rc == VERR_SSM_LOADED_TOO_MUCH)
+                    rc = VINF_SUCCESS;
             }
             pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
             pCmd->rc = rc;
+            Log(("VHWA Command <<< Sync %#p, %d\n", pCmd, pCmd->enmCmd));
             return VINF_SUCCESS;
+        }
+        case VBOXVHWACMD_TYPE_QUERY_INFO1:
+        {
+            VBOXVHWACMD_QUERYINFO1 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
+            Assert(pBody->u.in.guestVersion.maj == VBOXVHWA_VERSION_MAJ);
+            Assert(pBody->u.in.guestVersion.min == VBOXVHWA_VERSION_MIN);
+            Assert(pBody->u.in.guestVersion.bld == VBOXVHWA_VERSION_BLD);
+            Assert(pBody->u.in.guestVersion.reserved == VBOXVHWA_VERSION_RSV);
+            /* do NOT break!! make it proceed asynchronously */
         }
         default:
             break;
     }
+
+    Log(("VHWA Command --- Going Async %#p, %d\n", pCmd, pCmd->enmCmd));
     /* indicate that we process and complete the command asynchronously */
     pCmd->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
 
-    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd, flags);
-    return VINF_SUCCESS;
+    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_VHWA, pCmd);
+    return VINF_CALLBACK_RETURN;
 
 }
@@ -4323 +4374 @@
 void VBoxQGLOverlay::onVHWACommandEvent(QEvent * pEvent)
 {
-    Q_UNUSED(pEvent);
+    VBoxVHWACommandProcessEvent *pVhwaEvent = (VBoxVHWACommandProcessEvent*)pEvent;
+    /* sanity actually */
+    pVhwaEvent->setProcessed();
+
     Assert(!mProcessingCommands);
     mProcessingCommands = true;
     Assert(!mGlCurrent);
     mGlCurrent = false; /* just a fall-back */
-    bool bFirstCmd = true;
-    VBoxVHWACommandElement *pLast;
-    VBoxVHWACommandElement * pFirst = mCmdPipe.detachCmdList(&pLast, NULL, NULL);
-    while(pFirst) /* pFirst can be zero right after reset when all pending commands are flushed,
-                   * while events for those commands may still come along */
-    {
-        VBoxVHWACommandElement * pLastProcessed = processCmdList(pFirst, bFirstCmd);
-
-        if (pLastProcessed == pLast)
-        {
-            pFirst = mCmdPipe.detachCmdList(&pLast, pFirst, pLastProcessed);
-            bFirstCmd = false;
-        }
-        else
-        {
-            mCmdPipe.putBack(pLastProcessed->mpNext, pLast, pFirst, pLastProcessed);
-            break;
-        }
+    VBoxVHWACommandElement *pCmd = mCmdPipe.getCmd();
+    if (pCmd)
+    {
+        processCmd(pCmd);
+        mCmdPipe.doneCmd();
     }
 
     mProcessingCommands = false;
     repaint();
-//    vboxOpExit();
     mGlCurrent = false;
 }
@@ -4357 +4397 @@
                          ULONG aW, ULONG aH)
 {
-#if 1
+    /* we do not to miss notify updates, because we have to update bg textures for it,
+     * so no not check for m_fIsMarkedAsUnused here,
+     * mOverlay will store the required info for us */
     QRect r(aX, aY, aW, aH);
-    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_PAINT, &r, 0);
+    mCmdPipe.postCmd(VBOXVHWA_PIPECMD_PAINT, &r);
     return true;
-#else
-    /* We're not on the GUI thread and update() isn't thread safe in
-     * Qt 4.3.x on the Win, Qt 3.3.x on the Mac (4.2.x is),
-     * on Linux (didn't check Qt 4.x there) and probably on other
-     * non-DOS platforms, so post the event instead. */
-    QApplication::postEvent (mView,
-                             new VBoxRepaintEvent (aX, aY, aW, aH));
-
-    return S_OK;
-#endif
 }
 
@@ -4378 +4410 @@
     mContentsTopLeft = topLeft;
 
-    if(mGlOn)
-    {
+    if (mGlOn)
+    {
+        Assert(mOverlayImage.hasSurfaces());
         Assert(!mGlCurrent);
         Assert(!mNeedOverlayRepaint);
@@ -4386 +4419 @@
         /* need to ensure we're in sync */
         mNeedOverlayRepaint = vboxSynchGl();
-    }
-
-    if(!mOnResizeCmdList.empty())
+
+        if (!mOverlayImage.hasSurfaces())
+        {
+            Assert(0);
+            vboxSetGlOn(false);
+        }
+    }
+    else
+        Assert(!mOverlayImage.hasSurfaces());
+
+    if (!mOnResizeCmdList.empty())
     {
         for (VHWACommandList::const_iterator it = mOnResizeCmdList.begin();
@@ -4429 +4470 @@
     CDisplay display = mpSession->GetConsole().GetDisplay();
     Assert (!display.isNull());
+
+    Log(("VHWA Command <<< Async %#p, %d\n", cmd, ((VBOXVHWACMD *)cmd)->enmCmd));
 
     display.CompleteVHWACommand((BYTE*)cmd);
@@ -4590 +4633 @@
         {
             VBOXVHWACMD_SURF_CANCREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CANCREATE);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaSurfaceCanCreate(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_CREATE:
         {
             VBOXVHWACMD_SURF_CREATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_CREATE);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
@@ -4615 +4661 @@
                 mNeedOverlayRepaint = true;
             }
+
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_DESTROY:
         {
             VBOXVHWACMD_SURF_DESTROY * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_DESTROY);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
@@ -4636 +4685 @@
                 mNeedOverlayRepaint = true;
             }
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_LOCK:
         {
             VBOXVHWACMD_SURF_LOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_LOCK);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaSurfaceLock(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_UNLOCK:
         {
             VBOXVHWACMD_SURF_UNLOCK * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_UNLOCK);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = vhwaSurfaceUnlock(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             /* mNeedOverlayRepaint is set inside the vhwaSurfaceUnlock */
         } break;
@@ -4655 +4709 @@
         {
             VBOXVHWACMD_SURF_BLT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_BLT);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaSurfaceBlt(pBody);
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_FLIP:
         {
             VBOXVHWACMD_SURF_FLIP * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_FLIP);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaSurfaceFlip(pBody);
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_OVERLAY_UPDATE:
         {
             VBOXVHWACMD_SURF_OVERLAY_UPDATE * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_UPDATE);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
@@ -4681 +4740 @@
             vboxDoCheckUpdateViewport();
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_SURF_OVERLAY_SETPOSITION:
         {
             VBOXVHWACMD_SURF_OVERLAY_SETPOSITION * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_OVERLAY_SETPOSITION);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
@@ -4695 +4756 @@
             vboxDoCheckUpdateViewport();
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
 #ifdef VBOX_WITH_WDDM
@@ -4700 +4762 @@
         {
             VBOXVHWACMD_SURF_COLORFILL * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORFILL);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaSurfaceColorFill(pBody);
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
 #endif
@@ -4709 +4773 @@
         {
             VBOXVHWACMD_SURF_COLORKEY_SET * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_COLORKEY_SET);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
@@ -4715 +4780 @@
             vboxDoCheckUpdateViewport();
             mNeedOverlayRepaint = true;
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_QUERY_INFO1:
         {
             VBOXVHWACMD_QUERYINFO1 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO1);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaQueryInfo1(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_QUERY_INFO2:
         {
             VBOXVHWACMD_QUERYINFO2 * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_QUERYINFO2);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
             makeCurrent();
             pCmd->rc = mOverlayImage.vhwaQueryInfo2(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
         case VBOXVHWACMD_TYPE_ENABLE:
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             initGl();
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         case VBOXVHWACMD_TYPE_DISABLE:
             pCmd->rc = VINF_SUCCESS;
@@ -4738 +4810 @@
         {
             VBOXVHWACMD_HH_CONSTRUCT * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             pCmd->rc = vhwaConstruct(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
 #ifdef VBOX_WITH_WDDM
@@ -4744 +4818 @@
         {
             VBOXVHWACMD_SURF_GETINFO * pBody = VBOXVHWACMD_BODY(pCmd, VBOXVHWACMD_SURF_GETINFO);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
             pCmd->rc = mOverlayImage.vhwaSurfaceGetInfo(pBody);
+            Assert(!mGlOn == !mOverlayImage.hasSurfaces());
         } break;
 #endif
@@ -4850 +4926 @@
 }
 
-VBoxVHWACommandElement * VBoxQGLOverlay::processCmdList(VBoxVHWACommandElement * pCmd, bool bFirst)
-{
-    VBoxVHWACommandElement * pCur;
-    do
-    {
-        pCur = pCmd;
-        switch(pCmd->type())
-        {
+void VBoxQGLOverlay::processCmd(VBoxVHWACommandElement * pCmd)
+{
+    switch(pCmd->type())
+    {
         case VBOXVHWA_PIPECMD_PAINT:
             addMainDirtyRect(pCmd->rect());
@@ -4874 +4946 @@
         default:
             Assert(0);
-        }
-
-        pCmd = pCmd->mpNext;
-        if (!pCmd)
-            break;
-
-        if (!bFirst)
-        {
-            if (pCmd->isNewEvent())
-                break;
-        }
-        else
-        {
-            Assert(pCur->isNewEvent());
-            bFirst = false;
-        }
-    } while(1);
-
-    return pCur;
-}
-
+    }
+}
 
 VBoxVHWACommandElementProcessor::VBoxVHWACommandElementProcessor(QObject *pNotifyObject) :
     m_pNotifyObject(pNotifyObject),
-    mbNewEvent (false),
-    mbProcessingList (false),
-    mcDisabled (0)
+    mpCurCmd(NULL),
+    mbResetting(false),
+    mcDisabled(0)
 {
     int rc = RTCritSectInit(&mCritSect);
     AssertRC(rc);
 
-    for(int i = RT_ELEMENTS(mElementsBuffer) - 1; i >= 0; i--)
-    {
-        mFreeElements.push(&mElementsBuffer[i]);
-    }
+    RTListInit(&mCommandList);
 }
 
@@ -4914 +4964 @@
 {
     Assert(!m_NotifyObjectRefs.refs());
-    Assert(m_CmdPipe.isEmpty());
+    RTListIsEmpty(&mCommandList);
+
     RTCritSectDelete(&mCritSect);
 }
 
-bool VBoxVHWACommandElementProcessor::completeCurrentEvent()
-{
-    bool bActive = true;
-    RTCritSectEnter(&mCritSect);
-    mbNewEvent = true;
-    if (!m_pNotifyObject)
-        bActive = false;
-    RTCritSectLeave(&mCritSect);
-    return bActive;
-}
-
-void VBoxVHWACommandElementProcessor::postCmd(VBOXVHWA_PIPECMD_TYPE aType, void * pvData, uint32_t flags)
+void VBoxVHWACommandElementProcessor::postCmd(VBOXVHWA_PIPECMD_TYPE aType, void * pvData)
 {
     QObject *pNotifyObject = NULL;
+
+    Log(("VHWA post %d %#p\n", aType, pvData));
+
     /* 1. lock*/
     RTCritSectEnter(&mCritSect);
-    VBoxVHWACommandElement * pCmd = mFreeElements.pop();
+
+    VBoxVHWACommandElement * pCmd = g_VBoxCmdEntriesCache.alloc();
     if(!pCmd)
     {
@@ -4947 +4991 @@
     pCmd->setData(aType, pvData);
 
-    if((flags & VBOXVHWACMDPIPEC_NEWEVENT) != 0)
-        mbNewEvent = true;
-
     /* 2. if can add to current*/
-    if(mbNewEvent || (!mbProcessingList && m_CmdPipe.isEmpty()))
-    {
-        pCmd->setNewEvent(true);
-        mbNewEvent = false;
-        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
-        }
-    }
-    else
-    {
-        pCmd->setNewEvent(false);
-#ifdef DEBUG_misha
-        if (m_pNotifyObject)
-            checkConsistence();
-#endif
-    }
-
-    m_CmdPipe.put(pCmd);
-#ifdef DEBUG_misha
     if (m_pNotifyObject)
     {
-        checkConsistence(1);
-    }
-#endif
-
-    if((flags & VBOXVHWACMDPIPEC_COMPLETEEVENT) != 0)
-        mbNewEvent = true;
+        m_NotifyObjectRefs.inc(); /* ensure the parent does not get destroyed while we are using it */
+        pNotifyObject = m_pNotifyObject;
+    }
+
+    RTListAppend(&mCommandList, &pCmd->ListNode);
 
     RTCritSectLeave(&mCritSect);
@@ -4994 +5010 @@
 }
 
-#ifdef DEBUG_misha
-void VBoxVHWACommandElementProcessor::checkConsistence(uint32_t cEvents2Submit, const VBoxVHWACommandElementPipe *pPipe)
-{
-    const VBoxVHWACommandElement *pLast;
-    const VBoxVHWACommandElement *pFirst = pPipe ? pPipe->contentsRo(&pLast) : m_CmdPipe.contentsRo(&pLast);
-    uint32_t cEvents = 0;
-
-    for (const VBoxVHWACommandElement * pCur = pFirst; pCur; pCur = pCur->mpNext)
-    {
-        if (pCur->isNewEvent())
-        {
-            ++cEvents;
-            Assert(cEvents <= VBoxVHWACommandProcessEvent::cPending() + cEvents2Submit);
-        }
-    }
-//    Assert(cEvents == VBoxVHWACommandProcessEvent::cPending());
-}
-#endif
-
-void VBoxVHWACommandElementProcessor::putBack(class VBoxVHWACommandElement * pFirst2Put, VBoxVHWACommandElement * pLast2Put,
-        class VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free)
-{
-    RTCritSectEnter(&mCritSect);
-    if (pFirst2Free)
-        mFreeElements.pusha(pFirst2Free, pLast2Free);
-    m_CmdPipe.prepend(pFirst2Put, pLast2Put);
-    mbProcessingList = false;
-    Assert(pFirst2Put->isNewEvent());
-#ifdef DEBUG_misha
-    Assert(VBoxVHWACommandProcessEvent::cPending());
-    const VBoxVHWACommandElement *pLast;
-    const VBoxVHWACommandElement *pFirst = m_CmdPipe.contentsRo(&pLast);
-    Assert(pFirst);
-    Assert(pLast);
-    Assert(pFirst == pFirst2Put);
-    checkConsistence();
-#endif
-    RTCritSectLeave(&mCritSect);
-}
-
 void VBoxVHWACommandElementProcessor::setNotifyObject(QObject *pNotifyObject)
 {
     int cEventsNeeded = 0;
-    const VBoxVHWACommandElement * pFirst;
     RTCritSectEnter(&mCritSect);
     if (m_pNotifyObject == pNotifyObject)
@@ -5064 +5039 @@
         m_pNotifyObject = pNotifyObject;
 
-        pFirst = m_CmdPipe.contentsRo(NULL);
-        for (; pFirst; pFirst = pFirst->mpNext)
-        {
-            if (pFirst->isNewEvent())
-                ++cEventsNeeded;
+        VBoxVHWACommandElement *pCur;
+        RTListForEach(&mCommandList, pCur, VBoxVHWACommandElement, ListNode)
+        {
+            ++cEventsNeeded;
         }
 
@@ -5079 +5053 @@
         Assert(!m_pNotifyObject);
     }
-
-#ifdef DEBUG_misha
-    checkConsistence(cEventsNeeded);
-#endif
 
     RTCritSectLeave(&mCritSect);
@@ -5099 +5069 @@
 }
 
-VBoxVHWACommandElement * VBoxVHWACommandElementProcessor::detachCmdList(VBoxVHWACommandElement **ppLast,
-        VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free)
-{
-    VBoxVHWACommandElement * pList = NULL;
-    QObject * pNotifyObject = NULL;
+void VBoxVHWACommandElementProcessor::doneCmd()
+{
+    VBoxVHWACommandElement * pEl;
     RTCritSectEnter(&mCritSect);
-    if (pFirst2Free)
-    {
-        mFreeElements.pusha(pFirst2Free, pLast2Free);
-    }
-
-#ifdef DEBUG_misha
-    checkConsistence();
-#endif
-
-    if (!mcDisabled)
-    {
-        pList = m_CmdPipe.detachList(ppLast);
-
-        if (pList)
-        {
-            /* assume the caller atomically calls detachCmdList to free the elements obtained now those and reset the state */
-            mbProcessingList = true;
-            RTCritSectLeave(&mCritSect);
-            return pList;
-        }
-        else
-        {
-            mbProcessingList = false;
-        }
-    }
-    else
-    {
-        Assert(!mbProcessingList);
-        if (!m_CmdPipe.isEmpty())
+    pEl = mpCurCmd;
+    Assert(mpCurCmd);
+    mpCurCmd = NULL;
+    RTCritSectLeave(&mCritSect);
+
+    if (pEl)
+        g_VBoxCmdEntriesCache.free(pEl);
+}
+
+VBoxVHWACommandElement * VBoxVHWACommandElementProcessor::getCmd()
+{
+    VBoxVHWACommandElement * pEl = NULL;
+    RTCritSectEnter(&mCritSect);
+
+    Assert(!mpCurCmd);
+
+    if (mbResetting)
+    {
+        RTCritSectEnter(&mCritSect);
+        return NULL;
+    }
+
+    if (mcDisabled)
+    {
+        QObject * pNotifyObject = NULL;
+
+        if (!RTListIsEmpty(&mCommandList))
         {
             Assert(m_pNotifyObject);
@@ -5140 +5106 @@
                 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;
+    }
+
+    pEl = RTListGetFirst(&mCommandList, VBoxVHWACommandElement, ListNode);
+    if (pEl)
+    {
+        RTListNodeRemove(&pEl->ListNode);
+        mpCurCmd = pEl;
     }
 
     RTCritSectLeave(&mCritSect);
 
-    if (pNotifyObject)
-    {
-        VBoxVHWACommandProcessEvent *pCurrentEvent = new VBoxVHWACommandProcessEvent();
-        QApplication::postEvent(pNotifyObject, pCurrentEvent);
-        m_NotifyObjectRefs.dec();
-    }
-    return NULL;
+    return pEl;
 }
 
 /* it is currently assumed no one sends any new commands while reset is in progress */
-void VBoxVHWACommandElementProcessor::reset(VBoxVHWACommandElement ** ppHead, VBoxVHWACommandElement ** ppTail)
-{
-    VBoxVHWACommandElementPipe pipe;
+void VBoxVHWACommandElementProcessor::reset(CDisplay *pDisplay)
+{
+    VBoxVHWACommandElement *pCur, *pNext;
+
     RTCritSectEnter(&mCritSect);
 
-    pipe.setFrom(&m_CmdPipe);
-
-    if(mbProcessingList)
+    mbResetting = true;
+
+    if(mpCurCmd)
     {
         for(;;)
@@ -5174 +5149 @@
             RTCritSectEnter(&mCritSect);
             /* it is assumed no one sends any new commands while reset is in progress */
-            if(!mbProcessingList)
+            if(!mpCurCmd)
             {
                 break;
@@ -5181 +5156 @@
     }
 
-    Assert(!mbProcessingList);
-
-    pipe.prependFrom(&m_CmdPipe);
-
-    if(!pipe.isEmpty())
-        mbProcessingList = true;
-
     RTCritSectLeave(&mCritSect);
 
-    *ppHead = pipe.detachList(ppTail);
+    RTListForEachSafe(&mCommandList, pCur, pNext, VBoxVHWACommandElement, ListNode)
+    {
+        switch(pCur->type())
+        {
+#ifdef VBOX_WITH_VIDEOHWACCEL
+        case VBOXVHWA_PIPECMD_VHWA:
+            {
+                struct VBOXVHWACMD * pCmd = pCur->vhwaCmd();
+                pCmd->rc = VERR_INVALID_STATE;
+                Log(("VHWA Command <<< Async RESET %#p, %d\n", pCmd, pCmd->enmCmd));
+                pDisplay->CompleteVHWACommand((BYTE*)pCmd);
+            }
+            break;
+        case VBOXVHWA_PIPECMD_FUNC:
+            /* should not happen, don't handle this for now */
+            Assert(0);
+            break;
+#endif
+        case VBOXVHWA_PIPECMD_PAINT:
+            break;
+        default:
+            /* should not happen, don't handle this for now */
+            Assert(0);
+            break;
+        }
+
+        RTListNodeRemove(&pCur->ListNode);
+        g_VBoxCmdEntriesCache.free(pCur);
+    }
 }
 
@@ -5235 +5231 @@
                             {
                                 QRect r = QRect(x, y, w, h);
-                                postCmd(VBOXVHWA_PIPECMD_PAINT, &r, 0);
+                                postCmd(VBOXVHWA_PIPECMD_PAINT, &r);
                             }
                             break;
@@ -5248 +5244 @@
                             if (RT_SUCCESS(rc))
                             {
-                                postCmd(VBOXVHWA_PIPECMD_VHWA, (VBOXVHWACMD*)(((uint8_t*)pvVRAM) + offCmd), 0);
+                                postCmd(VBOXVHWA_PIPECMD_VHWA, (VBOXVHWACMD*)(((uint8_t*)pvVRAM) + offCmd));
                             }
                             break;
@@ -5281 +5277 @@
     rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC);         AssertRC(rc);
     rc = SSMR3PutU32(pSSM, m_NotifyObjectRefs.refs());         AssertRC(rc);
-    rc = SSMR3PutBool(pSSM, mbNewEvent);         AssertRC(rc);
-
-    const VBoxVHWACommandElement * pCur = m_CmdPipe.contentsRo(NULL);
-    for (;pCur; pCur = pCur->mpNext)
+    rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
+
+    VBoxVHWACommandElement *pCur;
+    RTListForEach(&mCommandList, pCur, VBoxVHWACommandElement, ListNode)
     {
         rc = SSMR3PutU32(pSSM, pCur->type());         AssertRC(rc);
@@ -5295 +5291 @@
                 rc = SSMR3PutS32(pSSM, pCur->rect().width());         AssertRC(rc);
                 rc = SSMR3PutS32(pSSM, pCur->rect().height());         AssertRC(rc);
-                rc = SSMR3PutBool(pSSM, pCur->isNewEvent());         AssertRC(rc);
+                rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
                 break;
             case VBOXVHWA_PIPECMD_VHWA:
             {
                 rc = SSMR3PutU32(pSSM, (uint32_t)((uintptr_t)((uint8_t*)pCur->vhwaCmd() - (uint8_t*)pvVRAM)));         AssertRC(rc);
-                rc = SSMR3PutBool(pSSM, pCur->isNewEvent());         AssertRC(rc);
+                rc = SSMR3PutBool(pSSM, true);         AssertRC(rc);
                 break;
             }
@@ -5316 +5312 @@
     RTCritSectEnter(&mCritSect);
 
-    if(mbProcessingList)
+    if(mpCurCmd)
     {
         for(;;)
@@ -5324 +5320 @@
             RTCritSectEnter(&mCritSect);
             /* it is assumed no one sends any new commands while reset is in progress */
-            if(!mbProcessingList)
+            if(!mpCurCmd)
             {
                 break;
@@ -5331 +5327 @@
     }
 
-    Assert(!mbProcessingList);
+    Assert(!mpCurCmd);
 }
 

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

@@ -36 +36 @@
 #include "COMEnums.h"
 
+#include "CDisplay.h"
+
 /* Other VBox includes: */
 #include <iprt/assert.h>
@@ -41 +43 @@
 #include <iprt/asm.h>
 #include <iprt/err.h>
+#include <iprt/list.h>
 #include <VBox/VBoxGL2D.h>
 #ifdef VBOXVHWA_PROFILE_FPS
 # include <iprt/stream.h>
 #endif /* VBOXVHWA_PROFILE_FPS */
+
+#ifndef S_FALSE
+# define S_FALSE ((HRESULT)1L)
+#endif
 
 #ifdef DEBUG_misha
@@ -1189 +1196 @@
 {
 public:
-    VBoxVHWACommandElement() :
-        bNewEvent(false)
-    {}
-
     void setVHWACmd(struct VBOXVHWACMD * pCmd)
     {
@@ -1230 +1233 @@
     }
 
-    void setNewEvent(bool bNew) {bNewEvent = bNew;}
-    bool isNewEvent() const { return bNewEvent; }
-
     VBOXVHWA_PIPECMD_TYPE type() const {return mType;}
     const QRect & rect() const {return mRect;}
@@ -1238 +1238 @@
     const VBOXVHWAFUNCCALLBACKINFO & func() const {return u.mFuncCallback; }
 
-    VBoxVHWACommandElement * mpNext;
+    RTLISTNODE ListNode;
 private:
     VBOXVHWA_PIPECMD_TYPE mType;
@@ -1247 +1247 @@
     }u;
     QRect                 mRect;
-    bool bNewEvent;
-};
-
-class VBoxVHWACommandElementPipe
-{
-public:
-    VBoxVHWACommandElementPipe() :
-        mpFirst(NULL),
-        mpLast(NULL)
-    {}
-
-    void put(VBoxVHWACommandElement *pCmd)
-    {
-        if (mpLast)
-        {
-            Assert(mpFirst);
-            mpLast->mpNext = pCmd;
-            mpLast = pCmd;
-        }
-        else
-        {
-            Assert(!mpFirst);
-            mpFirst = pCmd;
-            mpLast = pCmd;
-        }
-        pCmd->mpNext= NULL;
-
-    }
-
-    void setFrom(VBoxVHWACommandElementPipe *pOther)
-    {
-        mpFirst = pOther->detachList(&mpLast);
-    }
-
-    void set(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
-    {
-        mpFirst = pFirst;
-        mpLast = pLast;
-        if (mpLast)
-            mpLast->mpNext = NULL;
-    }
-
-    void prepend(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
-    {
-        if (!mpFirst)
-            set(pFirst, pLast);
-        else if (pLast)
-        {
-            pLast->mpNext = mpFirst;
-            mpFirst = pFirst;
-        }
-    }
-
-    void prependFrom(VBoxVHWACommandElementPipe *pOther)
-    {
-        VBoxVHWACommandElement *pFirst;
-        VBoxVHWACommandElement *pLast;
-        pFirst = pOther->detachList(&pLast);
-        prepend(pFirst, pLast);
-    }
-
-    void append(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
-    {
-        if (!mpLast)
-            set(pFirst, pLast);
-        else if (pLast)
-        {
-            mpLast->mpNext = pFirst;
-            mpLast = pLast;
-            pLast->mpNext = NULL;
-        }
-    }
-
-    VBoxVHWACommandElement * detachList(VBoxVHWACommandElement **ppLast)
-    {
-        if (mpLast)
-        {
-            VBoxVHWACommandElement * pHead = mpFirst;
-            if (ppLast)
-                *ppLast = mpLast;
-            mpFirst = NULL;
-            mpLast = NULL;
-            return pHead;
-        }
-        if (ppLast)
-            *ppLast = NULL;
-        return NULL;
-    }
-
-
-
-    const VBoxVHWACommandElement * contentsRo (const VBoxVHWACommandElement **ppLast) const
-    {
-        if (ppLast)
-            *ppLast = mpLast;
-        return mpFirst;
-    }
-
-    bool isEmpty() const { return !mpLast; }
-
-private:
-    VBoxVHWACommandElement *mpFirst;
-    VBoxVHWACommandElement *mpLast;
-};
-
-class VBoxVHWACommandElementStack
-{
-public:
-    VBoxVHWACommandElementStack() :
-        mpFirst(NULL) {}
-
-    void push(VBoxVHWACommandElement *pCmd)
-    {
-        pCmd->mpNext = mpFirst;
-        mpFirst = pCmd;
-    }
-
-    void pusha(VBoxVHWACommandElement *pFirst, VBoxVHWACommandElement *pLast)
-    {
-        pLast->mpNext = mpFirst;
-        mpFirst = pFirst;
-    }
-
-    VBoxVHWACommandElement * pop()
-    {
-        if(mpFirst)
-        {
-            VBoxVHWACommandElement * ret = mpFirst;
-            mpFirst = ret->mpNext;
-            return ret;
-        }
-        return NULL;
-    }
-private:
-    VBoxVHWACommandElement *mpFirst;
 };
 
@@ -1425 +1290 @@
 };
 
-#define VBOXVHWACMDPIPEC_NEWEVENT      0x00000001
-#define VBOXVHWACMDPIPEC_COMPLETEEVENT 0x00000002
 class VBoxVHWACommandElementProcessor
 {
@@ -1432 +1295 @@
     VBoxVHWACommandElementProcessor(QObject *pNotifyObject);
     ~VBoxVHWACommandElementProcessor();
-    void postCmd(VBOXVHWA_PIPECMD_TYPE aType, void * pvData, uint32_t flags);
-    bool completeCurrentEvent();
-    class VBoxVHWACommandElement * detachCmdList(class VBoxVHWACommandElement ** ppLast,
-            class VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free);
-    void putBack(class VBoxVHWACommandElement * pFirst2Put, VBoxVHWACommandElement * pLast2Put,
-            class VBoxVHWACommandElement * pFirst2Free, VBoxVHWACommandElement * pLast2Free);
-    void reset(class VBoxVHWACommandElement ** ppHead, class VBoxVHWACommandElement ** ppTail);
+    void postCmd(VBOXVHWA_PIPECMD_TYPE aType, void * pvData);
+    VBoxVHWACommandElement *getCmd();
+    void doneCmd();
+    void reset(CDisplay *pDisplay);
     void setNotifyObject(QObject *pNotifyObject);
     int loadExec (struct SSMHANDLE * pSSM, uint32_t u32Version, void *pvVRAM);
@@ -1446 +1306 @@
     void lock();
     void unlock();
-#ifdef DEBUG_misha
-    void checkConsistence(uint32_t cEvents2Submit = 0, const VBoxVHWACommandElementPipe *pPipe = NULL);
-#endif
 private:
     RTCRITSECT mCritSect;
-    VBoxVHWACommandElementPipe m_CmdPipe;
+    RTLISTNODE mCommandList;
     QObject *m_pNotifyObject;
     VBoxVHWARefCounter m_NotifyObjectRefs;
-    bool mbNewEvent;
-    bool mbProcessingList;
+    VBoxVHWACommandElement *mpCurCmd;
+    bool mbResetting;
     uint32_t mcDisabled;
-    VBoxVHWACommandElementStack mFreeElements;
-    VBoxVHWACommandElement mElementsBuffer[2048];
 };
 
@@ -1819 +1674 @@
                              ULONG aW, ULONG aH);
 
-    /**
-     * to be called on RequestResize framebuffer call
-     * @return true if the request was processed & should not be forwarded to the framebuffer
-     * false - otherwise */
-    bool onRequestResize (ULONG aScreenId, ULONG uPixelFormat,
-                          BYTE * pVRAM, ULONG uBitsPerPixel, ULONG uBytesPerLine,
-                          ULONG uWidth, ULONG uHeight,
-                          HRESULT *pResult,
-                          BOOL * pbFinished)
-    {
-        Q_UNUSED(aScreenId);
-        Q_UNUSED(uPixelFormat);
-        Q_UNUSED(pVRAM);
-        Q_UNUSED(uBitsPerPixel);
-        Q_UNUSED(uBytesPerLine);
-        Q_UNUSED(uWidth);
-        Q_UNUSED(uHeight);
-        Q_UNUSED(pbFinished);
-
-        if (mCmdPipe.completeCurrentEvent())
-            return false;
-
-        /* TODO: more graceful resize handling */
-        *pResult = E_FAIL;
-
-        return true;
+    void onNotifyUpdateIgnore (ULONG aX, ULONG aY,
+                             ULONG aW, ULONG aH)
+    {
+        /* @todo: we actually should not miss notify updates, since we need to update the texture on it */
     }
 
@@ -1922 +1755 @@
     void addMainDirtyRect (const QRect & aRect);
     void vboxCheckUpdateOverlay (const QRect & rect);
-    VBoxVHWACommandElement * processCmdList (VBoxVHWACommandElement * pCmd, bool bFirst);
+    void processCmd (VBoxVHWACommandElement * pCmd);
 
     int vhwaConstruct (struct VBOXVHWACMD_HH_CONSTRUCT *pCmd);
@@ -1980 +1813 @@
     STDMETHOD(ProcessVHWACommand)(BYTE *pCommand)
     {
-        return mOverlay.onVHWACommand ((struct VBOXVHWACMD*)pCommand);
+        int rc;
+        T::lock();
+        /* Make sure frame-buffer is used: */
+        if (m_fIsMarkedAsUnused)
+        {
+            LogRel2(("ProcessVHWACommand: Postponed!\n"));
+            /* Unlock access to frame-buffer: */
+            T::unlock();
+            /* tell client to pend ProcessVHWACommand */
+            return E_ACCESSDENIED;
+        }
+        rc = mOverlay.onVHWACommand ((struct VBOXVHWACMD*)pCommand);
+        T::unlock();
+        if (rc == VINF_CALLBACK_RETURN)
+            return S_OK;
+        else if (RT_SUCCESS(rc))
+            return S_FALSE;
+        else if (rc == VERR_INVALID_STATE)
+            return E_ACCESSDENIED;
+        return E_FAIL;
     }
 
@@ -1987 +1839 @@
         mOverlay.onVHWACommandEvent (pEvent);
     }
-
-    STDMETHOD(RequestResize) (ULONG aScreenId, ULONG aPixelFormat,
-                              BYTE *aVRAM, ULONG aBitsPerPixel, ULONG aBytesPerLine,
-                              ULONG aWidth, ULONG aHeight,
-                              BOOL *aFinished)
-   {
-        HRESULT result;
-        if (mOverlay.onRequestResize (aScreenId, aPixelFormat,
-                aVRAM, aBitsPerPixel, aBytesPerLine,
-                aWidth, aHeight,
-                &result,
-                aFinished))
-        {
-            return result;
-        }
-        return T::RequestResize (aScreenId, aPixelFormat,
-                aVRAM, aBitsPerPixel, aBytesPerLine,
-                aWidth, aHeight,
-                aFinished);
-   }
 
     STDMETHOD(NotifyUpdate) (ULONG aX, ULONG aY,
                              ULONG aW, ULONG aH)
     {
-        if (mOverlay.onNotifyUpdate (aX, aY, aW, aH))
-            return S_OK;
-        return T::NotifyUpdate (aX, aY, aW, aH);
-    }
-
-    STDMETHOD(VideoModeSupported) (ULONG uWidth, ULONG uHeight, ULONG uBPP,
-                                       BOOL *pbSupported)
-    {
-        /* TODO: tmp workaround: the lock should be moved to the calling code??
-         * otherwise we may end up calling a null View */
-        /* Todo: can we call VideoModeSupported with the lock held?
-         * if not we can introduce a ref counting for the mpView usage
-         * to ensure it stays alive till we need it*/
-        HRESULT hr = T::Lock();
-        HRESULT retHr = S_OK;
-        Assert(hr == S_OK);
-        if (SUCCEEDED(hr))
-        {
-            if (mpView)
-                retHr = T::VideoModeSupported(uWidth, uHeight, uBPP, pbSupported);
-            hr = T::Unlock();
-            Assert(hr == S_OK);
-        }
-        return retHr;
+        HRESULT hr = S_OK;
+        T::lock();
+        /* Make sure frame-buffer is used: */
+        if (m_fIsMarkedAsUnused)
+        {
+            LogRel2(("NotifyUpdate: Ignored!\n"));
+            mOverlay.onNotifyUpdateIgnore (aX, aY, aW, aH);
+            /* Unlock access to frame-buffer: */
+            T::unlock();
+            /*can we actually ignore the notify update?*/
+            /* Ignore NotifyUpdate: */
+            return E_FAIL;
+        }
+
+        if (!mOverlay.onNotifyUpdate (aX, aY, aW, aH))
+            hr = T::NotifyUpdate (aX, aY, aW, aH);
+        T::unlock();
+        return hr;
     }
 
@@ -2059 +1885 @@
     {
         /* lock to ensure we do not collide with the EMT thread passing commands to us */
-        HRESULT hr = T::Lock();
-        Assert(hr == S_OK);
-        if (SUCCEEDED(hr))
-        {
-            T::setView(pView);
-            mpView = pView;
-            mOverlay.updateAttachment(pView ? pView->viewport() : NULL, pView);
-            hr = T::Unlock();
-            Assert(hr == S_OK);
-        }
-    }
+        T::lock();
+        T::setView(pView);
+        mpView = pView;
+        mOverlay.updateAttachment(pView ? pView->viewport() : NULL, pView);
+        T::unlock();
+    }
+
 private:
     VBoxQGLOverlay mOverlay;

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineView.cpp

@@ -619 +619 @@
     QApplication::sendPostedEvents(this, QEvent::MetaCall);
 
+#ifdef VBOX_WITH_VIDEOHWACCEL
+    if (m_fAccelerate2DVideo)
+        QApplication::sendPostedEvents(this, VHWACommandProcessType);
+#endif /* VBOX_WITH_VIDEOHWACCEL */
+
     /* Temporarily detach the framebuffer from IDisplay before detaching
      * from view in order to respect the thread synchonisation logic (see UIFrameBuffer.h).

trunk/src/VBox/Main/include/DisplayImpl.h

@@ -147 +147 @@
     void handleDisplayUpdate(unsigned uScreenId, int x, int y, int w, int h);
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    void handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
+    int handleVHWACommandProcess(PVBOXVHWACMD pCommand);
 #endif
 #ifdef VBOX_WITH_CRHGSMI
@@ -225 +225 @@
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
-    static DECLCALLBACK(void)  displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
+    static DECLCALLBACK(int)  displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand);
 #endif
 

trunk/src/VBox/Main/src-client/DisplayImpl.cpp

@@ -3810 +3810 @@
 #ifdef VBOX_WITH_VIDEOHWACCEL
 
-void Display::handleVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
+#ifndef S_FALSE
+# define S_FALSE ((HRESULT)1L)
+#endif
+
+int Display::handleVHWACommandProcess(PVBOXVHWACMD pCommand)
 {
     unsigned id = (unsigned)pCommand->iDisplay;
     int rc = VINF_SUCCESS;
-    if (id < mcMonitors)
-    {
-        IFramebuffer *pFramebuffer = maFramebuffers[id].pFramebuffer;
-#ifdef DEBUG_misha
-        Assert (pFramebuffer);
-#endif
-
-        if (pFramebuffer != NULL)
-        {
-            HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
-            if (FAILED(hr))
-            {
-                rc = (hr == E_NOTIMPL) ? VERR_NOT_IMPLEMENTED : VERR_GENERAL_FAILURE;
-            }
-        }
-        else
-        {
-            rc = VERR_NOT_IMPLEMENTED;
-        }
-    }
-    else
-    {
-        rc = VERR_INVALID_PARAMETER;
-    }
-
-    if (RT_FAILURE(rc))
-    {
-        /* tell the guest the command is complete */
-        pCommand->Flags &= (~VBOXVHWACMD_FLAG_HG_ASYNCH);
-        pCommand->rc = rc;
-    }
-}
-
-DECLCALLBACK(void) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
+    if (id >= mcMonitors)
+        return VERR_INVALID_PARAMETER;
+
+    ComPtr<IFramebuffer> pFramebuffer;
+    AutoReadLock arlock(this COMMA_LOCKVAL_SRC_POS);
+    pFramebuffer = maFramebuffers[id].pFramebuffer;
+    arlock.release();
+
+    if (pFramebuffer == NULL)
+        return VERR_INVALID_STATE; /* notify we can not handle request atm */
+
+    HRESULT hr = pFramebuffer->ProcessVHWACommand((BYTE*)pCommand);
+    if (hr == S_FALSE)
+        return VINF_SUCCESS;
+    else if (SUCCEEDED(hr))
+        return VINF_CALLBACK_RETURN;
+    else if (hr == E_ACCESSDENIED)
+        return VERR_INVALID_STATE; /* notify we can not handle request atm */
+    else if (hr == E_NOTIMPL)
+        return VERR_NOT_IMPLEMENTED;
+    return VERR_GENERAL_FAILURE;
+}
+
+DECLCALLBACK(int) Display::displayVHWACommandProcess(PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCommand)
 {
     PDRVMAINDISPLAY pDrv = PDMIDISPLAYCONNECTOR_2_MAINDISPLAY(pInterface);
 
-    pDrv->pDisplay->handleVHWACommandProcess(pInterface, pCommand);
+    return pDrv->pDisplay->handleVHWACommandProcess(pCommand);
 }
 #endif