Changeset 44242 in vbox for trunk/src/VBox/Storage

Timestamp:

Jan 7, 2013 8:19:15 PM (12 years ago)

Author:

vboxsync

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

83098

Message:

Storage: Next step in the sync/async I/O unification, change all calls to pfnRead/pfnWrite/pfnFlush to pfnAsyncRead/pfnAsyncWrite/pfnFlush

Location:

trunk/src/VBox/Storage

Files:

• ISCSI.cpp (modified) (4 diffs)
• VD.cpp (modified) (57 diffs)
• VDI.cpp (modified) (1 diff)

trunk/src/VBox/Storage/ISCSI.cpp

@@ -5280 +5280 @@
                           PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
 {
+    PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
+    int rc = VINF_SUCCESS;
+
     LogFlowFunc(("pBackendData=%p uOffset=%#llx pIoCtx=%#p cbToRead=%u pcbActuallyRead=%p\n",
                  pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
-    PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
-    int rc = VINF_SUCCESS;
-
-    if (uOffset + cbToRead > pImage->cbSize)
+
+    if (   uOffset + cbToRead > pImage->cbSize
+        || cbToRead == 0)
         return VERR_INVALID_PARAMETER;
 
@@ -5292 +5294 @@
      */
     cbToRead = RT_MIN(cbToRead, pImage->cbRecvDataLength);
+
+    /** @todo: Remove iscsiRead and integrate properly. */
+    if (vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx))
+    {
+        RTSGSEG Segment;
+        unsigned cSegments = 1;
+        size_t cbSegs;
+
+        cbSegs = pImage->pIfIo->pfnIoCtxSegArrayCreate(pImage->pIfIo->Core.pvUser, pIoCtx,
+                                                       &Segment, &cSegments, cbToRead);
+        Assert(cbSegs == cbToRead);
+
+        return iscsiRead(pBackendData, uOffset, Segment.pvSeg, cbToRead, pcbActuallyRead);
+    }
 
     unsigned cT2ISegs = 0;
@@ -5418 +5434 @@
     cbToWrite = RT_MIN(cbToWrite, pImage->cbSendDataLength);
 
+    /** @todo: Remove iscsiWrite and integrate properly. */
+    if (vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx))
+    {
+        RTSGSEG Segment;
+        unsigned cSegments = 1;
+        size_t cbSegs;
+
+        cbSegs = pImage->pIfIo->pfnIoCtxSegArrayCreate(pImage->pIfIo->Core.pvUser, pIoCtx,
+                                                       &Segment, &cSegments, cbToWrite);
+        Assert(cbSegs == cbToWrite);
+
+        return iscsiWrite(pBackendData, uOffset, Segment.pvSeg, cbToWrite,
+                          pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
+    }
+
     unsigned cI2TSegs = 0;
     size_t   cbSegs = 0;
@@ -5526 +5557 @@
     PISCSIIMAGE pImage = (PISCSIIMAGE)pBackendData;
     int rc = VINF_SUCCESS;
+
+    /** @todo: Remove iscsiFlush and integrate properly. */
+    if (vdIfIoIntIoCtxIsSynchronous(pImage->pIfIo, pIoCtx))
+        return iscsiFlush(pBackendData);
 
     PSCSIREQASYNC pReqAsync = (PSCSIREQASYNC)RTMemAllocZ(sizeof(SCSIREQASYNC));

trunk/src/VBox/Storage/VD.cpp

@@ -306 +306 @@
     /** Return code. */
     int                          rcReq;
-    /** Flag whether the I/O context is blocked because it is in the growing list. */
-    bool                         fBlocked;
+    /** Various flags for the I/O context. */
+    uint32_t                     fFlags;
     /** Number of data transfers currently pending. */
     volatile uint32_t            cDataTransfersPending;
@@ -410 +410 @@
 } VDIOCTX;
 
+/** Flag whether the context is blocked. */
+#define VDIOCTX_FLAGS_BLOCKED RT_BIT_32(0)
+/** Flag whether the I/O context is using synchronous I/O. */
+#define VDIOCTX_FLAGS_SYNC    RT_BIT_32(1)
+
 /**
  * List node for deferred I/O contexts.
@@ -763 +768 @@
     }
     return pImage;
+}
+
+/**
+ * Initialize the structure members of a given I/O context.
+ */
+DECLINLINE(void) vdIoCtxInit(PVDIOCTX pIoCtx, PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
+                             uint64_t uOffset, size_t cbTransfer, PVDIMAGE pImageStart,
+                             PCRTSGBUF pcSgBuf, void *pvAllocation,
+                             PFNVDIOCTXTRANSFER pfnIoCtxTransfer, uint32_t fFlags)
+{
+    pIoCtx->pDisk                 = pDisk;
+    pIoCtx->enmTxDir              = enmTxDir;
+    pIoCtx->Req.Io.cbTransferLeft = cbTransfer;
+    pIoCtx->Req.Io.uOffset        = uOffset;
+    pIoCtx->Req.Io.cbTransfer     = cbTransfer;
+    pIoCtx->Req.Io.pImageStart    = pImageStart;
+    pIoCtx->Req.Io.pImageCur      = pImageStart;
+    pIoCtx->cDataTransfersPending = 0;
+    pIoCtx->cMetaTransfersPending = 0;
+    pIoCtx->fComplete             = false;
+    pIoCtx->fFlags                = fFlags;
+    pIoCtx->pvAllocation          = pvAllocation;
+    pIoCtx->pfnIoCtxTransfer      = pfnIoCtxTransfer;
+    pIoCtx->pfnIoCtxTransferNext  = NULL;
+    pIoCtx->rcReq                 = VINF_SUCCESS;
+
+    /* There is no S/G list for a flush request. */
+    if (   enmTxDir != VDIOCTXTXDIR_FLUSH
+        && enmTxDir != VDIOCTXTXDIR_DISCARD)
+        RTSgBufClone(&pIoCtx->Req.Io.SgBuf, pcSgBuf);
+    else
+        memset(&pIoCtx->Req.Io.SgBuf, 0, sizeof(RTSGBUF));
 }
 
@@ -794 +831 @@
     AssertPtr(pcbRead);
 
+#if 0 /** @todo: Cache implementation update */
     rc = pCache->Backend->pfnRead(pCache->pBackendData, uOffset, pvBuf,
                                   cbRead, pcbRead);
+#endif
 
     LogFlowFunc(("returns rc=%Rrc pcbRead=%zu\n", rc, *pcbRead));
@@ -823 +862 @@
     Assert(cbWrite > 0);
 
+#if 0 /** @todo: Change cache implementation */
     if (pcbWritten)
         rc = pCache->Backend->pfnWrite(pCache->pBackendData, uOffset, pcvBuf,
@@ -840 +880 @@
                  && RT_SUCCESS(rc));
     }
+#endif
 
     LogFlowFunc(("returns rc=%Rrc pcbWritten=%zu\n",
@@ -854 +895 @@
     int rc = VINF_SUCCESS;
     size_t cbThisRead = cbRead;
+    RTSGSEG SegmentBuf;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
 
     AssertPtr(pcbThisRead);
 
     *pcbThisRead = 0;
+
+    SegmentBuf.pvSeg = pvBuf;
+    SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
+    RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+    vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
+                &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
 
     /*
@@ -863 +913 @@
      * If the block is not allocated read from override chain if present.
      */
-    rc = pImage->Backend->pfnRead(pImage->pBackendData,
-                                  uOffset, pvBuf, cbThisRead,
-                                  &cbThisRead);
+    rc = pImage->Backend->pfnAsyncRead(pImage->pBackendData,
+                                       uOffset, cbThisRead, &IoCtx,
+                                       &cbThisRead);
 
     if (rc == VERR_VD_BLOCK_FREE)
@@ -873 +923 @@
              pCurrImage = pCurrImage->pPrev)
         {
-            rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
-                                              uOffset, pvBuf, cbThisRead,
-                                              &cbThisRead);
+            rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pBackendData,
+                                                   uOffset, cbThisRead, &IoCtx,
+                                                   &cbThisRead);
         }
     }
@@ -949 +999 @@
         else
         {
-            /** @todo can be be replaced by vdDiskReadHelper if it proves to be reliable,
-             * don't want to be responsible for data corruption...
-             */
+            RTSGSEG SegmentBuf;
+            RTSGBUF SgBuf;
+            VDIOCTX IoCtx;
+
+            SegmentBuf.pvSeg = pvBuf;
+            SegmentBuf.cbSeg = cbThisRead;
+            RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+            vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
+                        &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+
             /*
              * Try to read from the given image.
              * If the block is not allocated read from override chain if present.
              */
-            rc = pImage->Backend->pfnRead(pImage->pBackendData,
-                                          uOffset, pvBuf, cbThisRead,
-                                          &cbThisRead);
+            rc = pImage->Backend->pfnAsyncRead(pImage->pBackendData,
+                                               uOffset, cbThisRead, &IoCtx,
+                                               &cbThisRead);
 
             if (   rc == VERR_VD_BLOCK_FREE
@@ -969 +1026 @@
                      pCurrImage = pCurrImage->pPrev)
                 {
-                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
-                                                      uOffset, pvBuf, cbThisRead,
-                                                      &cbThisRead);
+                    rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pBackendData,
+                                                           uOffset, cbThisRead,
+                                                           &IoCtx, &cbThisRead);
                     if (cImagesToProcess == 1)
                         break;
@@ -1100 +1157 @@
                     cbThis = (idxEnd - idxStart) * 512;
 
-                rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, offStart,
-                                                       cbThis, NULL, NULL, &cbThis,
-                                                       NULL, VD_DISCARD_MARK_UNUSED);
+
+                VDIOCTX IoCtx;
+                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
+                            NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+                rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData,
+                                                            &IoCtx, offStart, cbThis, NULL,
+                                                            NULL, &cbThis, NULL,
+                                                            VD_DISCARD_MARK_UNUSED);
                 if (RT_FAILURE(rc))
                     break;
@@ -1190 +1252 @@
 
             /* No block found, try to discard using the backend first. */
-            rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, offStart,
-                                                   cbThisDiscard, &cbPreAllocated,
-                                                   &cbPostAllocated, &cbThisDiscard,
-                                                   &pbmAllocated, 0);
+            VDIOCTX IoCtx;
+
+            vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
+                        NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+            rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData,
+                                                        &IoCtx, offStart,
+                                                        cbThisDiscard, &cbPreAllocated,
+                                                        &cbPostAllocated, &cbThisDiscard,
+                                                        &pbmAllocated, 0);
             if (rc == VERR_VD_DISCARD_ALIGNMENT_NOT_MET)
             {
@@ -1241 +1308 @@
             if (ASMBitFirstSet((volatile void *)pBlock->pbmAllocated, pBlock->cbDiscard / 512) == -1)
             {
+                VDIOCTX IoCtx;
                 size_t cbPreAllocated, cbPostAllocated, cbActuallyDiscarded;
 
-                rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData, pBlock->Core.Key,
-                                                       pBlock->cbDiscard, &cbPreAllocated,
-                                                       &cbPostAllocated, &cbActuallyDiscarded,
-                                                       NULL, 0);
+                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
+                            NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+                rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData,
+                                                            &IoCtx, pBlock->Core.Key,
+                                                            pBlock->cbDiscard, &cbPreAllocated,
+                                                            &cbPostAllocated, &cbActuallyDiscarded,
+                                                            NULL, 0);
                 Assert(rc != VERR_VD_DISCARD_ALIGNMENT_NOT_MET);
                 Assert(!cbPreAllocated);
@@ -1369 +1440 @@
 DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
                                   uint64_t uOffset, size_t cbTransfer,
-                                  PVDIMAGE pImageStart,
-                                  PCRTSGBUF pcSgBuf, void *pvAllocation,
-                                  PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
+                                  PVDIMAGE pImageStart,PCRTSGBUF pcSgBuf,
+                                  void *pvAllocation, PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
+                                  uint32_t fFlags)
 {
     PVDIOCTX pIoCtx = NULL;
@@ -1378 +1449 @@
     if (RT_LIKELY(pIoCtx))
     {
-        pIoCtx->pDisk                 = pDisk;
-        pIoCtx->enmTxDir              = enmTxDir;
-        pIoCtx->Req.Io.cbTransferLeft = cbTransfer;
-        pIoCtx->Req.Io.uOffset        = uOffset;
-        pIoCtx->Req.Io.cbTransfer     = cbTransfer;
-        pIoCtx->Req.Io.pImageStart    = pImageStart;
-        pIoCtx->Req.Io.pImageCur      = pImageStart;
-        pIoCtx->cDataTransfersPending = 0;
-        pIoCtx->cMetaTransfersPending = 0;
-        pIoCtx->fComplete             = false;
-        pIoCtx->fBlocked              = false;
-        pIoCtx->pvAllocation          = pvAllocation;
-        pIoCtx->pfnIoCtxTransfer      = pfnIoCtxTransfer;
-        pIoCtx->pfnIoCtxTransferNext  = NULL;
-        pIoCtx->rcReq                 = VINF_SUCCESS;
-
-        /* There is no S/G list for a flush request. */
-        if (enmTxDir != VDIOCTXTXDIR_FLUSH)
-            RTSgBufClone(&pIoCtx->Req.Io.SgBuf, pcSgBuf);
-        else
-            memset(&pIoCtx->Req.Io.SgBuf, 0, sizeof(RTSGBUF));
+        vdIoCtxInit(pIoCtx, pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
+                    pcSgBuf, pvAllocation, pfnIoCtxTransfer, fFlags);
     }
 
@@ -1413 +1465 @@
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
-                                   pcSgBuf, pvAllocation, pfnIoCtxTransfer);
+                                   pcSgBuf, pvAllocation, pfnIoCtxTransfer, 0);
 
     if (RT_LIKELY(pIoCtx))
@@ -1445 +1497 @@
         pIoCtx->cMetaTransfersPending     = 0;
         pIoCtx->fComplete                 = false;
-        pIoCtx->fBlocked                  = false;
+        pIoCtx->fFlags                    = 0;
         pIoCtx->pvAllocation              = pvAllocation;
         pIoCtx->pfnIoCtxTransfer          = pfnIoCtxTransfer;
@@ -1475 +1527 @@
 {
     PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
-                                   pcSgBuf, pvAllocation, pfnIoCtxTransfer);
+                                   pcSgBuf, pvAllocation, pfnIoCtxTransfer, 0);
 
     AssertPtr(pIoCtxParent);
@@ -1579 +1631 @@
     LogFlowFunc(("Deferring write pIoCtx=%#p\n", pIoCtx));
 
-    Assert(!pIoCtx->pIoCtxParent && !pIoCtx->fBlocked);
+    Assert(!pIoCtx->pIoCtxParent && !(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED));
 
     RTListInit(&pDeferred->NodeDeferred);
     pDeferred->pIoCtx = pIoCtx;
     RTListAppend(&pDisk->ListWriteLocked, &pDeferred->NodeDeferred);
-    pIoCtx->fBlocked = true;
+    pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
     return VINF_SUCCESS;
 }
@@ -1651 +1703 @@
     /* Don't change anything if there is a metadata transfer pending or we are blocked. */
     if (   pIoCtx->cMetaTransfersPending
-        || pIoCtx->fBlocked)
+        || (pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
     {
         rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -1955 +2007 @@
                 Assert(!pIoCtxWait->pIoCtxParent);
 
-                pIoCtxWait->fBlocked = false;
+                pIoCtxWait->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
                 LogFlowFunc(("Processing waiting I/O context pIoCtxWait=%#p\n", pIoCtxWait));
 
@@ -2032 +2084 @@
             uOffset  += cbThisRead;
             cbToRead -= cbThisRead;
-            pIoCtx->fBlocked = true;
+            pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
         }
 
@@ -2105 +2157 @@
 
         if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
-            pDisk->pLast->Backend->pfnFlush(pDisk->pLast->pBackendData);
+        {
+            VDIOCTX IoCtx;
+            vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, NULL,
+                        NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+            pDisk->pLast->Backend->pfnAsyncFlush(pDisk->pLast->pBackendData, &IoCtx);
+        }
     }
 }
@@ -2183 +2240 @@
 
     /* Write the full block to the virtual disk. */
-    rc = pImage->Backend->pfnWrite(pImage->pBackendData,
-                                   uOffset - cbPreRead, pvTmp,
-                                   cbPreRead + cbThisWrite + cbPostRead,
-                                   NULL, &cbPreRead, &cbPostRead, 0);
+    RTSGSEG SegmentBuf;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
+
+    SegmentBuf.pvSeg = pvTmp;
+    SegmentBuf.cbSeg = cbPreRead + cbThisWrite + cbPostRead;
+    RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+    vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_WRITE, 0, 0, NULL,
+                &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+    rc = pImage->Backend->pfnAsyncWrite(pImage->pBackendData, uOffset - cbPreRead,
+                                        cbPreRead + cbThisWrite + cbPostRead,
+                                        &IoCtx, NULL, &cbPreRead, &cbPostRead, 0);
     Assert(rc != VERR_VD_BLOCK_FREE);
     Assert(cbPreRead == 0);
@@ -2265 +2330 @@
 
     /* Write the full block to the virtual disk. */
-    rc = pImage->Backend->pfnWrite(pImage->pBackendData,
-                                   uOffset - cbPreRead, pvTmp,
-                                   cbPreRead + cbThisWrite + cbPostRead,
-                                   NULL, &cbPreRead, &cbPostRead, 0);
+    RTSGSEG SegmentBuf;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
+
+    SegmentBuf.pvSeg = pvTmp;
+    SegmentBuf.cbSeg = cbPreRead + cbThisWrite + cbPostRead;
+    RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+    vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_WRITE, 0, 0, NULL,
+                &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+    rc = pImage->Backend->pfnAsyncWrite(pImage->pBackendData, uOffset - cbPreRead,
+                                        cbPreRead + cbThisWrite + cbPostRead,
+                                        &IoCtx, NULL, &cbPreRead, &cbPostRead, 0);
     Assert(rc != VERR_VD_BLOCK_FREE);
     Assert(cbPreRead == 0);
@@ -2292 +2365 @@
     size_t cbWriteCur = cbWrite;
     const void *pcvBufCur = pvBuf;
+    RTSGSEG SegmentBuf;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
 
     /* Loop until all written. */
@@ -2305 +2381 @@
         fWrite =   (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
                  ? 0 : VD_WRITE_NO_ALLOC;
-        rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffsetCur, pcvBufCur,
-                                       cbThisWrite, &cbThisWrite, &cbPreRead,
-                                       &cbPostRead, fWrite);
+
+        SegmentBuf.pvSeg = (void *)pcvBufCur;
+        SegmentBuf.cbSeg = cbWrite;
+        RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+        vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_WRITE, 0, 0, NULL,
+                    &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+        rc = pImage->Backend->pfnAsyncWrite(pImage->pBackendData, uOffsetCur, cbThisWrite,
+                                            &IoCtx, &cbThisWrite, &cbPreRead,
+                                            &cbPostRead, fWrite);
         if (rc == VERR_VD_BLOCK_FREE)
         {
@@ -2408 +2490 @@
         if (fBlockwiseCopy)
         {
+            RTSGSEG SegmentBuf;
+            RTSGBUF SgBuf;
+            VDIOCTX IoCtx;
+
+            SegmentBuf.pvSeg = pvBuf;
+            SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
+            RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+            vdIoCtxInit(&IoCtx, pDiskFrom, VDIOCTXTXDIR_READ, 0, 0, NULL,
+                        &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+
             /* Read the source data. */
-            rc = pImageFrom->Backend->pfnRead(pImageFrom->pBackendData,
-                                              uOffset, pvBuf, cbThisRead,
-                                              &cbThisRead);
+            rc = pImageFrom->Backend->pfnAsyncRead(pImageFrom->pBackendData,
+                                                   uOffset, cbThisRead, &IoCtx,
+                                                   &cbThisRead);
 
             if (   rc == VERR_VD_BLOCK_FREE
@@ -2422 +2514 @@
                      pCurrImage = pCurrImage->pPrev)
                 {
-                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
-                                                      uOffset, pvBuf, cbThisRead,
-                                                      &cbThisRead);
+                    rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pBackendData,
+                                                           uOffset, cbThisRead,
+                                                           &IoCtx, &cbThisRead);
                     if (cImagesToProcess == 1)
                         break;
@@ -2558 +2650 @@
                     {
                         ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
-                        pIoCtx->fBlocked = true;
+                        pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
                     }
                     else /* Another error */
@@ -2686 +2778 @@
     else if (rc == VERR_VD_IOCTX_HALT)
     {
-        pIoCtx->fBlocked = true;
+        pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
         rc = VINF_SUCCESS;
     }
@@ -2948 +3040 @@
                     LogFlow(("Child write pending\n"));
                     ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
-                    pIoCtx->fBlocked = true;
+                    pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
                     rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
                     cbWrite -= cbThisWrite;
@@ -2966 +3058 @@
             cbWrite -= cbThisWrite;
             uOffset += cbThisWrite;
-            pIoCtx->fBlocked = true;
+            pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
             break;
         }
@@ -3751 +3843 @@
         ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rcReq, VINF_SUCCESS);
 
-    if (!pIoCtx->fBlocked)
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
     {
         /* Continue the transfer */
@@ -3789 +3881 @@
 
                 /* Unblock the parent */
-                pIoCtxParent->fBlocked = false;
+                pIoCtxParent->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
 
                 rc = vdIoCtxProcess(pIoCtxParent);
@@ -3835 +3927 @@
                         Assert(!pIoCtxWait->pIoCtxParent);
 
-                        pIoCtxWait->fBlocked = false;
+                        pIoCtxWait->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
                         LogFlowFunc(("Processing waiting I/O context pIoCtxWait=%#p\n", pIoCtxWait));
 
@@ -4138 +4230 @@
                  pvUser, pIoStorage, uOffset, pIoCtx, cbRead));
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
-
-    /** @todo: Handle synchronous I/O contexts. */
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     Assert(cbRead > 0);
 
-    /* Build the S/G array and spawn a new I/O task */
-    while (cbRead)
-    {
-        RTSGSEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
-        unsigned cSegments  = VD_IO_TASK_SEGMENTS_MAX;
-        size_t   cbTaskRead = 0;
-
-        cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbRead);
-
-        Assert(cSegments > 0);
-        Assert(cbTaskRead > 0);
-        AssertMsg(cbTaskRead <= cbRead, ("Invalid number of bytes to read\n"));
-
-        LogFlow(("Reading %u bytes into %u segments\n", cbTaskRead, cSegments));
+    if (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
+    {
+        RTSGSEG Seg;
+        unsigned cSegments = 1;
+        size_t cbTaskRead = 0;
+
+        /* Synchronous I/O contexts only have one buffer segment. */
+        AssertMsgReturn(pIoCtx->Req.Io.SgBuf.cSegs == 1,
+                        ("Invalid number of buffer segments for synchronous I/O context"),
+                        VERR_INVALID_PARAMETER);
+
+        cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, &Seg, &cSegments, cbRead);
+        Assert(cbRead == cbTaskRead);
+        Assert(cSegments == 1);
+        rc = pVDIo->pInterfaceIo->pfnReadSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                              pIoStorage->pStorage, uOffset,
+                                              Seg.pvSeg, cbRead, NULL);
+    }
+    else
+    {
+        /* Build the S/G array and spawn a new I/O task */
+        while (cbRead)
+        {
+            RTSGSEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
+            unsigned cSegments  = VD_IO_TASK_SEGMENTS_MAX;
+            size_t   cbTaskRead = 0;
+
+            cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbRead);
+
+            Assert(cSegments > 0);
+            Assert(cbTaskRead > 0);
+            AssertMsg(cbTaskRead <= cbRead, ("Invalid number of bytes to read\n"));
+
+            LogFlow(("Reading %u bytes into %u segments\n", cbTaskRead, cSegments));
 
 #ifdef RT_STRICT
-        for (unsigned i = 0; i < cSegments; i++)
-                AssertMsg(aSeg[i].pvSeg && !(aSeg[i].cbSeg % 512),
-                          ("Segment %u is invalid\n", i));
+            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(pIoStorage, NULL, NULL, pIoCtx, cbTaskRead);
-
-        if (!pIoTask)
-            return VERR_NO_MEMORY;
-
-        ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
-
-        void *pvTask;
-        rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
-                                               pIoStorage->pStorage, uOffset,
-                                               aSeg, cSegments, cbTaskRead, pIoTask,
-                                               &pvTask);
-        if (RT_SUCCESS(rc))
-        {
-            AssertMsg(cbTaskRead <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
-            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskRead);
-            ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
-            vdIoTaskFree(pDisk, pIoTask);
-        }
-        else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
-        {
-            ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
-            vdIoTaskFree(pDisk, pIoTask);
-            break;
-        }
-
-        uOffset += cbTaskRead;
-        cbRead  -= cbTaskRead;
+            PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, NULL, NULL, pIoCtx, cbTaskRead);
+
+            if (!pIoTask)
+                return VERR_NO_MEMORY;
+
+            ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+
+            void *pvTask;
+            rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                   pIoStorage->pStorage, uOffset,
+                                                   aSeg, cSegments, cbTaskRead, pIoTask,
+                                                   &pvTask);
+            if (RT_SUCCESS(rc))
+            {
+                AssertMsg(cbTaskRead <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
+                ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskRead);
+                ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
+                vdIoTaskFree(pDisk, pIoTask);
+            }
+            else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            {
+                ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
+                vdIoTaskFree(pDisk, pIoTask);
+                break;
+            }
+
+            uOffset += cbTaskRead;
+            cbRead  -= cbTaskRead;
+        }
     }
 
@@ -4210 +4323 @@
                  pvUser, pIoStorage, uOffset, pIoCtx, cbWrite));
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
-
-    /** @todo: Handle synchronous I/O contexts. */
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     Assert(cbWrite > 0);
 
-    /* Build the S/G array and spawn a new I/O task */
-    while (cbWrite)
-    {
-        RTSGSEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
-        unsigned cSegments   = VD_IO_TASK_SEGMENTS_MAX;
-        size_t   cbTaskWrite = 0;
-
-        cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbWrite);
-
-        Assert(cSegments > 0);
-        Assert(cbTaskWrite > 0);
-        AssertMsg(cbTaskWrite <= cbWrite, ("Invalid number of bytes to write\n"));
-
-        LogFlow(("Writing %u bytes from %u segments\n", cbTaskWrite, cSegments));
+    if (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
+    {
+        RTSGSEG Seg;
+        unsigned cSegments = 1;
+        size_t cbTaskWrite = 0;
+
+        /* Synchronous I/O contexts only have one buffer segment. */
+        AssertMsgReturn(pIoCtx->Req.Io.SgBuf.cSegs == 1,
+                        ("Invalid number of buffer segments for synchronous I/O context"),
+                        VERR_INVALID_PARAMETER);
+
+        cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, &Seg, &cSegments, cbWrite);
+        Assert(cbWrite == cbTaskWrite);
+        Assert(cSegments == 1);
+        rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                              pIoStorage->pStorage, uOffset,
+                                              Seg.pvSeg, cbWrite, NULL);
+    }
+    else
+    {
+        /* Build the S/G array and spawn a new I/O task */
+        while (cbWrite)
+        {
+            RTSGSEG  aSeg[VD_IO_TASK_SEGMENTS_MAX];
+            unsigned cSegments   = VD_IO_TASK_SEGMENTS_MAX;
+            size_t   cbTaskWrite = 0;
+
+            cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbWrite);
+
+            Assert(cSegments > 0);
+            Assert(cbTaskWrite > 0);
+            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));
+            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(pIoStorage, pfnComplete, pvCompleteUser, pIoCtx, cbTaskWrite);
-
-        if (!pIoTask)
-            return VERR_NO_MEMORY;
-
-        ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
-
-        void *pvTask;
-        rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
-                                                pIoStorage->pStorage,
-                                                uOffset, aSeg, cSegments,
-                                                cbTaskWrite, pIoTask, &pvTask);
-        if (RT_SUCCESS(rc))
-        {
-            AssertMsg(cbTaskWrite <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
-            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskWrite);
-            ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
-            vdIoTaskFree(pDisk, pIoTask);
-        }
-        else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
-        {
-            ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
-            vdIoTaskFree(pDisk, pIoTask);
-            break;
-        }
-
-        uOffset += cbTaskWrite;
-        cbWrite -= cbTaskWrite;
-    }
-
+            PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, pfnComplete, pvCompleteUser, pIoCtx, cbTaskWrite);
+
+            if (!pIoTask)
+                return VERR_NO_MEMORY;
+
+            ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+
+            void *pvTask;
+            rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                    pIoStorage->pStorage,
+                                                    uOffset, aSeg, cSegments,
+                                                    cbTaskWrite, pIoTask, &pvTask);
+            if (RT_SUCCESS(rc))
+            {
+                AssertMsg(cbTaskWrite <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
+                ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskWrite);
+                ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
+                vdIoTaskFree(pDisk, pIoTask);
+            }
+            else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            {
+                ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
+                vdIoTaskFree(pDisk, pIoTask);
+                break;
+            }
+
+            uOffset += cbTaskWrite;
+            cbWrite -= cbTaskWrite;
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -4291 +4426 @@
                     VERR_INVALID_POINTER);
 
-    if (!pIoCtx)
+    /** @todo: Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
     {
         /* Handle synchronous metadata I/O. */
         /** @todo: Integrate with metadata transfers below. */
-        return pVDIo->pInterfaceIo->pfnReadSync(pVDIo->pInterfaceIo->Core.pvUser,
-                                                pIoStorage->pStorage, uOffset,
-                                                pvBuf, cbRead, NULL);
-    }
-
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
-
-    pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
-    if (!pMetaXfer)
-    {
+        rc = pVDIo->pInterfaceIo->pfnReadSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                               pIoStorage->pStorage, uOffset,
+                                               pvBuf, cbRead, NULL);
+        if (ppMetaXfer)
+            *ppMetaXfer = NULL;
+    }
+    else
+    {
+        pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
+        if (!pMetaXfer)
+        {
 #ifdef RT_STRICT
-        pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGetBestFit(pIoStorage->pTreeMetaXfers, uOffset, false /* fAbove */);
-        AssertMsg(!pMetaXfer || (pMetaXfer->Core.Key + (RTFOFF)pMetaXfer->cbMeta <= (RTFOFF)uOffset),
-                  ("Overlapping meta transfers!\n"));
+            pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGetBestFit(pIoStorage->pTreeMetaXfers, uOffset, false /* fAbove */);
+            AssertMsg(!pMetaXfer || (pMetaXfer->Core.Key + (RTFOFF)pMetaXfer->cbMeta <= (RTFOFF)uOffset),
+                      ("Overlapping meta transfers!\n"));
 #endif
 
-        /* Allocate a new meta transfer. */
-        pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbRead);
-        if (!pMetaXfer)
-            return VERR_NO_MEMORY;
-
-        pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
-        if (!pIoTask)
-        {
-            RTMemFree(pMetaXfer);
-            return VERR_NO_MEMORY;
-        }
-
-        Seg.cbSeg = cbRead;
-        Seg.pvSeg = pMetaXfer->abData;
-
-        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_READ);
-        rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
-                                               pIoStorage->pStorage,
-                                               uOffset, &Seg, 1,
-                                               cbRead, pIoTask, &pvTask);
-
-        if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
-        {
-            bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
-            Assert(fInserted);
-        }
-        else
-            RTMemFree(pMetaXfer);
-
-        if (RT_SUCCESS(rc))
-        {
-            VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
-            vdIoTaskFree(pDisk, pIoTask);
-        }
-        else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS && !pfnComplete)
-            rc = VERR_VD_NOT_ENOUGH_METADATA;
-    }
-
-    Assert(VALID_PTR(pMetaXfer) || RT_FAILURE(rc));
-
-    if (RT_SUCCESS(rc) || rc == VERR_VD_NOT_ENOUGH_METADATA || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
-    {
-        /* If it is pending add the request to the list. */
-        if (VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_READ)
-        {
-            PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
-            AssertPtr(pDeferred);
-
-            RTListInit(&pDeferred->NodeDeferred);
-            pDeferred->pIoCtx = pIoCtx;
-
-            ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
-            RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
-            rc = VERR_VD_NOT_ENOUGH_METADATA;
-        }
-        else
-        {
-            /* Transfer the data. */
-            pMetaXfer->cRefs++;
-            Assert(pMetaXfer->cbMeta >= cbRead);
-            Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
-            memcpy(pvBuf, pMetaXfer->abData, cbRead);
-            *ppMetaXfer = pMetaXfer;
-        }
-    }
-
+            /* Allocate a new meta transfer. */
+            pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbRead);
+            if (!pMetaXfer)
+                return VERR_NO_MEMORY;
+
+            pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
+            if (!pIoTask)
+            {
+                RTMemFree(pMetaXfer);
+                return VERR_NO_MEMORY;
+            }
+
+            Seg.cbSeg = cbRead;
+            Seg.pvSeg = pMetaXfer->abData;
+
+            VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_READ);
+            rc = pVDIo->pInterfaceIo->pfnReadAsync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                   pIoStorage->pStorage,
+                                                   uOffset, &Seg, 1,
+                                                   cbRead, pIoTask, &pvTask);
+
+            if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            {
+                bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
+                Assert(fInserted);
+            }
+            else
+                RTMemFree(pMetaXfer);
+
+            if (RT_SUCCESS(rc))
+            {
+                VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
+                vdIoTaskFree(pDisk, pIoTask);
+            }
+            else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS && !pfnComplete)
+                rc = VERR_VD_NOT_ENOUGH_METADATA;
+        }
+
+        Assert(VALID_PTR(pMetaXfer) || RT_FAILURE(rc));
+
+        if (RT_SUCCESS(rc) || rc == VERR_VD_NOT_ENOUGH_METADATA || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        {
+            /* If it is pending add the request to the list. */
+            if (VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_READ)
+            {
+                PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
+                AssertPtr(pDeferred);
+
+                RTListInit(&pDeferred->NodeDeferred);
+                pDeferred->pIoCtx = pIoCtx;
+
+                ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
+                RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
+                rc = VERR_VD_NOT_ENOUGH_METADATA;
+            }
+            else
+            {
+                /* Transfer the data. */
+                pMetaXfer->cRefs++;
+                Assert(pMetaXfer->cbMeta >= cbRead);
+                Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
+                memcpy(pvBuf, pMetaXfer->abData, cbRead);
+                *ppMetaXfer = pMetaXfer;
+            }
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -4401 +4545 @@
                     VERR_INVALID_POINTER);
 
-    if (!pIoCtx)
+    /** @todo: Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
     {
         /* Handle synchronous metadata I/O. */
         /** @todo: Integrate with metadata transfers below. */
-        return pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
-                                                 pIoStorage->pStorage, uOffset,
-                                                 pvBuf, cbWrite, NULL);
-    }
-
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
-
-    pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
-    if (!pMetaXfer)
-    {
-        /* Allocate a new meta transfer. */
-        pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbWrite);
+        rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                               pIoStorage->pStorage, uOffset,
+                                               pvBuf, cbWrite, NULL);
+    }
+    else
+    {
+        pMetaXfer = (PVDMETAXFER)RTAvlrFileOffsetGet(pIoStorage->pTreeMetaXfers, uOffset);
         if (!pMetaXfer)
+        {
+            /* Allocate a new meta transfer. */
+            pMetaXfer = vdMetaXferAlloc(pIoStorage, uOffset, cbWrite);
+            if (!pMetaXfer)
+                return VERR_NO_MEMORY;
+        }
+        else
+        {
+            Assert(pMetaXfer->cbMeta >= cbWrite);
+            Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
+            fInTree = true;
+        }
+
+        Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE);
+
+        pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
+        if (!pIoTask)
+        {
+            RTMemFree(pMetaXfer);
             return VERR_NO_MEMORY;
-    }
-    else
-    {
-        Assert(pMetaXfer->cbMeta >= cbWrite);
-        Assert(pMetaXfer->Core.Key == (RTFOFF)uOffset);
-        fInTree = true;
-    }
-
-    Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE);
-
-    pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvCompleteUser, pMetaXfer);
-    if (!pIoTask)
-    {
-        RTMemFree(pMetaXfer);
-        return VERR_NO_MEMORY;
-    }
-
-    memcpy(pMetaXfer->abData, pvBuf, cbWrite);
-    Seg.cbSeg = cbWrite;
-    Seg.pvSeg = pMetaXfer->abData;
-
-    ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
-
-    VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
-    rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
-                                            pIoStorage->pStorage,
-                                            uOffset, &Seg, 1, cbWrite, pIoTask,
-                                            &pvTask);
-    if (RT_SUCCESS(rc))
-    {
-        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
-        ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
-        vdIoTaskFree(pDisk, pIoTask);
-        if (fInTree && !pMetaXfer->cRefs)
-        {
-            LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
-            bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
-            AssertMsg(fRemoved, ("Metadata transfer wasn't removed\n"));
+        }
+
+        memcpy(pMetaXfer->abData, pvBuf, cbWrite);
+        Seg.cbSeg = cbWrite;
+        Seg.pvSeg = pMetaXfer->abData;
+
+        ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
+
+        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
+        rc = pVDIo->pInterfaceIo->pfnWriteAsync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                pIoStorage->pStorage,
+                                                uOffset, &Seg, 1, cbWrite, pIoTask,
+                                                &pvTask);
+        if (RT_SUCCESS(rc))
+        {
+            VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
+            ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
+            vdIoTaskFree(pDisk, pIoTask);
+            if (fInTree && !pMetaXfer->cRefs)
+            {
+                LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
+                bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
+                AssertMsg(fRemoved, ("Metadata transfer wasn't removed\n"));
+                RTMemFree(pMetaXfer);
+                pMetaXfer = NULL;
+            }
+        }
+        else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        {
+            PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
+            AssertPtr(pDeferred);
+
+            RTListInit(&pDeferred->NodeDeferred);
+            pDeferred->pIoCtx = pIoCtx;
+
+            if (!fInTree)
+            {
+                bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
+                Assert(fInserted);
+            }
+
+            RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
+        }
+        else
+        {
             RTMemFree(pMetaXfer);
             pMetaXfer = NULL;
         }
     }
-    else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
-    {
-        PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
-        AssertPtr(pDeferred);
-
-        RTListInit(&pDeferred->NodeDeferred);
-        pDeferred->pIoCtx = pIoCtx;
-
-        if (!fInTree)
-        {
-            bool fInserted = RTAvlrFileOffsetInsert(pIoStorage->pTreeMetaXfers, &pMetaXfer->Core);
-            Assert(fInserted);
-        }
-
-        RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
-    }
-    else
-    {
-        RTMemFree(pMetaXfer);
-        pMetaXfer = NULL;
-    }
-
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -4490 +4641 @@
     PVDIO    pVDIo = (PVDIO)pvUser;
     PVBOXHDD pDisk = pVDIo->pDisk;
-    PVDIOSTORAGE pIoStorage = pMetaXfer->pIoStorage;
+    PVDIOSTORAGE pIoStorage;
+
+    /*
+     * It is possible that we get called with a NULL metadata xfer handle
+     * for synchronous I/O. Just exit.
+     */
+    if (!pMetaXfer)
+        return;
+
+    pIoStorage = pMetaXfer->pIoStorage;
 
     VD_THREAD_IS_CRITSECT_OWNER(pDisk);
@@ -4530 +4690 @@
                     VERR_INVALID_POINTER);
 
-    if (!pIoCtx)
+    /** @todo: Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+
+    if (pVDIo->fIgnoreFlush)
+        return VINF_SUCCESS;
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
     {
         /* Handle synchronous flushes. */
         /** @todo: Integrate with metadata transfers below. */
-        return pVDIo->pInterfaceIo->pfnFlushSync(pVDIo->pInterfaceIo->Core.pvUser,
-                                                 pIoStorage->pStorage);
-    }
-
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
-
-    if (pVDIo->fIgnoreFlush)
-        return VINF_SUCCESS;
-
-    /* Allocate a new meta transfer. */
-    pMetaXfer = vdMetaXferAlloc(pIoStorage, 0, 0);
-    if (!pMetaXfer)
-        return VERR_NO_MEMORY;
-
-    pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvUser, pMetaXfer);
-    if (!pIoTask)
-    {
-        RTMemFree(pMetaXfer);
-        return VERR_NO_MEMORY;
-    }
-
-    ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
-
-    PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
-    AssertPtr(pDeferred);
-
-    RTListInit(&pDeferred->NodeDeferred);
-    pDeferred->pIoCtx = pIoCtx;
-
-    RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
-    VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_FLUSH);
-    rc = pVDIo->pInterfaceIo->pfnFlushAsync(pVDIo->pInterfaceIo->Core.pvUser,
-                                            pIoStorage->pStorage,
-                                            pIoTask, &pvTask);
-    if (RT_SUCCESS(rc))
-    {
-        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
-        ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
-        vdIoTaskFree(pDisk, pIoTask);
-        RTMemFree(pDeferred);
-        RTMemFree(pMetaXfer);
-    }
-    else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
-        RTMemFree(pMetaXfer);
-
+        rc = pVDIo->pInterfaceIo->pfnFlushSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                               pIoStorage->pStorage);
+    }
+    else
+    {
+        /* Allocate a new meta transfer. */
+        pMetaXfer = vdMetaXferAlloc(pIoStorage, 0, 0);
+        if (!pMetaXfer)
+            return VERR_NO_MEMORY;
+
+        pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvUser, pMetaXfer);
+        if (!pIoTask)
+        {
+            RTMemFree(pMetaXfer);
+            return VERR_NO_MEMORY;
+        }
+
+        ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
+
+        PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
+        AssertPtr(pDeferred);
+
+        RTListInit(&pDeferred->NodeDeferred);
+        pDeferred->pIoCtx = pIoCtx;
+
+        RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
+        VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_FLUSH);
+        rc = pVDIo->pInterfaceIo->pfnFlushAsync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                pIoStorage->pStorage,
+                                                pIoTask, &pvTask);
+        if (RT_SUCCESS(rc))
+        {
+            VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
+            ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
+            vdIoTaskFree(pDisk, pIoTask);
+            RTMemFree(pDeferred);
+            RTMemFree(pMetaXfer);
+        }
+        else if (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            RTMemFree(pMetaXfer);
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -4589 +4756 @@
     size_t cbCopied = 0;
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     cbCopied = vdIoCtxCopyTo(pIoCtx, (uint8_t *)pvBuf, cbBuf);
@@ -4606 +4775 @@
     size_t cbCopied = 0;
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     cbCopied = vdIoCtxCopyFrom(pIoCtx, (uint8_t *)pvBuf, cbBuf);
@@ -4622 +4793 @@
     size_t cbSet = 0;
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     cbSet = vdIoCtxSet(pIoCtx, ch, cb);
@@ -4640 +4813 @@
     size_t cbCreated = 0;
 
-    VD_THREAD_IS_CRITSECT_OWNER(pDisk);
+    /** @todo: Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
     cbCreated = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, paSeg, pcSeg, cbData);
@@ -4659 +4834 @@
      * Example is that iSCSI is doing an asynchronous write but calls us already
      * while the other thread is still hanging in vdWriteHelperAsync and couldn't update
-     * the fBlocked state yet.
+     * the blocked state yet.
      * It can overwrite the state to true before we call vdIoCtxContinue and the
      * the request would hang indefinite.
@@ -4667 +4842 @@
 
     /* Continue */
-    pIoCtx->fBlocked = false;
+    pIoCtx->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
     ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbCompleted);
 
@@ -4678 +4853 @@
 
     vdDiskCritSectLeave(pDisk, NULL);
+}
+
+static DECLCALLBACK(bool) vdIOIntIoCtxIsSynchronous(void *pvUser, PVDIOCTX pIoCtx)
+{
+    NOREF(pvUser);
+    return !!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC);
+}
+
+static DECLCALLBACK(bool) vdIOIntIoCtxIsZero(void *pvUser, PVDIOCTX pIoCtx, size_t cbCheck,
+                                             bool fAdvance)
+{
+    NOREF(pvUser);
+
+    bool fIsZero = RTSgBufIsZero(&pIoCtx->Req.Io.SgBuf, cbCheck);
+    if (fIsZero && fAdvance)
+        RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbCheck);
+
+    return fIsZero;
 }
 
@@ -4962 +5155 @@
     pIfIoInt->pfnIoCtxSegArrayCreate = vdIOIntIoCtxSegArrayCreate;
     pIfIoInt->pfnIoCtxCompleted      = vdIOIntIoCtxCompleted;
+    pIfIoInt->pfnIoCtxIsSynchronous  = vdIOIntIoCtxIsSynchronous;
+    pIfIoInt->pfnIoCtxIsZero         = vdIOIntIoCtxIsZero;
 }
 
@@ -6748 +6943 @@
             {
                 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
+                RTSGSEG SegmentBuf;
+                RTSGBUF SgBuf;
+                VDIOCTX IoCtx;
+
+                SegmentBuf.pvSeg = pvBuf;
+                SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
+                RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
+                            &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
 
                 /* Need to hold the write lock during a read-write operation. */
@@ -6754 +6958 @@
                 fLockWrite = true;
 
-                rc = pImageTo->Backend->pfnRead(pImageTo->pBackendData,
-                                                uOffset, pvBuf, cbThisRead,
-                                                &cbThisRead);
+                rc = pImageTo->Backend->pfnAsyncRead(pImageTo->pBackendData,
+                                                     uOffset, cbThisRead,
+                                                     &IoCtx, &cbThisRead);
                 if (rc == VERR_VD_BLOCK_FREE)
                 {
@@ -6767 +6971 @@
                          pCurrImage = pCurrImage->pPrev)
                     {
-                        rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
-                                                          uOffset, pvBuf,
-                                                          cbThisRead,
-                                                          &cbThisRead);
+                        rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pBackendData,
+                                                               uOffset, cbThisRead,
+                                                               &IoCtx, &cbThisRead);
                     }
 
@@ -6869 +7072 @@
             {
                 size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
+                RTSGSEG SegmentBuf;
+                RTSGBUF SgBuf;
+                VDIOCTX IoCtx;
+
                 rc = VERR_VD_BLOCK_FREE;
+
+                SegmentBuf.pvSeg = pvBuf;
+                SegmentBuf.cbSeg = VD_MERGE_BUFFER_SIZE;
+                RTSgBufInit(&SgBuf, &SegmentBuf, 1);
+                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, 0, 0, NULL,
+                            &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC);
 
                 /* Need to hold the write lock during a read-write operation. */
@@ -6884 +7097 @@
                      pCurrImage = pCurrImage->pPrev)
                 {
-                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
-                                                      uOffset, pvBuf,
-                                                      cbThisRead, &cbThisRead);
+                    rc = pCurrImage->Backend->pfnAsyncRead(pCurrImage->pBackendData,
+                                                           uOffset, cbThisRead,
+                                                           &IoCtx, &cbThisRead);
                 }
 
@@ -8081 +8294 @@
 
         vdResetModifiedFlag(pDisk);
-        rc = pImage->Backend->pfnFlush(pImage->pBackendData);
-
+
+        VDIOCTX IoCtx;
+        vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, NULL,
+                    NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+        rc = pImage->Backend->pfnAsyncFlush(pImage->pBackendData, &IoCtx);
+
+#if 0 /** @todo: Change cache implementation. */
         if (   RT_SUCCESS(rc)
             && pDisk->pCache)
             rc = pDisk->pCache->Backend->pfnFlush(pDisk->pCache->pBackendData);
+#endif
     } while (0);
 

trunk/src/VBox/Storage/VDI.cpp

@@ -2548 +2548 @@
                     || cbToWrite == getImageBlockSize(&pImage->Header)))
             {
-#if 0 /** @todo Provide interface to check an I/O context for a specific value */
                 /* If the destination block is unallocated at this point, it's
                  * either a zero block or a block which hasn't been used so far
                  * (which also means that it's a zero block. Don't need to write
                  * anything to this block  if the data consists of just zeroes. */
-                Assert(!(cbToWrite % 4));
-                Assert(cbToWrite * 8 <= UINT32_MAX);
-                if (ASMBitFirstSet((volatile void *)pvBuf, (uint32_t)cbToWrite * 8) == -1)
+                if (vdIfIoIntIoCtxIsZero(pImage->pIfIo, pIoCtx, cbToWrite, true))
                 {
                     pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
+                    *pcbPreRead = 0;
+                    *pcbPostRead = 0;
                     break;
                 }
-#endif
             }