Changeset 28620 in vbox

Timestamp:

Apr 22, 2010 10:43:37 PM (15 years ago)

Author:

vboxsync

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

60469

Message:

VBoxHDD: async I/O updates. Mostly complete except for bug fixes

Location:

trunk

Files:

• include/VBox/VBoxHDD.h (modified) (2 diffs)
• src/VBox/Devices/Storage/DevAHCI.cpp (modified) (2 diffs)
• src/VBox/Devices/Storage/DrvVD.cpp (modified) (1 diff)
• src/VBox/Devices/Storage/ParallelsHDDCore.cpp (modified) (3 diffs)
• src/VBox/Devices/Storage/RawHDDCore.cpp (modified) (5 diffs)
• src/VBox/Devices/Storage/VBoxHDD.cpp (modified) (62 diffs)
• src/VBox/Devices/Storage/VDICore.h (modified) (1 diff)
• src/VBox/Devices/Storage/VDIHDDCore.cpp (modified) (4 diffs)
• src/VBox/Devices/Storage/VHDHDDCore.cpp (modified) (4 diffs)
• src/VBox/Devices/Storage/VmdkHDDCore.cpp (modified) (8 diffs)

trunk/include/VBox/VBoxHDD.h

@@ -1338 +1338 @@
 } VDBACKENDINFO, *PVDBACKENDINFO;
 
-/**
- * Completion callback for metadata reads or writes.
- *
- * @return  nothing.
- * @param   pvBackendData   The opaque backend data.
- * @param   pvMetaUser      Opaque user data passed during a metadata read/write request.
- */
-typedef DECLCALLBACK(void) FNVDMETACOMPLETED(void *pvBackendData, void *pvMetaUser);
-/** Pointer to FNVDCOMPLETED() */
-typedef FNVDMETACOMPLETED *PFNVDMETACOMPLETED;
 
 /** Forward declaration. Only visible in the VBoxHDD module. */
@@ -1356 +1346 @@
 /** Pointer to a storage backend handle. */
 typedef PVDIOSTORAGE *PPVDIOSTORAGE;
+
+/**
+ * Completion callback for metadata reads or writes.
+ *
+ * @return  nothing.
+ * @param   pvBackendData   The opaque backend data.
+ * @param   pIoCtx          I/O context associated with this request.
+ * @param   pvMetaUser      Opaque user data passed during a metadata read/write request.
+ */
+typedef DECLCALLBACK(void) FNVDMETACOMPLETED(void *pvBackendData, PVDIOCTX pIoCtx, void *pvMetaUser);
+/** Pointer to FNVDCOMPLETED() */
+typedef FNVDMETACOMPLETED *PFNVDMETACOMPLETED;
 
 /**

trunk/src/VBox/Devices/Storage/DevAHCI.cpp

@@ -4855 +4855 @@
 {
     /* Free system resources occupied by the scatter gather list. */
-    ahciScatterGatherListDestroy(pAhciPort, pAhciPortTaskState);
+    if (pAhciPortTaskState->enmTxDir != AHCITXDIR_FLUSH)
+        ahciScatterGatherListDestroy(pAhciPort, pAhciPortTaskState);
 
     pAhciPortTaskState->cmdHdr.u32PRDBC = pAhciPortTaskState->cbTransfer;
@@ -5290 +5291 @@
         if (enmTxDir != AHCITXDIR_NONE)
         {
+            pAhciPortTaskState->enmTxDir = enmTxDir;
+
             if (pAhciPortTaskState->fQueued)
             {

trunk/src/VBox/Devices/Storage/DrvVD.cpp

@@ -1352 +1352 @@
                 break;
             }
-            rc = CFGMR3QueryBoolDef(pCurNode, "UseNewIo", &fUseNewIo, false);
+            rc = CFGMR3QueryBoolDef(pCurNode, "UseNewIo", &fUseNewIo, true);
             if (RT_FAILURE(rc))
             {

trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp

@@ -65 +65 @@
 {
     /** Pointer to the per-disk VD interface list. */
-    PVDINTERFACE         pVDIfsDisk;
+    PVDINTERFACE        pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE        pVDIfsImage;
     /** Error interface. */
     PVDINTERFACE        pInterfaceError;
@@ -284 +286 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get async I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -499 +501 @@
     pImage->pszFilename = pszFilename;
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = parallelsOpenImage(pImage, uOpenFlags);

trunk/src/VBox/Devices/Storage/RawHDDCore.cpp

@@ -58 +58 @@
     /** Pointer to the per-disk VD interface list. */
     PVDINTERFACE      pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE      pVDIfsImage;
 
     /** Error callback. */
@@ -269 +271 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -335 +337 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get async I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -511 +513 @@
 #endif
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = rawOpenImage(pImage, uOpenFlags);
@@ -580 +583 @@
 #endif
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = rawCreateImage(pImage, cbSize, uImageFlags, pszComment,

trunk/src/VBox/Devices/Storage/VBoxHDD.cpp

@@ -41 +41 @@
 #include <iprt/memcache.h>
 #include <iprt/sg.h>
+#include <iprt/critsect.h>
+#include <iprt/list.h>
 
 #include <VBox/VBoxHDD-Plugin.h>
@@ -87 +89 @@
     /** Function pointers for the various backend methods. */
     PCVBOXHDDBACKEND    Backend;
+    /** Per image I/O interface. */
+    VDINTERFACE         VDIIO;
     /** Pointer to list of VD interfaces, per-image. */
     PVDINTERFACE        pVDIfsImage;
+    /** Disk this image is part of */
+    PVBOXHDD            pDisk;
 } VDIMAGE, *PVDIMAGE;
 
@@ -158 +164 @@
     /** Memory cache for I/O tasks. */
     RTMEMCACHE          hMemCacheIoTask;
+    /** Critical section protecting the disk against concurrent access. */
+    RTCRITSECT          CritSect;
+    /** Flag whether the last image is currently written to and needs to grow.
+     * Other write requests which will grow the image too need to be deferred to
+     * prevent data corruption. - Protected by the critical section.
+     */
+    bool                fGrowing;
+    /** List of waiting requests. - Protected by the critical section. */
+    RTLISTNODE          ListWriteGrowing;
 };
 
@@ -187 +202 @@
 } VDIOCTXTXDIR, *PVDIOCTXTXDIR;
 
+/** Transfer function */
+typedef DECLCALLBACK(int) FNVDIOCTXTRANSFER (PVDIOCTX pIoCtx);
+/** Pointer to a transfer function. */
+typedef FNVDIOCTXTRANSFER *PFNVDIOCTXTRANSFER;
+
 /**
  * I/O context
@@ -192 +212 @@
 typedef struct VDIOCTX
 {
+    /** Node in the list of deferred requests. */
+    RTLISTNODE                   NodeWriteGrowing;
     /** Disk this is request is for. */
     PVBOXHDD                     pDisk;
@@ -202 +224 @@
     /** Current offset */
     volatile uint64_t            uOffset;
+    /** Number of bytes to transfer */
+    volatile size_t              cbTransfer;
+    /** Current image in the chain. */
+    PVDIMAGE                     pImage;
     /** S/G buffer */
     RTSGBUF                      SgBuf;
@@ -211 +237 @@
      * when the context completes. */
     void                        *pvAllocation;
+    /** Transfer function. */
+    PFNVDIOCTXTRANSFER           pfnIoCtxTransfer;
+    /** Next transfer part after the current one completed. */
+    PFNVDIOCTXTRANSFER           pfnIoCtxTransferNext;
     /** Parent I/O context if any. Sets the type of the context (root/child) */
     PVDIOCTX                     pIoCtxParent;
@@ -235 +265 @@
             /** Number of bytes transfered from the parent if this context completes. */
             size_t                       cbTransferParent;
+            /** Number of bytes to pre read */
+            size_t                       cbPreRead;
+            /** Number of bytes to post read. */
+            size_t                       cbPostRead;
+            /** Write type dependent data. */
+            union
+            {
+                /** Optimized */
+                struct
+                {
+                    /** Bytes to fill to satisfy the block size. Not part of the virtual disk. */
+                    size_t               cbFill;
+                    /** Bytes to copy instead of reading from the parent */
+                    size_t               cbWriteCopy;
+                    /** Bytes to read from the image. */
+                    size_t               cbReadImage;
+                    /** Number of bytes to wite left. */
+                    size_t               cbWrite;
+                } Optimized;
+            } Write;
         } Child;
     } Type;
@@ -266 +316 @@
             /** User data */
             void                *pvMetaUser;
+            /** Image the task was created for. */
+            PVDIMAGE             pImage;
         } Meta;
     } Type;
@@ -275 +327 @@
 typedef struct VDIOSTORAGE
 {
+    /** Image this storage handle belongs to. */
+    PVDIMAGE                     pImage;
     union
     {
         /** Storage handle */
-        void                        *pStorage;
+        void                    *pStorage;
         /** File handle for the limited I/O version. */
-        RTFILE                       hFile;
+        RTFILE                   hFile;
     } u;
 } VDIOSTORAGE;
@@ -531 +585 @@
                                   uint64_t uOffset, size_t cbTransfer,
                                   PCRTSGSEG pcaSeg, unsigned cSeg,
-                                  void *pvAllocation)
+                                  void *pvAllocation,
+                                  PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
 {
     PVDIOCTX pIoCtx = NULL;
@@ -542 +597 @@
         pIoCtx->cbTransferLeft        = cbTransfer;
         pIoCtx->uOffset               = uOffset;
+        pIoCtx->cbTransfer            = cbTransfer;
         pIoCtx->cMetaTransfersPending = 0;
         pIoCtx->fComplete             = false;
         pIoCtx->pvAllocation          = pvAllocation;
+        pIoCtx->pfnIoCtxTransfer      = pfnIoCtxTransfer;
+        pIoCtx->pfnIoCtxTransferNext  = NULL;
 
         RTSgBufInit(&pIoCtx->SgBuf, pcaSeg, cSeg);
@@ -552 +610 @@
 }
 
-static PVDIOCTX vdIoCtxRootAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
-                                 uint64_t uOffset, size_t cbTransfer,
-                                 PCRTSGSEG paSeg, unsigned cSeg,
-                                 PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
-                                 void *pvUser1, void *pvUser2,
-                                 void *pvAllocation)
+DECLINLINE(PVDIOCTX) vdIoCtxRootAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+                                      uint64_t uOffset, size_t cbTransfer,
+                                      PCRTSGSEG paSeg, unsigned cSeg,
+                                      PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                      void *pvUser1, void *pvUser2,
+                                      void *pvAllocation,
+                                      PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer,
-                                   paSeg, cSeg, pvAllocation);
+                                   paSeg, cSeg, pvAllocation, pfnIoCtxTransfer);
 
     if (RT_LIKELY(pIoCtx))
@@ -573 +632 @@
 }
 
-static PVDIOCTX vdIoCtxChildAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
-                                  uint64_t uOffset, size_t cbTransfer,
-                                  PCRTSGSEG paSeg, unsigned cSeg,
-                                  PVDIOCTX pIoCtxParent, size_t cbTransferParent,
-                                  void *pvAllocation)
+DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+                                       uint64_t uOffset, size_t cbTransfer,
+                                       PCRTSGSEG paSeg, unsigned cSeg,
+                                       PVDIOCTX pIoCtxParent, size_t cbTransferParent,
+                                       void *pvAllocation,
+                                       PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer,
-                                   paSeg, cSeg, pvAllocation);
+                                   paSeg, cSeg, pvAllocation, pfnIoCtxTransfer);
 
     if (RT_LIKELY(pIoCtx))
@@ -593 +653 @@
 }
 
-static PVDIOTASK vdIoTaskUserAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, uint32_t cbTransfer)
+DECLINLINE(PVDIOTASK) vdIoTaskUserAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, uint32_t cbTransfer)
 {
     PVDIOTASK pIoTask = NULL;
@@ -608 +668 @@
 }
 
-static PVDIOTASK vdIoTaskMetaAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, VDIOCTXTXDIR enmTxDir,
-                                   PFNVDMETACOMPLETED pfnMetaComplete, void *pvMetaUser)
+DECLINLINE(PVDIOTASK) vdIoTaskMetaAlloc(PVBOXHDD pDisk, PVDIOCTX pIoCtx, VDIOCTXTXDIR enmTxDir,
+                                        PVDIMAGE pImage,
+                                        PFNVDMETACOMPLETED pfnMetaComplete, void *pvMetaUser)
 {
     PVDIOTASK pIoTask = NULL;
@@ -621 +682 @@
         pIoTask->Type.Meta.pfnMetaComplete   = pfnMetaComplete;
         pIoTask->Type.Meta.pvMetaUser        = pvMetaUser;
+        pIoTask->Type.Meta.pImage            = pImage;
     }
 
@@ -626 +688 @@
 }
 
-static void vdIoCtxFree(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
+DECLINLINE(void) vdIoCtxFree(PVBOXHDD pDisk, PVDIOCTX pIoCtx)
 {
     if (pIoCtx->pvAllocation)
@@ -633 +695 @@
 }
 
-static void vdIoTaskFree(PVBOXHDD pDisk, PVDIOTASK pIoTask)
+DECLINLINE(void) vdIoTaskFree(PVBOXHDD pDisk, PVDIOTASK pIoTask)
 {
     pIoTask->pIoCtx = NULL;
@@ -639 +701 @@
 }
 
-static void vdIoCtxChildReset(PVDIOCTX pIoCtx)
+DECLINLINE(void) vdIoCtxChildReset(PVDIOCTX pIoCtx)
 {
     AssertPtr(pIoCtx->pIoCtxParent);
@@ -674 +736 @@
 }
 
+static int vdIoCtxProcess(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = pIoCtx->pDisk;
+
+    if (   !pIoCtx->cbTransferLeft
+        && !pIoCtx->cMetaTransfersPending)
+        return VINF_VD_ASYNC_IO_FINISHED;
+
+    if (pIoCtx->pfnIoCtxTransfer)
+    {
+        /* Call the transfer function advancing to the next while there is no error. */
+        RTCritSectEnter(&pDisk->CritSect);
+        while (   pIoCtx->pfnIoCtxTransfer
+               && RT_SUCCESS(rc))
+        {
+            rc = pIoCtx->pfnIoCtxTransfer(pIoCtx);
+
+            /* Advance to the next part of the transfer if the current one succeeded. */
+            if (RT_SUCCESS(rc))
+            {
+                pIoCtx->pfnIoCtxTransfer = pIoCtx->pfnIoCtxTransferNext;
+                pIoCtx->pfnIoCtxTransferNext = NULL;
+            }
+        }
+        RTCritSectLeave(&pDisk->CritSect);
+    }
+
+    if (   RT_SUCCESS(rc)
+        && !pIoCtx->cbTransferLeft
+        && !pIoCtx->cMetaTransfersPending)
+        rc = VINF_VD_ASYNC_IO_FINISHED;
+    else if (RT_SUCCESS(rc))
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+
+    LogFlowFunc(("pIoCtx=%#p rc=%Rrc cbTransferLeft=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
+                 pIoCtx, rc, pIoCtx->cbTransferLeft, pIoCtx->cMetaTransfersPending,
+                 pIoCtx->fComplete));
+
+    return rc;
+}
+
 /**
  * internal: read the specified amount of data in whatever blocks the backend
  * will give us - async version.
  */
-static int vdReadHelperAsync(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
-                             PVDIOCTX pIoCtx, uint64_t uOffset, size_t cbRead)
+static int vdReadHelperAsync(PVDIOCTX pIoCtx)
 {
     int rc;
+    size_t cbToRead     = pIoCtx->cbTransfer;
+    uint64_t uOffset    = pIoCtx->uOffset;
+    PVDIMAGE pCurrImage = NULL;
     size_t cbThisRead;
 
@@ -687 +793 @@
     do
     {
+        pCurrImage = pIoCtx->pImage;
+
         /* Search for image with allocated block. Do not attempt to read more
          * than the previous reads marked as valid. Otherwise this would return
          * stale data when different block sizes are used for the images. */
-        cbThisRead = cbRead;
+        cbThisRead = cbToRead;
 
         /*
@@ -696 +804 @@
          * If the block is not allocated read from override chain if present.
          */
-        rc = pImage->Backend->pfnAsyncRead(pImage->pvBackendData,
-                                           uOffset, cbThisRead,
-                                           pIoCtx, &cbThisRead);
+        rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pvBackendData,
+                                               uOffset, cbThisRead,
+                                               pIoCtx, &cbThisRead);
 
         if (rc == VERR_VD_BLOCK_FREE)
         {
-            for (PVDIMAGE pCurrImage = pImageParentOverride ? pImageParentOverride : pImage->pPrev;
+            for (pCurrImage =  pCurrImage->pPrev;
                  pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
                  pCurrImage = pCurrImage->pPrev)
@@ -723 +831 @@
             break;
 
-        cbRead  -= cbThisRead;
-        uOffset += cbThisRead;
-    } while (cbRead != 0 && RT_SUCCESS(rc));
+        cbToRead -= cbThisRead;
+        uOffset  += cbThisRead;
+    } while (cbToRead != 0 && RT_SUCCESS(rc));
 
     if (rc == VERR_VD_NOT_ENOUGH_METADATA)
     {
-        pIoCtx->uOffset = uOffset;
+        /* Save the current state. */
+        pIoCtx->uOffset    = uOffset;
+        pIoCtx->cbTransfer = cbToRead;
+        pIoCtx->pImage     = pCurrImage;
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
     }
 
@@ -1014 +1126 @@
  * images that are really needed) - async version.
  */
-static int vdWriteHelperStandardAsync(PVBOXHDD pDisk, PVDIMAGE pImage,
-                                      PVDIMAGE pImageParentOverride,
-                                      uint64_t uOffset, size_t cbWrite,
-                                      size_t cbThisWrite, size_t cbPreRead,
-                                      size_t cbPostRead, PVDIOCTX pIoCtxSrc,
-                                      PVDIOCTX pIoCtxDst)
+static int vdWriteHelperStandardAsync(PVDIOCTX pIoCtx)
 {
     int rc = VINF_SUCCESS;
+
+#if 0
 
     /* Read the data that goes before the write to fill the block. */
     if (cbPreRead)
     {
-        rc = vdReadHelperAsync(pDisk, pImage, pImageParentOverride, pIoCtxDst,
-                               uOffset - cbPreRead, cbPreRead);
+        rc = vdReadHelperAsync(pIoCtxDst);
         if (RT_FAILURE(rc))
             return rc;
@@ -1102 +1210 @@
 
     return rc;
+#endif
+    return VERR_NOT_IMPLEMENTED;
+}
+
+static int vdWriteHelperOptimizedCmpAndWriteAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = pIoCtx->pImage;
+    size_t cbThisWrite    = 0;
+    size_t cbPreRead      = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead     = pIoCtx->Type.Child.cbPostRead;
+    size_t cbWriteCopy    = pIoCtx->Type.Child.Write.Optimized.cbWriteCopy;
+    size_t cbFill         = pIoCtx->Type.Child.Write.Optimized.cbFill;
+    size_t cbReadImage    = pIoCtx->Type.Child.Write.Optimized.cbReadImage;
+    PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+    AssertPtr(pIoCtxParent);
+    Assert(!pIoCtx->cbTransferLeft && !pIoCtx->cMetaTransfersPending);
+
+    vdIoCtxChildReset(pIoCtx);
+    cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    RTSgBufAdvance(&pIoCtx->SgBuf, cbPreRead);
+
+    /* Check if the write would modify anything in this block. */
+    if (!RTSgBufCmp(&pIoCtx->SgBuf, &pIoCtxParent->SgBuf, cbThisWrite))
+    {
+        RTSGBUF SgBufSrcTmp;
+
+        RTSgBufClone(&SgBufSrcTmp, &pIoCtxParent->SgBuf);
+        RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
+        RTSgBufAdvance(&pIoCtx->SgBuf, cbThisWrite);
+
+        if (!cbWriteCopy || !RTSgBufCmp(&pIoCtx->SgBuf, &SgBufSrcTmp, cbWriteCopy))
+        {
+            /* Block is completely unchanged, so no need to write anything. */
+            LogFlowFunc(("Block didn't changed\n"));
+            ASMAtomicWriteU32(&pIoCtx->cbTransferLeft, 0);
+            return VINF_VD_ASYNC_IO_FINISHED;
+        }
+    }
+
+    /* Copy the data to the right place in the buffer. */
+    RTSgBufReset(&pIoCtx->SgBuf);
+    RTSgBufAdvance(&pIoCtx->SgBuf, cbPreRead);
+    vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
+
+    /* Handle the data that goes after the write to fill the block. */
+    if (cbPostRead)
+    {
+        /* Now assemble the remaining data. */
+        if (cbWriteCopy)
+            vdIoCtxCopy(pIoCtx, pIoCtxParent, cbWriteCopy);
+        /* Zero out the remainder of this block. Will never be visible, as this
+         * is beyond the limit of the image. */
+        if (cbFill)
+        {
+            RTSgBufAdvance(&pIoCtx->SgBuf, cbReadImage);
+            vdIoCtxSet(pIoCtx, '\0', cbFill);
+        }
+    }
+
+    /* Write the full block to the virtual disk. */
+    RTSgBufReset(&pIoCtx->SgBuf);
+    rc = pImage->Backend->pfnAsyncWrite(pImage->pvBackendData,
+                                        pIoCtx->uOffset - cbPreRead,
+                                        cbPreRead + pIoCtx->cbTransferLeft + cbPostRead,
+                                        pIoCtx, NULL, &cbPreRead, &cbPostRead, 0);
+    Assert(rc != VERR_VD_BLOCK_FREE);
+    Assert(cbPreRead == 0);
+    Assert(cbPostRead == 0);
+
+    return rc;
+}
+
+static int vdWriteHelperOptimizedPreReadAsync(PVDIOCTX pIoCtx)
+{
+    pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedCmpAndWriteAsync;
+    return vdReadHelperAsync(pIoCtx);
 }
 
@@ -1110 +1296 @@
  * All backends which support differential/growing images support this - async version.
  */
-static int vdWriteHelperOptimizedAsync(PVBOXHDD pDisk, PVDIMAGE pImage,
-                                       PVDIMAGE pImageParentOverride,
-                                       uint64_t uOffset, size_t cbWrite,
-                                       size_t cbThisWrite, size_t cbPreRead,
-                                       size_t cbPostRead, PVDIOCTX pIoCtxSrc,
-                                       PVDIOCTX pIoCtxDst)
-{
+static int vdWriteHelperOptimizedAsync(PVDIOCTX pIoCtx)
+{
+    PVBOXHDD pDisk = pIoCtx->pDisk;
+    uint64_t uOffset   = pIoCtx->Type.Child.uOffsetSaved;
+    size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    size_t cbPreRead   = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead  = pIoCtx->Type.Child.cbPostRead;
+    size_t cbWrite     = pIoCtx->Type.Child.Write.Optimized.cbWrite;
     size_t cbFill = 0;
     size_t cbWriteCopy = 0;
     size_t cbReadImage = 0;
     int rc;
+
+    AssertPtr(pIoCtx->pIoCtxParent);
 
     if (cbPostRead)
@@ -1139 +1328 @@
     }
 
+    pIoCtx->Type.Child.Write.Optimized.cbFill      = cbFill;
+    pIoCtx->Type.Child.Write.Optimized.cbWriteCopy = cbWriteCopy;
+    pIoCtx->Type.Child.Write.Optimized.cbReadImage = cbReadImage;
+
     /* Read the entire data of the block so that we can compare whether it will
      * be modified by the write or not. */
-    rc = vdReadHelperAsync(pDisk, pImage, pImageParentOverride, pIoCtxDst,
-                           uOffset - cbPreRead,
-                           cbPreRead + cbThisWrite + cbPostRead - cbFill);
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /** @todo Snapshots */
-    Assert(!pIoCtxDst->cbTransferLeft && !pIoCtxDst->cMetaTransfersPending);
-
-    vdIoCtxChildReset(pIoCtxDst);
-    RTSgBufAdvance(&pIoCtxDst->SgBuf, cbPreRead);
-
-    /* Check if the write would modify anything in this block. */
-    if (!RTSgBufCmp(&pIoCtxDst->SgBuf, &pIoCtxSrc->SgBuf, cbThisWrite))
-    {
-        RTSGBUF SgBufSrcTmp;
-
-        RTSgBufClone(&SgBufSrcTmp, &pIoCtxSrc->SgBuf);
-        RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
-        RTSgBufAdvance(&pIoCtxDst->SgBuf, cbThisWrite);
-
-        if (!cbWriteCopy || !RTSgBufCmp(&pIoCtxDst->SgBuf, &SgBufSrcTmp, cbWriteCopy))
-        {
-            /* Block is completely unchanged, so no need to write anything. */
-            LogFlowFunc(("Block didn't changed\n"));
-            ASMAtomicWriteU32(&pIoCtxDst->cbTransferLeft, 0);
-            return VINF_SUCCESS;
-        }
-    }
-
-    /* Copy the data to the right place in the buffer. */
-    RTSgBufReset(&pIoCtxDst->SgBuf);
-    RTSgBufAdvance(&pIoCtxDst->SgBuf, cbPreRead);
-    vdIoCtxCopy(pIoCtxDst, pIoCtxSrc, cbThisWrite);
-
-    /* Handle the data that goes after the write to fill the block. */
-    if (cbPostRead)
-    {
-        /* Now assemble the remaining data. */
-        if (cbWriteCopy)
-            vdIoCtxCopy(pIoCtxDst, pIoCtxSrc, cbWriteCopy);
-        /* Zero out the remainder of this block. Will never be visible, as this
-         * is beyond the limit of the image. */
-        if (cbFill)
-        {
-            RTSgBufAdvance(&pIoCtxDst->SgBuf, cbReadImage);
-            vdIoCtxSet(pIoCtxDst, '\0', cbFill);
-        }
-    }
-
-    /* Write the full block to the virtual disk. */
-    RTSgBufReset(&pIoCtxDst->SgBuf);
-    rc = pImage->Backend->pfnAsyncWrite(pImage->pvBackendData,
-                                        uOffset - cbPreRead,
-                                        cbPreRead + cbThisWrite + cbPostRead,
-                                        pIoCtxDst, NULL, &cbPreRead, &cbPostRead, 0);
-    Assert(rc != VERR_VD_BLOCK_FREE);
-    Assert(cbPreRead == 0);
-    Assert(cbPostRead == 0);
-
-    return rc;
+    pIoCtx->cbTransferLeft = cbPreRead + cbThisWrite + cbPostRead - cbFill;
+    pIoCtx->cbTransfer     = pIoCtx->cbTransferLeft;
+    pIoCtx->uOffset -= cbPreRead;
+
+    /* Next step */
+    pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedPreReadAsync;
+    return VINF_SUCCESS;
 }
 
@@ -1208 +1347 @@
  * write optimizations - async version.
  */
-static int vdWriteHelperAsync(PVBOXHDD pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
-                              PVDIOCTX pIoCtx, uint64_t uOffset, size_t cbWrite)
+static int vdWriteHelperAsync(PVDIOCTX pIoCtx)
 {
     int rc;
+    size_t cbWrite   = pIoCtx->cbTransfer;
+    uint64_t uOffset = pIoCtx->uOffset;
+    PVDIMAGE pImage  = pIoCtx->pImage;
+    PVBOXHDD pDisk   = pIoCtx->pDisk;
     unsigned fWrite;
     size_t cbThisWrite;
@@ -1235 +1377 @@
         {
             /*
-             * Allocate segment and buffer in one go.
-             * A bit hackish but avoids the need to allocate memory twice.
+             * If there is a growing request already put this one onto the waiting list.
+             * It will be restarted if the current request completes.
              */
-            PRTSGSEG pTmp = (PRTSGSEG)RTMemAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG));
-            AssertBreakStmt(VALID_PTR(pTmp), rc = VERR_NO_MEMORY);
-
-            pTmp->pvSeg = pTmp + 1;
-            pTmp->cbSeg = cbPreRead + cbThisWrite + cbPostRead;
-
-            PVDIOCTX pIoCtxWrite = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_WRITE,
-                                                     uOffset - cbPreRead, pTmp->cbSeg,
-                                                     pTmp, 1,
-                                                     pIoCtx, cbThisWrite,
-                                                     pTmp);
-            if (!VALID_PTR(pIoCtxWrite))
+            if (pDisk->fGrowing)
             {
-                RTMemTmpFree(pTmp);
-                rc = VERR_NO_MEMORY;
+                LogFlowFunc(("Deferring write pIoCtx=%#p\n", pIoCtx));
+                RTListAppend(&pDisk->ListWriteGrowing, &pIoCtx->NodeWriteGrowing);
+                Assert(pIoCtx->NodeWriteGrowing.pNext == &pDisk->ListWriteGrowing);
+                rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
                 break;
-            }
-
-            if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME))
-            {
-                /* Optimized write, suppress writing to a so far unallocated
-                 * block if the data is in fact not changed. */
-                rc = vdWriteHelperOptimizedAsync(pDisk, pImage, pImageParentOverride,
-                                                 uOffset, cbWrite,
-                                                 cbThisWrite, cbPreRead, cbPostRead,
-                                                 pIoCtx, pIoCtxWrite);
             }
             else
             {
-                /* Normal write, not optimized in any way. The block will
-                 * be written no matter what. This will usually (unless the
-                 * backend has some further optimization enabled) cause the
-                 * block to be allocated. */
-                rc = vdWriteHelperStandardAsync(pDisk, pImage, pImageParentOverride,
-                                                uOffset, cbWrite,
-                                                cbThisWrite, cbPreRead, cbPostRead,
-                                                pIoCtx, pIoCtxWrite);
+                /*
+                 * Allocate segment and buffer in one go.
+                 * A bit hackish but avoids the need to allocate memory twice.
+                 */
+                PRTSGSEG pTmp = (PRTSGSEG)RTMemAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG));
+                AssertBreakStmt(VALID_PTR(pTmp), rc = VERR_NO_MEMORY);
+
+                pTmp->pvSeg = pTmp + 1;
+                pTmp->cbSeg = cbPreRead + cbThisWrite + cbPostRead;
+
+                PVDIOCTX pIoCtxWrite = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_WRITE,
+                                                         uOffset, pTmp->cbSeg,
+                                                         pTmp, 1,
+                                                         pIoCtx, cbThisWrite,
+                                                         pTmp, 
+                                                           (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
+                                                         ? vdWriteHelperStandardAsync
+                                                         : vdWriteHelperOptimizedAsync);
+                if (!VALID_PTR(pIoCtxWrite))
+                {
+                    RTMemTmpFree(pTmp);
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                /* Set the state to growing. */
+                LogFlowFunc(("Disk is growing because of pIoCtx=%#p pIoCtxWrite=%#p\n",
+                             pIoCtx, pIoCtxWrite));
+                pDisk->fGrowing = true;
+
+                pIoCtxWrite->pImage                = pImage;
+                pIoCtxWrite->Type.Child.cbPreRead  = cbPreRead;
+                pIoCtxWrite->Type.Child.cbPostRead = cbPostRead;
+
+                /* Process the write request */
+                rc = vdIoCtxProcess(pIoCtxWrite);
+
+                if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
+                {
+                    vdIoCtxFree(pDisk, pIoCtxWrite);
+                    break;
+                }
+                else if (   rc == VINF_VD_ASYNC_IO_FINISHED
+                         && ASMAtomicCmpXchgBool(&pIoCtxWrite->fComplete, true, false))
+                {
+                    LogFlow(("Child write request completed\n"));
+                    Assert(pIoCtx->cbTransferLeft >= cbThisWrite);
+                    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisWrite);
+                    pDisk->fGrowing = false;
+                    vdIoCtxFree(pDisk, pIoCtxWrite);
+
+                    Assert(RTListIsEmpty(&pDisk->ListWriteGrowing));
+                    rc = VINF_SUCCESS;
+                }
+                else
+                    LogFlow(("Child write pending\n"));
             }
-
-            if (RT_FAILURE(rc))
-            {
-                vdIoCtxFree(pDisk, pIoCtxWrite);
-                break;
-            }
-
-            if (   !(pIoCtxWrite->cbTransferLeft || pIoCtxWrite->cMetaTransfersPending)
-                && ASMAtomicCmpXchgBool(&pIoCtxWrite->fComplete, true, false))
-            {
-                LogFlow(("Child write request completed\n"));
-                ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisWrite);
-                vdIoCtxFree(pDisk, pIoCtxWrite);
-            }
-            else
-                LogFlow(("Child write pending\n"));
-        }
-
-        if (RT_FAILURE(rc))
-            break;
+        }
 
         cbWrite -= cbThisWrite;
         uOffset += cbThisWrite;
     } while (cbWrite != 0 && RT_SUCCESS(rc));
+
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        /*
+         * Tell the caller that we don't need to go back here because all
+         * writes are initiated.
+         */
+        if (!cbWrite)
+            rc = VINF_SUCCESS;
+
+        pIoCtx->uOffset    = uOffset;
+        pIoCtx->cbTransfer = cbWrite;
+    }
+
+    return rc;
+}
+
+/**
+ * Flush helper async version.
+ */
+static int vdFlushHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDIMAGE pImage = pIoCtx->pImage;
+
+    vdResetModifiedFlag(pDisk);
+    rc = pImage->Backend->pfnAsyncFlush(pImage->pvBackendData, pIoCtx);
 
     return rc;
@@ -1556 +1736 @@
 static int vdIOReqCompleted(void *pvUser)
 {
+    int rc = VINF_SUCCESS;
     PVDIOTASK pIoTask = (PVDIOTASK)pvUser;
     PVDIOCTX  pIoCtx  = pIoTask->pIoCtx;
@@ -1567 +1748 @@
     else
     {
-        Assert(pIoTask->Type.Meta.enmTxDir == VDIOCTXTXDIR_WRITE);
         if (pIoTask->Type.Meta.pfnMetaComplete)
-            pIoTask->Type.Meta.pfnMetaComplete(NULL, pIoTask->Type.Meta.pvMetaUser);
+            pIoTask->Type.Meta.pfnMetaComplete(pIoTask->Type.Meta.pImage->pvBackendData,
+                                               pIoCtx,
+                                               pIoTask->Type.Meta.pvMetaUser);
         ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
     }
@@ -1575 +1757 @@
     vdIoTaskFree(pDisk, pIoTask);
 
-    if (   !pIoCtx->cbTransferLeft
-        && !pIoCtx->cMetaTransfersPending
+    /* Continue the transfer */
+    rc = vdIoCtxProcess(pIoCtx);
+
+    if (   rc == VINF_VD_ASYNC_IO_FINISHED
         && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
     {
-        LogFlowFunc(("I/O context completed\n"));
+        LogFlowFunc(("I/O context completed pIoCtx=%#p\n", pIoCtx));
         if (pIoCtx->pIoCtxParent)
         {
             PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+            LogFlowFunc(("I/O context transfered %u bytes for the parent pIoCtxParent=%p\n",
+                         pIoCtx->Type.Child.cbTransferParent, pIoCtxParent));
 
             /* Update the parent state. */
@@ -1589 +1776 @@
             ASMAtomicSubU32(&pIoCtxParent->cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
 
-            if (   !pIoCtxParent->cbTransferLeft
-                && !pIoCtxParent->cMetaTransfersPending
+            rc = vdIoCtxProcess(pIoCtxParent);
+
+            if (   rc == VINF_VD_ASYNC_IO_FINISHED
                 && ASMAtomicCmpXchgBool(&pIoCtxParent->fComplete, true, false))
             {
+                LogFlowFunc(("Parent I/O context completed pIoCtxParent=%#p\n", pIoCtx));
                 pIoCtxParent->Type.Root.pfnComplete(pIoCtxParent->Type.Root.pvUser1, pIoCtxParent->Type.Root.pvUser2);
                 vdIoCtxFree(pDisk, pIoCtxParent);
+
+                /*
+                 * A completed parent means that we finsihed growing the image.
+                 * We have to process any pending writes now.
+                 */
+                Assert(pDisk->fGrowing);
+
+                RTCritSectEnter(&pDisk->CritSect);
+
+                pDisk->fGrowing = false;
+
+                if (!RTListIsEmpty(&pDisk->ListWriteGrowing))
+                {
+                    RTLISTNODE ListTmp;
+                    PVDIOCTX pIoCtxWait;
+
+                    RTListMove(&ListTmp, &pDisk->ListWriteGrowing);
+
+                    RTCritSectLeave(&pDisk->CritSect);
+
+                    /* Process the list. */
+                    RTListForEach(&ListTmp, pIoCtxWait, VDIOCTX, NodeWriteGrowing)
+                    {
+                        Assert(!pIoCtxWait->pIoCtxParent);
+
+                        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));
+                            pIoCtxWait->Type.Root.pfnComplete(pIoCtxWait->Type.Root.pvUser1,
+                                                              pIoCtxWait->Type.Root.pvUser2);
+                            vdIoCtxFree(pDisk, pIoCtxWait);
+                        }
+                    }
+                }
+                else
+                    RTCritSectLeave(&pDisk->CritSect);
             }
         }
@@ -1613 +1842 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk          = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage         = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk          = pImage->pDisk;
     PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
 
@@ -1634 +1864 @@
 static int vdIOClose(void *pvUser, PVDIOSTORAGE pIoStorage)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     int rc = pDisk->pInterfaceAsyncIOCallbacks->pfnClose(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1647 +1878 @@
                        uint64_t *pcbSize)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnGetSize(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1657 +1889 @@
                        uint64_t cbSize)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnSetSize(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1667 +1900 @@
                          size_t cbWrite, const void *pvBuf, size_t *pcbWritten)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnWriteSync(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1678 +1912 @@
                         size_t cbRead, void *pvBuf, size_t *pcbRead)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnReadSync(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1688 +1923 @@
 static int vdIOFlushSync(void *pvUser, PVDIOSTORAGE pIoStorage)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
 
     return pDisk->pInterfaceAsyncIOCallbacks->pfnFlushSync(pDisk->pInterfaceAsyncIO->pvUser,
@@ -1699 +1935 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbRead=%u\n",
+                 pvUser, pIoStorage, uOffset, pIoCtx, cbRead));
 
     /* Build the S/G array and spawn a new I/O task */
@@ -1709 +1949 @@
 
         cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->SgBuf, aSeg, &cSegments, cbRead);
+
+        AssertMsg(cbTaskRead <= cbRead, ("Invalid number of bytes to read\n"));
+
+        LogFlow(("Reading %u bytes into %u segments\n", cbTaskRead, cSegments));
+
+#ifdef DEBUG
+        for (unsigned i = 0; i < cSegments; i++)
+                AssertMsg(aSeg[i].pvSeg && !(aSeg[i].cbSeg % 512),
+                          ("Segment %u is invalid\n", i));
+#endif
 
         PVDIOTASK pIoTask = vdIoTaskUserAlloc(pDisk, pIoCtx, cbTaskRead);
@@ -1747 +1997 @@
 {
     int rc = VINF_SUCCESS;
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbWrite=%u\n",
+                 pvUser, pIoStorage, uOffset, pIoCtx, cbWrite));
 
     /* Build the S/G array and spawn a new I/O task */
@@ -1757 +2011 @@
 
         cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->SgBuf, aSeg, &cSegments, cbWrite);
+
+        AssertMsg(cbTaskWrite <= cbWrite, ("Invalid number of bytes to write\n"));
+
+        LogFlow(("Writing %u bytes from %u segments\n", cbTaskWrite, cSegments));
+
+#ifdef DEBUG
+        for (unsigned i = 0; i < cSegments; i++)
+                AssertMsg(aSeg[i].pvSeg && !(aSeg[i].cbSeg % 512),
+                          ("Segment %u is invalid\n", i));
+#endif
 
         PVDIOTASK pIoTask = vdIoTaskUserAlloc(pDisk, pIoCtx, cbTaskWrite);
@@ -1796 +2060 @@
                              void *pvMetaUser)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
     int rc = VINF_SUCCESS;
     RTSGSEG Seg;
@@ -1802 +2067 @@
     void *pvTask = NULL;
 
-    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_READ,
+    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_READ, pImage,
                                 pfnMetaComplete, pvMetaUser);
     if (!pIoTask)
@@ -1836 +2101 @@
                               void *pvMetaUser)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
     int rc = VINF_SUCCESS;
     RTSGSEG Seg;
@@ -1842 +2108 @@
     void *pvTask = NULL;
 
-    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_WRITE,
+    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_WRITE, pImage,
                                 pfnMetaComplete, pvMetaUser);
     if (!pIoTask)
@@ -1873 +2139 @@
                           PVDIOCTX pIoCtx)
 {
-    PVBOXHDD pDisk = (PVBOXHDD)pvUser;
+    PVDIMAGE pImage = (PVDIMAGE)pvUser;
+    PVBOXHDD pDisk  = pImage->pDisk;
     int rc = VINF_SUCCESS;
     PVDIOTASK pIoTask;
     void *pvTask = NULL;
 
-    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_FLUSH,
+    pIoTask = vdIoTaskMetaAlloc(pDisk, pIoCtx, VDIOCTXTXDIR_FLUSH, pImage,
                                 NULL, NULL);
     if (!pIoTask)
@@ -2172 +2439 @@
             pDisk->pInterfaceThreadSync = NULL;
             pDisk->pInterfaceThreadSyncCallbacks = NULL;
+            pDisk->fGrowing = false;
+            RTListInit(&pDisk->ListWriteGrowing);
 
             /* Create the I/O ctx cache */
@@ -2192 +2461 @@
             }
 
+            /* Create critical section. */
+            rc = RTCritSectInit(&pDisk->CritSect);
+            if (RT_FAILURE(rc))
+            {
+                RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+                RTMemCacheDestroy(pDisk->hMemCacheIoTask);
+                RTMemFree(pDisk);
+                break;
+            }
 
             pDisk->pInterfaceError = VDInterfaceGet(pVDIfsDisk, VDINTERFACETYPE_ERROR);
@@ -2247 +2525 @@
             pDisk->VDIIOCallbacks.pfnIoCtxCopyTo    = vdIOIoCtxCopyTo;
             pDisk->VDIIOCallbacks.pfnIoCtxSet       = vdIOIoCtxSet;
-
-            /* Set up the I/O interface. */
-            rc = VDInterfaceAdd(&pDisk->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
-                                &pDisk->VDIIOCallbacks, pDisk, &pDisk->pVDIfsDisk);
-            AssertRC(rc);
 
             *ppDisk = pDisk;
@@ -2436 +2709 @@
         }
 
+        pImage->pDisk       = pDisk;
         pImage->pVDIfsImage = pVDIfsImage;
 
@@ -2447 +2721 @@
             break;
         }
+
+        /* Set up the I/O interface. */
+        rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
+                            &pDisk->VDIIOCallbacks, pImage, &pImage->pVDIfsImage);
+        AssertRC(rc);
 
         pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
@@ -2718 +2997 @@
             break;
         }
+        pImage->pDisk       = pDisk;
         pImage->pVDIfsImage = pVDIfsImage;
+
+        /* Set up the I/O interface. */
+        rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
+                            &pDisk->VDIIOCallbacks, pImage, &pImage->pVDIfsImage);
+        AssertRC(rc);
 
         rc = vdFindBackend(pszBackend, &pImage->Backend);
@@ -2961 +3246 @@
             break;
         }
+
+        pImage->pDisk       = pDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+
+        /* Set up the I/O interface. */
+        rc = VDInterfaceAdd(&pImage->VDIIO, "VD_IO", VDINTERFACETYPE_IO,
+                            &pDisk->VDIIOCallbacks, pImage, &pImage->pVDIfsImage);
+        AssertRC(rc);
 
         /* Create UUID if the caller didn't specify one. */
@@ -5608 +5901 @@
                                   cbRead, paSeg, cSeg,
                                   pfnComplete, pvUser1, pvUser2,
-                                  NULL);
+                                  NULL, vdReadHelperAsync);
         if (!pIoCtx)
         {
@@ -5615 +5908 @@
         }
 
-        PVDIMAGE pImage = pDisk->pLast;
-        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
-
-        rc = vdReadHelperAsync(pDisk, pImage, NULL, pIoCtx, uOffset, cbRead);
+        pIoCtx->pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pIoCtx->pImage, rc = VERR_VD_NOT_OPENED);
+
+        rc = vdIoCtxProcess(pIoCtx);
+        if (rc == VINF_VD_ASYNC_IO_FINISHED)
+        {
+            if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
+                vdIoCtxFree(pDisk, pIoCtx);
+            else
+                rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
+        }
+        else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
+            vdIoCtxFree(pDisk, pIoCtx);
+
     } while (0);
 
-    if (RT_UNLIKELY(fLockRead))
+    if (RT_UNLIKELY(fLockRead) && (rc != VINF_VD_ASYNC_IO_FINISHED))
     {
         rc2 = vdThreadFinishRead(pDisk);
         AssertRC(rc2);
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        if (   !pIoCtx->cbTransferLeft
-            && !pIoCtx->cMetaTransfersPending
-            && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
-        {
-            vdIoCtxFree(pDisk, pIoCtx);
-            rc = VINF_VD_ASYNC_IO_FINISHED;
-        }
-        else
-        {
-            LogFlow(("cbTransferLeft=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
-                     pIoCtx->cbTransferLeft, pIoCtx->cMetaTransfersPending,
-                     pIoCtx->fComplete));
-            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
-        }
     }
 
@@ -5691 +5976 @@
                                   cbWrite, paSeg, cSeg,
                                   pfnComplete, pvUser1, pvUser2,
-                                  NULL);
+                                  NULL, vdWriteHelperAsync);
         if (!pIoCtx)
         {
@@ -5700 +5985 @@
         PVDIMAGE pImage = pDisk->pLast;
         AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
-
-        rc = vdWriteHelperAsync(pDisk, pImage, NULL, pIoCtx, uOffset, cbWrite);
-
+        pIoCtx->pImage = pImage;
+
+        rc = vdIoCtxProcess(pIoCtx);
+        if (rc == VINF_VD_ASYNC_IO_FINISHED)
+        {
+            if (ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
+                vdIoCtxFree(pDisk, pIoCtx);
+            else
+                rc = VERR_VD_ASYNC_IO_IN_PROGRESS; /* Let the other handler complete the request. */
+        }
+        else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS) /* Another error */
+            vdIoCtxFree(pDisk, pIoCtx);
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite) && RT_FAILURE(rc))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDAsyncFlush(PVBOXHDD pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                               void *pvUser1, void *pvUser2)
+{
+    int rc;
+    int rc2;
+    bool fLockWrite = false;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
+                                  0, NULL, 0,
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL, vdFlushHelperAsync);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        PVDIMAGE pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
+        pIoCtx->pImage = pImage;
+
+        rc = vdIoCtxProcess(pIoCtx);
     } while (0);
 
@@ -5733 +6075 @@
 }
 
-
-VBOXDDU_DECL(int) VDAsyncFlush(PVBOXHDD pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
-                               void *pvUser1, void *pvUser2)
-{
-    int rc;
-    int rc2;
-    bool fLockWrite = false;
-    PVDIOCTX pIoCtx = NULL;
-
-    LogFlowFunc(("pDisk=%#p\n", pDisk));
-
-    do
-    {
-        /* sanity check */
-        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
-        AssertMsg(pDisk->u32Signature == VBOXHDDDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
-
-        rc2 = vdThreadStartWrite(pDisk);
-        AssertRC(rc2);
-        fLockWrite = true;
-
-        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
-                                  0, NULL, 0,
-                                  pfnComplete, pvUser1, pvUser2,
-                                  NULL);
-        if (!pIoCtx)
-        {
-            rc = VERR_NO_MEMORY;
-            break;
-        }
-
-        PVDIMAGE pImage = pDisk->pLast;
-        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
-
-        vdResetModifiedFlag(pDisk);
-        rc = pImage->Backend->pfnAsyncFlush(pImage->pvBackendData, pIoCtx);
-    } while (0);
-
-    if (RT_UNLIKELY(fLockWrite) && RT_FAILURE(rc))
-    {
-        rc2 = vdThreadFinishWrite(pDisk);
-        AssertRC(rc2);
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        if (   !pIoCtx->cbTransferLeft
-            && !pIoCtx->cMetaTransfersPending
-            && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
-        {
-            vdIoCtxFree(pDisk, pIoCtx);
-            rc = VINF_VD_ASYNC_IO_FINISHED;
-        }
-        else
-        {
-            LogFlow(("cbTransferLeft=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
-                     pIoCtx->cbTransferLeft, pIoCtx->cMetaTransfersPending,
-                     pIoCtx->fComplete));
-            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
-        }
-    }
-
-    LogFlowFunc(("returns %Rrc\n", rc));
-    return rc;
-}
-
 #if 0
 /** @copydoc VBOXHDDBACKEND::pfnComposeLocation */

trunk/src/VBox/Devices/Storage/VDICore.h

@@ -586 +586 @@
     /** Pointer to the per-disk VD interface list. */
     PVDINTERFACE            pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE            pVDIfsImage;
     /** Error interface. */
     PVDINTERFACE            pInterfaceError;

trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp

@@ -541 +541 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -727 +727 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -1071 +1071 @@
     pImage->paBlocks = NULL;
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = vdiOpenImage(pImage, uOpenFlags);
@@ -1149 +1150 @@
     pImage->paBlocks = NULL;
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = vdiCreateImage(pImage, cbSize, uImageFlags, pszComment,

trunk/src/VBox/Devices/Storage/VHDHDDCore.cpp

@@ -144 +144 @@
     /** Pointer to the per-disk VD interface list. */
     PVDINTERFACE      pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE      pVDIfsImage;
     /** Error interface. */
     PVDINTERFACE      pInterfaceError;
@@ -581 +583 @@
 #ifdef VBOX_WITH_NEW_IO_CODE
     /* Try to get async I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     AssertPtr(pImage->pInterfaceIO);
     pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -684 +686 @@
 #endif
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = vhdOpenImage(pImage, uOpenFlags);
@@ -1972 +1975 @@
 #endif
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
 #ifdef VBOX_WITH_NEW_IO_CODE

trunk/src/VBox/Devices/Storage/VmdkHDDCore.cpp

@@ -423 +423 @@
     /** Pointer to the per-disk VD interface list. */
     PVDINTERFACE    pVDIfsDisk;
+    /** Pointer to the per-image VD interface list. */
+    PVDINTERFACE    pVDIfsImage;
 
     /** Error interface. */
@@ -786 +788 @@
     if (pVmdkFile->fAsyncIO)
         return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
-                                                                pVmdkFile->pStorage);
+                                                           pVmdkFile->pStorage);
     else
         return RTFileFlush(pVmdkFile->File);
 #else
     return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
-                                                            pVmdkFile->pStorage);
+                                                       pVmdkFile->pStorage);
 #endif
+}
+
+
+DECLINLINE(int) vmdkFileFlushAsync(PVMDKFILE pVmdkFile, PVDIOCTX pIoCtx)
+{
+    PVMDKIMAGE pImage = pVmdkFile->pImage;
+
+    return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
+                                                        pVmdkFile->pStorage, pIoCtx);
 }
 
@@ -2536 +2547 @@
 
 /**
+ * Internal: write/update the descriptor part of the image - async version.
+ */
+static int vmdkWriteDescriptorAsync(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    uint64_t cbLimit;
+    uint64_t uOffset;
+    PVMDKFILE pDescFile;
+
+    if (pImage->pDescData)
+    {
+        /* Separate descriptor file. */
+        uOffset = 0;
+        cbLimit = 0;
+        pDescFile = pImage->pFile;
+    }
+    else
+    {
+        /* Embedded descriptor file. */
+        uOffset = VMDK_SECTOR2BYTE(pImage->pExtents[0].uDescriptorSector);
+        cbLimit = VMDK_SECTOR2BYTE(pImage->pExtents[0].cDescriptorSectors);
+        pDescFile = pImage->pExtents[0].pFile;
+    }
+    /* Bail out if there is no file to write to. */
+    if (pDescFile == NULL)
+        return VERR_INVALID_PARAMETER;
+
+    /*
+     * Allocate temporary descriptor buffer.
+     * In case there is no limit allocate a default
+     * and increase if required.
+     */
+    size_t cbDescriptor = cbLimit ? cbLimit : 4 * _1K;
+    char *pszDescriptor = (char *)RTMemAllocZ(cbDescriptor);
+    unsigned offDescriptor = 0;
+
+    if (!pszDescriptor)
+        return VERR_NO_MEMORY;
+
+    for (unsigned i = 0; i < pImage->Descriptor.cLines; i++)
+    {
+        const char *psz = pImage->Descriptor.aLines[i];
+        size_t cb = strlen(psz);
+
+        /*
+         * Increase the descriptor if there is no limit and
+         * there is not enough room left for this line.
+         */
+        if (offDescriptor + cb + 1 > cbDescriptor)
+        {
+            if (cbLimit)
+            {
+                rc = vmdkError(pImage, VERR_BUFFER_OVERFLOW, RT_SRC_POS, N_("VMDK: descriptor too long in '%s'"), pImage->pszFilename);
+                break;
+            }
+            else
+            {
+                char *pszDescriptorNew = NULL;
+                LogFlow(("Increasing descriptor cache\n"));
+
+                pszDescriptorNew = (char *)RTMemRealloc(pszDescriptor, cbDescriptor + cb + 4 * _1K);
+                if (!pszDescriptorNew)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+                pszDescriptorNew = pszDescriptor;
+                cbDescriptor += cb + 4 * _1K;
+            }
+        }
+
+        if (cb > 0)
+        {
+            memcpy(pszDescriptor + offDescriptor, psz, cb);
+            offDescriptor += cb;
+        }
+
+        memcpy(pszDescriptor + offDescriptor, "\n", 1);
+        offDescriptor++;
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        rc = vmdkFileWriteAt(pDescFile, uOffset, pszDescriptor, cbLimit ? cbLimit : offDescriptor, NULL);
+        if (RT_FAILURE(rc))
+            rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error writing descriptor in '%s'"), pImage->pszFilename);
+    }
+
+    if (RT_SUCCESS(rc) && !cbLimit)
+    {
+        rc = vmdkFileSetSize(pDescFile, offDescriptor);
+        if (RT_FAILURE(rc))
+            rc = vmdkError(pImage, rc, RT_SRC_POS, N_("VMDK: error truncating descriptor in '%s'"), pImage->pszFilename);
+    }
+
+    if (RT_SUCCESS(rc))
+        pImage->Descriptor.fDirty = false;
+
+    RTMemFree(pszDescriptor);
+    return rc;
+}
+
+/**
  * Internal: validate the consistency check values in a binary header.
  */
@@ -2974 +3088 @@
 
     /* Try to get async I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     if (pImage->pInterfaceIO)
         pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -3843 +3957 @@
 
     /* Try to get async I/O interface. */
-    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_IO);
+    pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IO);
     if (pImage->pInterfaceIO)
         pImage->pInterfaceIOCallbacks = VDGetInterfaceIO(pImage->pInterfaceIO);
@@ -4117 +4231 @@
                     && !(pExtent->pszBasename[0] == RTPATH_SLASH))
                     rc = vmdkFileFlush(pExtent->pFile);
+                break;
+            case VMDKETYPE_ZERO:
+                /* No need to do anything for this extent. */
+                break;
+            default:
+                AssertMsgFailed(("unknown extent type %d\n", pExtent->enmType));
+                break;
+        }
+    }
+
+out:
+    return rc;
+}
+
+/**
+ * Internal. Flush image data (and metadata) to disk - async version.
+ */
+static int vmdkFlushImageAsync(PVMDKIMAGE pImage, PVDIOCTX pIoCtx)
+{
+    PVMDKEXTENT pExtent;
+    int rc = VINF_SUCCESS;
+
+    /* Update descriptor if changed. */
+    if (pImage->Descriptor.fDirty)
+    {
+        rc = vmdkWriteDescriptor(pImage);
+        if (RT_FAILURE(rc))
+            goto out;
+    }
+
+    for (unsigned i = 0; i < pImage->cExtents; i++)
+    {
+        pExtent = &pImage->pExtents[i];
+        if (pExtent->pFile != NULL && pExtent->fMetaDirty)
+        {
+            switch (pExtent->enmType)
+            {
+                case VMDKETYPE_HOSTED_SPARSE:
+                    AssertMsgFailed(("Async I/O not supported for sparse images\n"));
+                    break;
+#ifdef VBOX_WITH_VMDK_ESX
+                case VMDKETYPE_ESX_SPARSE:
+                    /** @todo update the header. */
+                    break;
+#endif /* VBOX_WITH_VMDK_ESX */
+                case VMDKETYPE_VMFS:
+                case VMDKETYPE_FLAT:
+                    /* Nothing to do. */
+                    break;
+                case VMDKETYPE_ZERO:
+                default:
+                    AssertMsgFailed(("extent with type %d marked as dirty\n",
+                                     pExtent->enmType));
+                    break;
+            }
+        }
+        switch (pExtent->enmType)
+        {
+            case VMDKETYPE_HOSTED_SPARSE:
+#ifdef VBOX_WITH_VMDK_ESX
+            case VMDKETYPE_ESX_SPARSE:
+#endif /* VBOX_WITH_VMDK_ESX */
+            case VMDKETYPE_VMFS:
+            case VMDKETYPE_FLAT:
+                /** @todo implement proper path absolute check. */
+                if (   pExtent->pFile != NULL
+                    && !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                    && !(pExtent->pszBasename[0] == RTPATH_SLASH))
+                    rc = vmdkFileFlushAsync(pExtent->pFile, pIoCtx);
                 break;
             case VMDKETYPE_ZERO:
@@ -4522 +4705 @@
     pImage->pDescData = NULL;
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsDisk;
     /** @todo speed up this test open (VD_OPEN_FLAGS_INFO) by skipping as
      * much as possible in vmdkOpenImage. */
@@ -4572 +4756 @@
     pImage->pDescData = NULL;
     pImage->pVDIfsDisk = pVDIfsDisk;
+    pImage->pVDIfsImage = pVDIfsImage;
 
     rc = vmdkOpenImage(pImage, uOpenFlags);