Changeset 49420 in vbox for trunk/src/VBox/Devices/Graphics

Timestamp:

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

Author:

vboxsync

Message:

forward-port and adopt VHWA fixes

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA.cpp (modified) (1 diff)
• DevVGA.h (modified) (4 diffs)
• DevVGA_VBVA.cpp (modified) (9 diffs)

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