Changeset 36132 in vbox for trunk/src

Timestamp:

Mar 2, 2011 9:58:40 PM (14 years ago)

Author:

vboxsync

Message:

VD: Update the modification UUID during async I/O

File:

• trunk/src/VBox/Storage/VD.cpp (modified) (10 diffs)

trunk/src/VBox/Storage/VD.cpp

@@ -213 +213 @@
     /** List of waiting requests. - Protected by the critical section. */
     RTLISTNODE          ListWriteLocked;
+    /** I/O context which locked the disk. */
+    PVDIOCTX            pIoCtxLockOwner;
 
     /** Pointer to the L2 disk cache if any. */
@@ -1200 +1202 @@
 }
 
+DECLINLINE(bool) vdIoCtxIsDiskLockOwner(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+{
+    return    pDisk->fLocked
+           && pDisk->pIoCtxLockOwner == pIoCtx;
+}
+
 static int vdIoCtxLockDisk(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
 {
@@ -1206 +1214 @@
     if (!ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
     {
+        Assert(pDisk->pIoCtxLockOwner != pIoCtx); /* No nesting allowed. */
+
         rc = vdIoCtxDefer(pDisk, pIoCtx);
         if (RT_SUCCESS(rc))
             rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
     }
+    else
+    {
+        Assert(!pDisk->pIoCtxLockOwner);
+        pDisk->pIoCtxLockOwner = pIoCtx;
+    }
 
     return rc;
 }
 
-static void vdIoCtxUnlockDisk(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+static void vdIoCtxUnlockDisk(PVBOXHDD pDisk, PVDIOCTX pIoCtx, bool fProcessDeferredReqs)
 {
     Assert(pDisk->fLocked);
+    Assert(pDisk->pIoCtxLockOwner == pIoCtx);
+    pDisk->pIoCtxLockOwner = NULL;
     ASMAtomicXchgBool(&pDisk->fLocked, false);
 
-    /* Process any pending writes if the current request didn't caused another growing. */
-    RTCritSectEnter(&pDisk->CritSect);
-
-    if (!RTListIsEmpty(&pDisk->ListWriteLocked))
-    {
-        RTLISTNODE ListTmp;
-
-        RTListMove(&ListTmp, &pDisk->ListWriteLocked);
-        RTCritSectLeave(&pDisk->CritSect);
-
-        /* Process the list. */
-        do
-        {
-            int rc;
-            PVDIOCTXDEFERRED pDeferred = RTListGetFirst(&ListTmp, VDIOCTXDEFERRED, NodeDeferred);
-            PVDIOCTX pIoCtxWait = pDeferred->pIoCtx;
-
-            AssertPtr(pIoCtxWait);
-
-            RTListNodeRemove(&pDeferred->NodeDeferred);
-            RTMemFree(pDeferred);
-
-            Assert(!pIoCtxWait->pIoCtxParent);
-
-            pIoCtxWait->fBlocked = false;
-            LogFlowFunc(("Processing waiting I/O context pIoCtxWait=%#p\n", pIoCtxWait));
-
-            rc = vdIoCtxProcess(pIoCtxWait);
-            if (   rc == VINF_VD_ASYNC_IO_FINISHED
-                && ASMAtomicCmpXchgBool(&pIoCtxWait->fComplete, true, false))
+    if (fProcessDeferredReqs)
+    {
+        /* Process any pending writes if the current request didn't caused another growing. */
+        RTCritSectEnter(&pDisk->CritSect);
+
+        if (!RTListIsEmpty(&pDisk->ListWriteLocked))
+        {
+            RTLISTNODE ListTmp;
+
+            RTListMove(&ListTmp, &pDisk->ListWriteLocked);
+            RTCritSectLeave(&pDisk->CritSect);
+
+            /* Process the list. */
+            do
             {
-                LogFlowFunc(("Waiting I/O context completed pIoCtxWait=%#p\n", pIoCtxWait));
-                vdThreadFinishWrite(pDisk);
-                pIoCtxWait->Type.Root.pfnComplete(pIoCtxWait->Type.Root.pvUser1,
-                                                  pIoCtxWait->Type.Root.pvUser2,
-                                                  pIoCtxWait->rcReq);
-                vdIoCtxFree(pDisk, pIoCtxWait);
-            }
-        } while (!RTListIsEmpty(&ListTmp));
-    }
-    else
-        RTCritSectLeave(&pDisk->CritSect);
+                int rc;
+                PVDIOCTXDEFERRED pDeferred = RTListGetFirst(&ListTmp, VDIOCTXDEFERRED, NodeDeferred);
+                PVDIOCTX pIoCtxWait = pDeferred->pIoCtx;
+
+                AssertPtr(pIoCtxWait);
+
+                RTListNodeRemove(&pDeferred->NodeDeferred);
+                RTMemFree(pDeferred);
+
+                Assert(!pIoCtxWait->pIoCtxParent);
+
+                pIoCtxWait->fBlocked = false;
+                LogFlowFunc(("Processing waiting I/O context pIoCtxWait=%#p\n", pIoCtxWait));
+
+                rc = vdIoCtxProcess(pIoCtxWait);
+                if (   rc == VINF_VD_ASYNC_IO_FINISHED
+                    && ASMAtomicCmpXchgBool(&pIoCtxWait->fComplete, true, false))
+                {
+                    LogFlowFunc(("Waiting I/O context completed pIoCtxWait=%#p\n", pIoCtxWait));
+                    vdThreadFinishWrite(pDisk);
+                    pIoCtxWait->Type.Root.pfnComplete(pIoCtxWait->Type.Root.pvUser1,
+                                                      pIoCtxWait->Type.Root.pvUser2,
+                                                      pIoCtxWait->rcReq);
+                    vdIoCtxFree(pDisk, pIoCtxWait);
+                }
+            } while (!RTListIsEmpty(&ListTmp));
+        }
+        else
+            RTCritSectLeave(&pDisk->CritSect);
+    }
 }
 
@@ -1640 +1660 @@
 
 /**
+ * Flush helper async version.
+ */
+static int vdSetModifiedHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDIMAGE pImage = pIoCtx->pImageCur;
+
+    rc = pImage->Backend->pfnAsyncFlush(pImage->pBackendData, pIoCtx);
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+
+    return rc;
+}
+
+/**
+ * internal: mark the disk as modified - async version.
+ */
+static int vdSetModifiedFlagAsync(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
+    if (pDisk->uModified & VD_IMAGE_MODIFIED_FIRST)
+    {
+        rc = vdIoCtxLockDisk(pDisk, pIoCtx);
+        if (RT_SUCCESS(rc))
+        {
+            pDisk->uModified &= ~VD_IMAGE_MODIFIED_FIRST;
+
+            /* First modify, so create a UUID and ensure it's written to disk. */
+            vdResetModifiedFlag(pDisk);
+
+            if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
+            {
+                PVDIOCTX pIoCtxFlush = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_FLUSH,
+                                                         0, 0, pDisk->pLast,
+                                                         NULL, pIoCtx, 0, 0, NULL,
+                                                         vdSetModifiedHelperAsync);
+
+                if (pIoCtxFlush)
+                {
+                    rc = vdIoCtxProcess(pIoCtxFlush);
+                    if (rc == VINF_VD_ASYNC_IO_FINISHED)
+                    {
+                        vdIoCtxUnlockDisk(pDisk, pIoCtxFlush, false /* fProcessDeferredReqs */);
+                        vdIoCtxFree(pDisk, pIoCtxFlush);
+                    }
+                    else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    {
+                        pIoCtx->fBlocked = true;
+                    }
+                    else /* Another error */
+                        vdIoCtxFree(pDisk, pIoCtxFlush);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+        }
+    }
+
+    return rc;
+}
+
+/**
  * internal: write a complete block (only used for diff images), taking the
  * remaining data from parent images. This implementation does not optimize
@@ -1928 +2013 @@
     size_t cbPreRead, cbPostRead;
 
+    rc = vdSetModifiedFlagAsync(pDisk, pIoCtx);
+    if (RT_FAILURE(rc)) /* Includes I/O in progress. */
+        return rc;
+
     /* Loop until all written. */
     do
@@ -2489 +2578 @@
                 PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
 
-                LogFlowFunc(("I/O context transferred %u bytes for the parent pIoCtxParent=%p\n",
-                             pIoCtx->Type.Child.cbTransferParent, pIoCtxParent));
-
-                /* Update the parent state. */
                 Assert(!pIoCtxParent->pIoCtxParent);
-                Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE);
-                Assert(pIoCtxParent->cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
-                ASMAtomicSubU32(&pIoCtxParent->cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
-
                 if (RT_FAILURE(pIoCtx->rcReq))
                     ASMAtomicCmpXchgS32(&pIoCtxParent->rcReq, pIoCtx->rcReq, VINF_SUCCESS);
+
+                if (pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE)
+                {
+                    LogFlowFunc(("I/O context transferred %u bytes for the parent pIoCtxParent=%p\n",
+                                 pIoCtx->Type.Child.cbTransferParent, pIoCtxParent));
+
+                    /* Update the parent state. */
+                    Assert(pIoCtxParent->cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
+                    ASMAtomicSubU32(&pIoCtxParent->cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
+                }
+                else
+                    Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH);
 
                 /*
@@ -2505 +2598 @@
                  * We have to process any pending writes now.
                  */
-                Assert(pDisk->fLocked);
-                ASMAtomicWriteBool(&pDisk->fLocked, false);
+                vdIoCtxUnlockDisk(pDisk, pIoCtxParent, false /* fProcessDeferredReqs */);
 
                 /* Unblock the parent */
@@ -2527 +2619 @@
                 RTCritSectEnter(&pDisk->CritSect);
 
-                if (!RTListIsEmpty(&pDisk->ListWriteLocked) && !pDisk->fLocked)
+                if (   !RTListIsEmpty(&pDisk->ListWriteLocked)
+                    && !vdIoCtxIsDiskLockOwner(pDisk, pIoCtx))
                 {
                     RTLISTNODE ListTmp;
@@ -2577 +2670 @@
                 if (pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH)
                 {
-                    vdIoCtxUnlockDisk(pDisk, pIoCtx);
+                    vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessDerredReqs */);
                     vdThreadFinishWrite(pDisk);
                 }
@@ -3739 +3832 @@
             pDisk->pInterfaceThreadSyncCallbacks = NULL;
             pDisk->fLocked = false;
+            pDisk->pIoCtxLockOwner = NULL;
             RTListInit(&pDisk->ListWriteLocked);