Changeset 34129 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Nov 16, 2010 10:31:39 PM (14 years ago)

Author:

vboxsync

Message:

2d: fix save state deadlock (xtracker#5335)

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• VBoxFBOverlay.cpp (modified) (4 diffs)
• VBoxFBOverlay.h (modified) (4 diffs)

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

@@ -2739 +2739 @@
 
 #ifdef VBOX_WITH_WDDM
-    if(pCmd->u.in.xUpdatedSrcMemRect.right)
+    if(pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_SRCMEMRECT)
     {
         QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedSrcMemRect);
         pSrcSurf->updatedMem(&r);
     }
-    if(pCmd->u.in.xUpdatedDstMemRect.right)
+    if(pCmd->u.in.xFlags & VBOXVHWACMD_SURF_OVERLAY_UPDATE_F_DSTMEMRECT)
     {
         QRect r = VBOXVHWA_CONSTRUCT_QRECT_FROM_RECTL_WH(&pCmd->u.in.xUpdatedDstMemRect);
@@ -4262 +4262 @@
             return VINF_SUCCESS;
         }
+        case VBOXVHWACMD_TYPE_HH_ENABLE:
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = VINF_SUCCESS;
+            return VINF_SUCCESS;
+        case VBOXVHWACMD_TYPE_HH_DISABLE:
+            pCmd->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
+            pCmd->rc = VINF_SUCCESS;
+            return VINF_SUCCESS;
         default:
             break;
@@ -4721 +4729 @@
 int VBoxQGLOverlay::vhwaLoadExec(struct SSMHANDLE * pSSM, uint32_t u32Version)
 {
-    return VBoxVHWAImage::vhwaLoadExec(&mOnResizeCmdList, pSSM, u32Version);
+    int rc = VBoxVHWAImage::vhwaLoadExec(&mOnResizeCmdList, pSSM, u32Version);
+    AssertRC(rc);
+    if (RT_SUCCESS(rc))
+    {
+        rc = mCmdPipe.loadExec(pSSM, u32Version, mOverlayImage.vramBase());
+        AssertRC(rc);
+    }
+    return rc;
 }
 
 void VBoxQGLOverlay::vhwaSaveExec(struct SSMHANDLE * pSSM)
 {
+    mCmdPipe.lock();
     mOverlayImage.vhwaSaveExec(pSSM);
+    mCmdPipe.saveExec(pSSM, mOverlayImage.vramBase());
+    mCmdPipe.unlock();
 }
 
@@ -5104 +5122 @@
 }
 
+#define VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC 0x89abcdef
+#define VBOXVHWACOMMANDELEMENTLISTEND_MAGIC   0xfedcba98
+
+int VBoxVHWACommandElementProcessor::loadExec (struct SSMHANDLE * pSSM, uint32_t u32Version, void *pvVRAM)
+{
+    uint32_t u32;
+    bool b;
+    int rc;
+    rc = SSMR3GetU32(pSSM, &u32);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(u32 == VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC);
+        if (u32 == VBOXVHWACOMMANDELEMENTLISTBEGIN_MAGIC)
+        {
+            rc = SSMR3GetU32(pSSM, &u32);
+            rc = SSMR3GetBool(pSSM, &b);         AssertRC(rc);
+        //    m_NotifyObjectRefs = VBoxVHWARefCounter(u32);
+            bool bContinue = true;
+            do
+            {
+                rc = SSMR3GetU32(pSSM, &u32);         AssertRC(rc);
+                if (RT_SUCCESS(rc))
+                {
+                    bool bNewEvent;
+                    switch (u32)
+                    {
+                        case VBOXVHWA_PIPECMD_PAINT:
+                        {
+                            int x,y,w,h;
+                            rc = SSMR3GetS32(pSSM, &x);         AssertRC(rc);
+                            rc = SSMR3GetS32(pSSM, &y);         AssertRC(rc);
+                            rc = SSMR3GetS32(pSSM, &w);         AssertRC(rc);
+                            rc = SSMR3GetS32(pSSM, &h);         AssertRC(rc);
+
+                            rc = SSMR3GetBool(pSSM, &bNewEvent);         AssertRC(rc);
+
+                            if (RT_SUCCESS(rc))
+                            {
+                                postCmd(VBOXVHWA_PIPECMD_PAINT, &QRect(x,y,w,h), 0);
+                            }
+                            break;
+                        }
+                        case VBOXVHWA_PIPECMD_VHWA:
+                        {
+                            uint32_t offCmd;
+                            rc = SSMR3GetU32(pSSM, &offCmd);         AssertRC(rc);
+
+                            rc = SSMR3GetBool(pSSM, &bNewEvent);         AssertRC(rc);
+
+                            if (RT_SUCCESS(rc))
+                            {
+                                postCmd(VBOXVHWA_PIPECMD_VHWA, (VBOXVHWACMD*)(((uint8_t*)pvVRAM) + offCmd), 0);
+                            }
+                            break;
+                        }
+                        case VBOXVHWACOMMANDELEMENTLISTEND_MAGIC:
+                        {
+                            bContinue = false;
+                            break;
+                        }
+                        default:
+                            Assert(0);
+                            break;
+                    }
+
+                }
+
+            } while(bContinue && RT_SUCCESS(rc));
+        }
+        else
+        {
+            rc = VERR_INVALID_MAGIC;
+        }
+    }
+    else if (rc == VERR_SSM_LOADED_TOO_MUCH)
+    {
+        /* this would mean we do not have a cmd pipe data saved.
+         * skip the failure.
+         * not sure if that's a good idea actually,
+         * but this allows keeping the state version unchanged */
+        rc = VINF_SUCCESS;
+    }
+
+    return rc;
+}
+
+void VBoxVHWACommandElementProcessor::saveExec (struct SSMHANDLE * pSSM, void *pvVRAM)
+{
+    int rc;
+
+    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 = SSMR3PutU32(pSSM, pCur->type());         AssertRC(rc);
+
+        switch (pCur->type())
+        {
+            case VBOXVHWA_PIPECMD_PAINT:
+                rc = SSMR3PutS32(pSSM, pCur->rect().x());         AssertRC(rc);
+                rc = SSMR3PutS32(pSSM, pCur->rect().y());         AssertRC(rc);
+                rc = SSMR3PutS32(pSSM, pCur->rect().width());         AssertRC(rc);
+                rc = SSMR3PutS32(pSSM, pCur->rect().height());         AssertRC(rc);
+                rc = SSMR3PutBool(pSSM, pCur->isNewEvent());         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);
+                break;
+            }
+            default:
+                Assert(0);
+                break;
+        }
+    }
+
+    rc = SSMR3PutU32(pSSM, VBOXVHWACOMMANDELEMENTLISTEND_MAGIC);         AssertRC(rc);
+}
+
+void VBoxVHWACommandElementProcessor::lock()
+{
+    RTCritSectEnter(&mCritSect);
+
+    if(mbProcessingList)
+    {
+        for(;;)
+        {
+            RTCritSectLeave(&mCritSect);
+            RTThreadSleep(2000); /* 2 ms */
+            RTCritSectEnter(&mCritSect);
+            /* it is assumed no one sends any new commands while reset is in progress */
+            if(!mbProcessingList)
+            {
+                break;
+            }
+        }
+    }
+
+    Assert(!mbProcessingList);
+}
+
+void VBoxVHWACommandElementProcessor::unlock()
+{
+    RTCritSectLeave(&mCritSect);
+}
+
 VBoxVHWATextureImage::VBoxVHWATextureImage(const QRect &size, const VBoxVHWAColorFormat &format, class VBoxVHWAGlProgramMngr * aMgr, VBOXVHWAIMG_TYPE flags) :
         mVisibleDisplay(0),

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

@@ -1318 +1318 @@
     }
 
+
+
     const VBoxVHWACommandElement * contentsRo (const VBoxVHWACommandElement **ppLast) const
     {
@@ -1326 +1328 @@
 
     bool isEmpty() const { return !mpLast; }
+
 private:
     VBoxVHWACommandElement *mpFirst;
@@ -1368 +1371 @@
 public:
     VBoxVHWARefCounter() : m_cRefs(0) {}
+    VBoxVHWARefCounter(uint32_t cRefs) : m_cRefs(cRefs) {}
     void inc() { ASMAtomicIncU32(&m_cRefs); }
     uint32_t dec()
@@ -1418 +1422 @@
     void reset(class VBoxVHWACommandElement ** ppHead, class VBoxVHWACommandElement ** ppTail);
     void setNotifyObject(QObject *pNotifyObject);
+    int loadExec (struct SSMHANDLE * pSSM, uint32_t u32Version, void *pvVRAM);
+    void saveExec (struct SSMHANDLE * pSSM, void *pvVRAM);
+    void lock();
+    void unlock();
 #ifdef DEBUG_misha
     void checkConsistence(uint32_t cEvents2Submit = 0, const VBoxVHWACommandElementPipe *pPipe = NULL);