Changeset 38876 in vbox

Timestamp:

Sep 27, 2011 9:03:15 AM (14 years ago)

Author:

vboxsync

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

74198

Message:

Storage: Add async discard API

Location:

trunk

Files:

• include/VBox/vd-plugin.h (modified) (1 diff)
• include/VBox/vd.h (modified) (3 diffs)
• include/VBox/vddbg.h (modified) (2 diffs)
• src/VBox/Storage/DMG.cpp (modified) (1 diff)
• src/VBox/Storage/Debug/VDDbgIoLog.cpp (modified) (4 diffs)
• src/VBox/Storage/ISCSI.cpp (modified) (1 diff)
• src/VBox/Storage/QCOW.cpp (modified) (1 diff)
• src/VBox/Storage/QED.cpp (modified) (1 diff)
• src/VBox/Storage/RAW.cpp (modified) (1 diff)
• src/VBox/Storage/VD.cpp (modified) (56 diffs)
• src/VBox/Storage/VDI.cpp (modified) (6 diffs)
• src/VBox/Storage/VDICore.h (modified) (1 diff)
• src/VBox/Storage/VHD.cpp (modified) (1 diff)
• src/VBox/Storage/VMDK.cpp (modified) (1 diff)
• src/VBox/Storage/testcase/tstVDIo.cpp (modified) (10 diffs)

trunk/include/VBox/vd-plugin.h

@@ -601 +601 @@
                                            unsigned fDiscard));
 
+    /**
+     * Discards the given amount of bytes decreasing the size of the image if possible
+     * callback version for asynchronous I/O.
+     *
+     * @returns VBox status code.
+     * @retval  VERR_VD_DISCARD_ALIGNMENT_NOT_MET if the range doesn't meet the required alignment
+     *          for the discard.
+     * @param   pBackendData         Opaque state data for this image.
+     * @param   pIoCtx               I/O context associated with this request.
+     * @param   uOffset              The offset of the first byte to discard.
+     * @param   cbDiscard            How many bytes to discard.
+     * @param   pcbPreAllocated      Pointer to the returned amount of bytes that must
+     *                               be discarded before the range to perform a full
+     *                               block discard.
+     * @param   pcbPostAllocated     Pointer to the returned amount of bytes that must
+     *                               be discarded after the range to perform a full
+     *                               block discard.
+     * @param   pcbActuallyDiscarded Pointer to the returned amount of bytes which
+     *                               could be actually discarded.
+     * @param   ppbmAllocationBitmap Where to store the pointer to the allocation bitmap
+     *                               if VERR_VD_DISCARD_ALIGNMENT_NOT_MET is returned or NULL
+     *                               if the allocation bitmap should be returned.
+     * @param   fDiscard             Flags which affect discard behavior. Combination
+     *                               of the VD_DISCARD_* flags.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnAsyncDiscard, (void *pBackendData, PVDIOCTX pIoCtx,
+                                                uint64_t uOffset, size_t cbDiscard,
+                                                size_t *pcbPreAllocated,
+                                                size_t *pcbPostAllocated,
+                                                size_t *pcbActuallyDiscarded,
+                                                void   **ppbmAllocationBitmap,
+                                                unsigned fDiscard));
+
 } VBOXHDDBACKEND;
 

trunk/include/VBox/vd.h

@@ -398 +398 @@
 
 /**
- * VD range descriptor.
- */
-typedef struct VDRANGE
-{
-    /** Start offset in bytes, multiple of 512. */
-    uint64_t    offStart;
-    /** Amount of bytes described by this range, multiple of 512. */
-    size_t      cbRange;
-} VDRANGE;
-
-/** Pointer to a range descriptor. */
-typedef VDRANGE *PVDRANGE;
-/** Pointer to a constant range descriptor. */
-typedef const VDRANGE *PCVDRANGE;
-
-/**
  * VBox HDD Container main structure.
  */
@@ -1122 +1106 @@
  *       appear to contain data. This method is mainly used to implement TRIM support.
  */
-VBOXDDU_DECL(int) VDDiscardRanges(PVBOXHDD pDisk, PCVDRANGE paRanges, unsigned cRanges);
+VBOXDDU_DECL(int) VDDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges);
 
 
@@ -1170 +1154 @@
                                PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
                                void *pvUser1, void *pvUser2);
+
+/**
+ * Start an asynchronous discard request.
+ *
+ * @return  VBox status code.
+ * @param   pDisk           Pointer to HDD container.
+ * @param   paRanges        The array of ranges to discard.
+ * @param   cRanges         Number of entries in the array.
+ * @param   pfnComplete     Completion callback.
+ * @param   pvUser1         User data which is passed on completion.
+ * @param   pvUser2         User data which is passed on completion.
+ */
+VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges,
+                                       PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                       void *pvUser1, void *pvUser);
+
 RT_C_DECLS_END
 

trunk/include/VBox/vddbg.h

@@ -175 +175 @@
  * @param   phIoLogEntry Where to store the I/O log entry handle on success.
  */
-VBOXDDU_DECL(int) VDDbgIoLogStartDiscard(VDIOLOGGER hIoLogger, bool fAsync, PVDRANGE paRanges, unsigned cRanges,
+VBOXDDU_DECL(int) VDDbgIoLogStartDiscard(VDIOLOGGER hIoLogger, bool fAsync, PCRTRANGE paRanges, unsigned cRanges,
                                          PVDIOLOGENT phIoLogEntry);
 
@@ -239 +239 @@
  */
 VBOXDDU_DECL(int) VDDbgIoLogEventGetStartDiscard(VDIOLOGGER hIoLogger, uint64_t *pidEvent, bool *pfAsync,
-                                                 PVDRANGE *ppaRanges, unsigned *pcRanges);
+                                                 PRTRANGE *ppaRanges, unsigned *pcRanges);
 
 /**

trunk/src/VBox/Storage/DMG.cpp

@@ -2334 +2334 @@
     NULL,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/Debug/VDDbgIoLog.cpp

@@ -449 +449 @@
 }
 
-VBOXDDU_DECL(int) VDDbgIoLogStartDiscard(VDIOLOGGER hIoLogger, bool fAsync, PVDRANGE paRanges, unsigned cRanges,
+VBOXDDU_DECL(int) VDDbgIoLogStartDiscard(VDIOLOGGER hIoLogger, bool fAsync, PCRTRANGE paRanges, unsigned cRanges,
                                          PVDIOLOGENT phIoLogEntry)
 {
@@ -697 +697 @@
 
 VBOXDDU_DECL(int) VDDbgIoLogEventGetStartDiscard(VDIOLOGGER hIoLogger, uint64_t *pidEvent, bool *pfAsync,
-                                                 PVDRANGE *ppaRanges, unsigned *pcRanges)
+                                                 PRTRANGE *ppaRanges, unsigned *pcRanges)
 {
     int rc = VINF_SUCCESS;
@@ -716 +716 @@
         if (RT_SUCCESS(rc))
         {
-            PVDRANGE paRanges = NULL;
+            PRTRANGE paRanges = NULL;
             IoLogEntryDiscard DiscardRange;
 
@@ -724 +724 @@
             *pcRanges  = RT_LE2H_U32(Entry.Discard.cRanges);
 
-            paRanges = (PVDRANGE)RTMemAllocZ(*pcRanges * sizeof(VDRANGE));
+            paRanges = (PRTRANGE)RTMemAllocZ(*pcRanges * sizeof(RTRANGE));
             if (paRanges)
             {

trunk/src/VBox/Storage/ISCSI.cpp

@@ -5572 +5572 @@
     NULL,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/QCOW.cpp

@@ -2854 +2854 @@
     NULL,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/QED.cpp

@@ -2921 +2921 @@
     qedResize,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/RAW.cpp

@@ -1292 +1292 @@
     NULL,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/VD.cpp

@@ -273 +273 @@
     /** Flush */
     VDIOCTXTXDIR_FLUSH,
+    /** Discard */
+    VDIOCTXTXDIR_DISCARD,
     /** 32bit hack */
     VDIOCTXTXDIR_32BIT_HACK = 0x7fffffff
@@ -291 +293 @@
     /** Return code. */
     int                          rcReq;
-    /** Transfer direction */
-    VDIOCTXTXDIR                 enmTxDir;
-    /** Number of bytes left until this context completes. */
-    volatile uint32_t            cbTransferLeft;
-    /** Current offset */
-    volatile uint64_t            uOffset;
-    /** Number of bytes to transfer */
-    volatile size_t              cbTransfer;
-    /** Current image in the chain. */
-    PVDIMAGE                     pImageCur;
-    /** Start image to read from. pImageCur is reset to this
-     *  value after it reached the first image in the chain. */
-    PVDIMAGE                     pImageStart;
-    /** S/G buffer */
-    RTSGBUF                      SgBuf;
     /** Flag whether the I/O context is blocked because it is in the growing list. */
     bool                         fBlocked;
@@ -321 +308 @@
     /** Next transfer part after the current one completed. */
     PFNVDIOCTXTRANSFER           pfnIoCtxTransferNext;
+    /** Transfer direction */
+    VDIOCTXTXDIR                 enmTxDir;
+    /** Request type dependent data. */
+    union
+    {
+        /** I/O request (read/write). */
+        struct
+        {
+            /** Number of bytes left until this context completes. */
+            volatile uint32_t    cbTransferLeft;
+            /** Current offset */
+            volatile uint64_t    uOffset;
+            /** Number of bytes to transfer */
+            volatile size_t      cbTransfer;
+            /** Current image in the chain. */
+            PVDIMAGE             pImageCur;
+            /** Start image to read from. pImageCur is reset to this
+             *  value after it reached the first image in the chain. */
+            PVDIMAGE             pImageStart;
+            /** S/G buffer */
+            RTSGBUF              SgBuf;
+        } Io;
+        /** Discard requests. */
+        struct
+        {
+            /** Pointer to the range descriptor array. */
+            PCRTRANGE            paRanges;
+            /** Number of ranges in the array. */
+            unsigned             cRanges;
+            /** Range descriptor index which is processed. */
+            unsigned             idxRange;
+            /** Start offset to discard currently. */
+            uint64_t             offCur;
+            /** How many bytes left to discard in the current range. */
+            size_t               cbDiscardLeft;
+            /** How many bytes to discard in the current block (<= cbDiscardLeft). */
+            size_t               cbThisDiscard;
+            /** Discard block handled currently. */
+            PVDDISCARDBLOCK      pBlock;
+        } Discard;
+    } Req;
     /** Parent I/O context if any. Sets the type of the context (root/child) */
     PVDIOCTX                     pIoCtxParent;
@@ -333 +361 @@
             /** User argument 1 passed on completion. */
             void                        *pvUser1;
-            /** User argument 1 passed on completion. */
+            /** User argument 2 passed on completion. */
             void                        *pvUser2;
         } Root;
@@ -369 +397 @@
 } VDIOCTX;
 
+/**
+ * List node for deferred I/O contexts.
+ */
 typedef struct VDIOCTXDEFERRED
 {
@@ -501 +532 @@
     &g_VciCacheBackend
 };
+
+/** Forward declaration of the async discard helper. */
+static int vdDiscardHelperAsync(PVDIOCTX pIoCtx);
 
 /**
@@ -1163 +1197 @@
                 }
                 else
+                {
+                    RTMemFree(pbmAllocated);
                     rc = VERR_NO_MEMORY;
+                }
             }
         }
@@ -1169 +1206 @@
         {
             /* Range lies partly in the block, update allocation bitmap. */
+            int32_t idxStart, idxEnd;
+
             cbThisDiscard = RT_MIN(cbDiscard, pBlock->Core.KeyLast - offStart + 1);
-            rc = VERR_VD_DISCARD_ALIGNMENT_NOT_MET;
-        }
-
-        Assert(cbDiscard >= cbThisDiscard);
-
-        if (rc == VERR_VD_DISCARD_ALIGNMENT_NOT_MET)
-        {
-            int32_t idxStart, idxEnd;
 
             AssertPtr(pBlock);
@@ -1241 +1272 @@
  * @param   cRanges  The number of ranges in the array.
  */
-static int vdDiscardHelper(PVBOXHDD pDisk, PCVDRANGE paRanges, unsigned cRanges)
+static int vdDiscardHelper(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges)
 {
     int rc = VINF_SUCCESS;
@@ -1331 +1362 @@
         pIoCtx->pDisk                 = pDisk;
         pIoCtx->enmTxDir              = enmTxDir;
-        pIoCtx->cbTransferLeft        = cbTransfer;
-        pIoCtx->uOffset               = uOffset;
-        pIoCtx->cbTransfer            = cbTransfer;
-        pIoCtx->pImageStart           = pImageStart;
-        pIoCtx->pImageCur             = pImageStart;
+        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;
@@ -1347 +1378 @@
         /* There is no S/G list for a flush request. */
         if (enmTxDir != VDIOCTXTXDIR_FLUSH)
-            RTSgBufClone(&pIoCtx->SgBuf, pcSgBuf);
+            RTSgBufClone(&pIoCtx->Req.Io.SgBuf, pcSgBuf);
         else
-            memset(&pIoCtx->SgBuf, 0, sizeof(RTSGBUF));
+            memset(&pIoCtx->Req.Io.SgBuf, 0, sizeof(RTSGBUF));
     }
 
@@ -1378 +1409 @@
 }
 
+DECLINLINE(PVDIOCTX) vdIoCtxDiscardAlloc(PVBOXHDD pDisk, PCRTRANGE paRanges,
+                                         unsigned cRanges,
+                                         PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                         void *pvUser1, void *pvUser2,
+                                         void *pvAllocation,
+                                         PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
+{
+    PVDIOCTX pIoCtx = NULL;
+
+    pIoCtx = (PVDIOCTX)RTMemCacheAlloc(pDisk->hMemCacheIoCtx);
+    if (RT_LIKELY(pIoCtx))
+    {
+        pIoCtx->pDisk                     = pDisk;
+        pIoCtx->enmTxDir                  = VDIOCTXTXDIR_DISCARD;
+        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;
+        pIoCtx->Req.Discard.paRanges      = paRanges;
+        pIoCtx->Req.Discard.cRanges       = cRanges;
+        pIoCtx->Req.Discard.idxRange      = 0;
+        pIoCtx->Req.Discard.cbDiscardLeft = 0;
+        pIoCtx->Req.Discard.offCur        = 0;
+        pIoCtx->Req.Discard.cbThisDiscard = 0;
+
+        pIoCtx->pIoCtxParent          = NULL;
+        pIoCtx->Type.Root.pfnComplete = pfnComplete;
+        pIoCtx->Type.Root.pvUser1     = pvUser1;
+        pIoCtx->Type.Root.pvUser2     = pvUser2;
+    }
+
+    LogFlow(("Allocated discard I/O context %#p\n", pIoCtx));
+    return pIoCtx;
+}
+
 DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVBOXHDD pDisk, VDIOCTXTXDIR enmTxDir,
                                        uint64_t uOffset, size_t cbTransfer,
@@ -1459 +1529 @@
     AssertPtr(pIoCtx->pIoCtxParent);
 
-    RTSgBufReset(&pIoCtx->SgBuf);
-    pIoCtx->uOffset        = pIoCtx->Type.Child.uOffsetSaved;
-    pIoCtx->cbTransferLeft = pIoCtx->Type.Child.cbTransferLeftSaved;
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    pIoCtx->Req.Io.uOffset        = pIoCtx->Type.Child.uOffsetSaved;
+    pIoCtx->Req.Io.cbTransferLeft = pIoCtx->Type.Child.cbTransferLeftSaved;
 }
 
@@ -1501 +1571 @@
 static size_t vdIoCtxCopy(PVDIOCTX pIoCtxDst, PVDIOCTX pIoCtxSrc, size_t cbData)
 {
-    return RTSgBufCopy(&pIoCtxDst->SgBuf, &pIoCtxSrc->SgBuf, cbData);
+    return RTSgBufCopy(&pIoCtxDst->Req.Io.SgBuf, &pIoCtxSrc->Req.Io.SgBuf, cbData);
 }
 
 static int vdIoCtxCmp(PVDIOCTX pIoCtx1, PVDIOCTX pIoCtx2, size_t cbData)
 {
-    return RTSgBufCmp(&pIoCtx1->SgBuf, &pIoCtx2->SgBuf, cbData);
+    return RTSgBufCmp(&pIoCtx1->Req.Io.SgBuf, &pIoCtx2->Req.Io.SgBuf, cbData);
 }
 
 static size_t vdIoCtxCopyTo(PVDIOCTX pIoCtx, uint8_t *pbData, size_t cbData)
 {
-    return RTSgBufCopyToBuf(&pIoCtx->SgBuf, pbData, cbData);
+    return RTSgBufCopyToBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
 }
 
@@ -1517 +1587 @@
 static size_t vdIoCtxCopyFrom(PVDIOCTX pIoCtx, uint8_t *pbData, size_t cbData)
 {
-    return RTSgBufCopyFromBuf(&pIoCtx->SgBuf, pbData, cbData);
+    return RTSgBufCopyFromBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
 }
 
 static size_t vdIoCtxSet(PVDIOCTX pIoCtx, uint8_t ch, size_t cbData)
 {
-    return RTSgBufSet(&pIoCtx->SgBuf, ch, cbData);
+    return RTSgBufSet(&pIoCtx->Req.Io.SgBuf, ch, cbData);
 }
 
@@ -1534 +1604 @@
     RTCritSectEnter(&pDisk->CritSect);
 
-    if (   !pIoCtx->cbTransferLeft
-        && !pIoCtx->cMetaTransfersPending
+    if (   !pIoCtx->cMetaTransfersPending
         && !pIoCtx->cDataTransfersPending
         && !pIoCtx->pfnIoCtxTransfer)
@@ -1567 +1636 @@
         /* Call the transfer function advancing to the next while there is no error. */
         while (   pIoCtx->pfnIoCtxTransfer
+               && !pIoCtx->cMetaTransfersPending
                && RT_SUCCESS(rc))
         {
@@ -1582 +1652 @@
 
     if (   RT_SUCCESS(rc)
-        && !pIoCtx->cbTransferLeft
         && !pIoCtx->cMetaTransfersPending
         && !pIoCtx->cDataTransfersPending)
@@ -1607 +1676 @@
     RTCritSectLeave(&pDisk->CritSect);
 
-    LogFlowFunc(("pIoCtx=%#p rc=%Rrc cbTransferLeft=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
-                 pIoCtx, rc, pIoCtx->cbTransferLeft, pIoCtx->cMetaTransfersPending,
+    LogFlowFunc(("pIoCtx=%#p rc=%Rrc cDataTransfersPending=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
+                 pIoCtx, rc, pIoCtx->cDataTransfersPending, pIoCtx->cMetaTransfersPending,
                  pIoCtx->fComplete));
 
@@ -1711 +1780 @@
 {
     int rc;
-    size_t cbToRead     = pIoCtx->cbTransfer;
-    uint64_t uOffset    = pIoCtx->uOffset;
+    size_t cbToRead     = pIoCtx->Req.Io.cbTransfer;
+    uint64_t uOffset    = pIoCtx->Req.Io.uOffset;
     PVDIMAGE pCurrImage = NULL;
     size_t cbThisRead;
@@ -1719 +1788 @@
     do
     {
-        pCurrImage = pIoCtx->pImageCur;
+        pCurrImage = pIoCtx->Req.Io.pImageCur;
 
         /* Search for image with allocated block. Do not attempt to read more
@@ -1751 +1820 @@
             /* No image in the chain contains the data for the block. */
             vdIoCtxSet(pIoCtx, '\0', cbThisRead);
-            ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisRead);
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbThisRead);
             rc = VINF_SUCCESS;
         }
@@ -1774 +1843 @@
     {
         /* Save the current state. */
-        pIoCtx->uOffset    = uOffset;
-        pIoCtx->cbTransfer = cbToRead;
-        pIoCtx->pImageCur  = pCurrImage ? pCurrImage : pIoCtx->pImageStart;
+        pIoCtx->Req.Io.uOffset    = uOffset;
+        pIoCtx->Req.Io.cbTransfer = cbToRead;
+        pIoCtx->Req.Io.pImageCur  = pCurrImage ? pCurrImage : pIoCtx->Req.Io.pImageStart;
     }
 
@@ -2240 +2309 @@
     int rc = VINF_SUCCESS;
     PVBOXHDD pDisk = pIoCtx->pDisk;
-    PVDIMAGE pImage = pIoCtx->pImageCur;
+    PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
 
     rc = pImage->Backend->pfnAsyncFlush(pImage->pBackendData, pIoCtx);
@@ -2284 +2353 @@
                     else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
                     {
+                        ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
                         pIoCtx->fBlocked = true;
                     }
@@ -2394 +2464 @@
 static int vdWriteHelperOptimizedCommitAsync(PVDIOCTX pIoCtx)
 {
-    int rc = VINF_SUCCESS;
-    PVDIMAGE pImage = pIoCtx->pImageStart;
-    size_t cbPreRead      = pIoCtx->Type.Child.cbPreRead;
-    size_t cbPostRead     = pIoCtx->Type.Child.cbPostRead;
-    size_t cbThisWrite    = pIoCtx->Type.Child.cbTransferParent;
+    int rc             = VINF_SUCCESS;
+    PVDIMAGE pImage    = pIoCtx->Req.Io.pImageStart;
+    size_t cbPreRead   = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead  = pIoCtx->Type.Child.cbPostRead;
+    size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
 
     LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
     rc = pImage->Backend->pfnAsyncWrite(pImage->pBackendData,
-                                        pIoCtx->uOffset - cbPreRead,
+                                        pIoCtx->Req.Io.uOffset - cbPreRead,
                                         cbPreRead + cbThisWrite + cbPostRead,
                                         pIoCtx, NULL, &cbPreRead, &cbPostRead, 0);
@@ -2423 +2493 @@
 {
     int rc = VINF_SUCCESS;
-    PVDIMAGE pImage = pIoCtx->pImageCur;
+    PVDIMAGE pImage       = pIoCtx->Req.Io.pImageCur;
     size_t cbThisWrite    = 0;
     size_t cbPreRead      = pIoCtx->Type.Child.cbPreRead;
@@ -2436 +2506 @@
     AssertPtr(pIoCtxParent);
     Assert(!pIoCtxParent->pIoCtxParent);
-    Assert(!pIoCtx->cbTransferLeft && !pIoCtx->cMetaTransfersPending);
+    Assert(!pIoCtx->Req.Io.cbTransferLeft && !pIoCtx->cMetaTransfersPending);
 
     vdIoCtxChildReset(pIoCtx);
     cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
-    RTSgBufAdvance(&pIoCtx->SgBuf, cbPreRead);
+    RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
 
     /* Check if the write would modify anything in this block. */
-    if (!RTSgBufCmp(&pIoCtx->SgBuf, &pIoCtxParent->SgBuf, cbThisWrite))
+    if (!RTSgBufCmp(&pIoCtx->Req.Io.SgBuf, &pIoCtxParent->Req.Io.SgBuf, cbThisWrite))
     {
         RTSGBUF SgBufSrcTmp;
 
-        RTSgBufClone(&SgBufSrcTmp, &pIoCtxParent->SgBuf);
+        RTSgBufClone(&SgBufSrcTmp, &pIoCtxParent->Req.Io.SgBuf);
         RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
-        RTSgBufAdvance(&pIoCtx->SgBuf, cbThisWrite);
-
-        if (!cbWriteCopy || !RTSgBufCmp(&pIoCtx->SgBuf, &SgBufSrcTmp, cbWriteCopy))
+        RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbThisWrite);
+
+        if (!cbWriteCopy || !RTSgBufCmp(&pIoCtx->Req.Io.SgBuf, &SgBufSrcTmp, cbWriteCopy))
         {
             /* Block is completely unchanged, so no need to write anything. */
             LogFlowFunc(("Block didn't changed\n"));
-            ASMAtomicWriteU32(&pIoCtx->cbTransferLeft, 0);
-            RTSgBufAdvance(&pIoCtxParent->SgBuf, cbThisWrite);
+            ASMAtomicWriteU32(&pIoCtx->Req.Io.cbTransferLeft, 0);
+            RTSgBufAdvance(&pIoCtxParent->Req.Io.SgBuf, cbThisWrite);
             return VINF_VD_ASYNC_IO_FINISHED;
         }
@@ -2462 +2532 @@
 
     /* Copy the data to the right place in the buffer. */
-    RTSgBufReset(&pIoCtx->SgBuf);
-    RTSgBufAdvance(&pIoCtx->SgBuf, cbPreRead);
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
     vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
 
@@ -2478 +2548 @@
             RTSGBUF SgBufParentTmp;
 
-            RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->SgBuf);
-            RTSgBufCopy(&pIoCtx->SgBuf, &SgBufParentTmp, cbWriteCopy);
+            RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->Req.Io.SgBuf);
+            RTSgBufCopy(&pIoCtx->Req.Io.SgBuf, &SgBufParentTmp, cbWriteCopy);
         }
 
@@ -2486 +2556 @@
         if (cbFill)
         {
-            RTSgBufAdvance(&pIoCtx->SgBuf, cbReadImage);
+            RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbReadImage);
             vdIoCtxSet(pIoCtx, '\0', cbFill);
         }
@@ -2492 +2562 @@
 
     /* Write the full block to the virtual disk. */
-    RTSgBufReset(&pIoCtx->SgBuf);
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
     pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedCommitAsync;
 
@@ -2504 +2574 @@
     LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
 
-    if (pIoCtx->cbTransferLeft)
+    if (pIoCtx->Req.Io.cbTransferLeft)
         rc = vdReadHelperAsync(pIoCtx);
 
     if (   RT_SUCCESS(rc)
-        && (   pIoCtx->cbTransferLeft
+        && (   pIoCtx->Req.Io.cbTransferLeft
             || pIoCtx->cMetaTransfersPending))
         rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -2563 +2633 @@
     /* Read the entire data of the block so that we can compare whether it will
      * be modified by the write or not. */
-    pIoCtx->cbTransferLeft = cbPreRead + cbThisWrite + cbPostRead - cbFill;
-    pIoCtx->cbTransfer     = pIoCtx->cbTransferLeft;
-    pIoCtx->uOffset       -= cbPreRead;
+    pIoCtx->Req.Io.cbTransferLeft = cbPreRead + cbThisWrite + cbPostRead - cbFill;
+    pIoCtx->Req.Io.cbTransfer     = pIoCtx->Req.Io.cbTransferLeft;
+    pIoCtx->Req.Io.uOffset       -= cbPreRead;
 
     /* Next step */
@@ -2579 +2649 @@
 {
     int rc;
-    size_t cbWrite   = pIoCtx->cbTransfer;
-    uint64_t uOffset = pIoCtx->uOffset;
-    PVDIMAGE pImage  = pIoCtx->pImageCur;
+    size_t cbWrite   = pIoCtx->Req.Io.cbTransfer;
+    uint64_t uOffset = pIoCtx->Req.Io.uOffset;
+    PVDIMAGE pImage  = pIoCtx->Req.Io.pImageCur;
     PVBOXHDD pDisk   = pIoCtx->pDisk;
     unsigned fWrite;
@@ -2589 +2659 @@
     rc = vdSetModifiedFlagAsync(pDisk, pIoCtx);
     if (RT_FAILURE(rc)) /* Includes I/O in progress. */
+        return rc;
+
+    rc = vdDiscardSetRangeAllocated(pDisk, uOffset, cbWrite);
+    if (RT_FAILURE(rc))
         return rc;
 
@@ -2659 +2733 @@
                 {
                     LogFlow(("Child write request completed\n"));
-                    Assert(pIoCtx->cbTransferLeft >= cbThisWrite);
-                    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbThisWrite);
+                    Assert(pIoCtx->Req.Io.cbTransferLeft >= cbThisWrite);
+                    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbThisWrite);
                     vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs*/ );
                     vdIoCtxFree(pDisk, pIoCtxWrite);
@@ -2669 +2743 @@
                 {
                     LogFlow(("Child write pending\n"));
+                    ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
                     pIoCtx->fBlocked = true;
                     rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
@@ -2708 +2783 @@
             rc = VINF_SUCCESS;
 
-        pIoCtx->uOffset    = uOffset;
-        pIoCtx->cbTransfer = cbWrite;
+        pIoCtx->Req.Io.uOffset    = uOffset;
+        pIoCtx->Req.Io.cbTransfer = cbWrite;
     }
 
@@ -2722 +2797 @@
     int rc = VINF_SUCCESS;
     PVBOXHDD pDisk = pIoCtx->pDisk;
-    PVDIMAGE pImage = pIoCtx->pImageCur;
+    PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
 
     rc = vdIoCtxLockDisk(pDisk, pIoCtx);
@@ -2735 +2810 @@
     }
 
+    return rc;
+}
+
+/**
+ * Async discard helper - discards a whole block which is recorded in the block
+ * tree.
+ *
+ * @returns VBox status code.
+ * @param   pIoCtx    The I/O context to operate on.
+ */
+static int vdDiscardWholeBlockAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVBOXHDD pDisk = pIoCtx->pDisk;
+    PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
+    PVDDISCARDBLOCK pBlock = pIoCtx->Req.Discard.pBlock;
+    size_t cbPreAllocated, cbPostAllocated, cbActuallyDiscarded;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    AssertPtr(pBlock);
+
+    rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData, pIoCtx,
+                                                pBlock->Core.Key, pBlock->cbDiscard,
+                                                &cbPreAllocated, &cbPostAllocated,
+                                                &cbActuallyDiscarded, NULL, 0);
+    Assert(rc != VERR_VD_DISCARD_ALIGNMENT_NOT_MET);
+    Assert(!cbPreAllocated);
+    Assert(!cbPostAllocated);
+    Assert(cbActuallyDiscarded == pBlock->cbDiscard || RT_FAILURE(rc));
+
+    /* Remove the block on success. */
+    if (   RT_SUCCESS(rc)
+        || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
+        Assert(pBlockRemove == pBlock);
+
+        pDiscard->cbDiscarding -= pBlock->cbDiscard;
+        RTListNodeRemove(&pBlock->NodeLru);
+        RTMemFree(pBlock->pbmAllocated);
+        RTMemFree(pBlock);
+        pIoCtx->Req.Discard.pBlock = NULL;/* Safety precaution. */
+        pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync; /* Next part. */
+        rc = VINF_SUCCESS;
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Removes the least recently used blocks from the waiting list until
+ * the new value is reached - version for async I/O.
+ *
+ * @returns VBox status code.
+ * @param   pDisk              VD disk container.
+ * @param   pDiscard           The discard state.
+ * @param   cbDiscardingNew    How many bytes should be waiting on success.
+ *                             The number of bytes waiting can be less.
+ */
+static int vdDiscardRemoveBlocksAsync(PVBOXHDD pDisk, PVDIOCTX pIoCtx, size_t cbDiscardingNew)
+{
+    int rc = VINF_SUCCESS;
+    PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
+
+    LogFlowFunc(("pDisk=%#p pDiscard=%#p cbDiscardingNew=%zu\n",
+                 pDisk, pDiscard, cbDiscardingNew));
+
+    while (pDiscard->cbDiscarding > cbDiscardingNew)
+    {
+        PVDDISCARDBLOCK pBlock = RTListGetLast(&pDiscard->ListLru, VDDISCARDBLOCK, NodeLru);
+
+        Assert(!RTListIsEmpty(&pDiscard->ListLru));
+
+        /* Go over the allocation bitmap and mark all discarded sectors as unused. */
+        uint64_t offStart = pBlock->Core.Key;
+        uint32_t idxStart = 0;
+        size_t cbLeft = pBlock->cbDiscard;
+        bool fAllocated = ASMBitTest(pBlock->pbmAllocated, idxStart);
+        uint32_t cSectors = pBlock->cbDiscard / 512;
+
+        while (cbLeft > 0)
+        {
+            int32_t idxEnd;
+            size_t cbThis = cbLeft;
+
+            if (fAllocated)
+            {
+                /* Check for the first unallocated bit. */
+                idxEnd = ASMBitNextClear(pBlock->pbmAllocated, cSectors, idxStart);
+                if (idxEnd != -1)
+                {
+                    cbThis = (idxEnd - idxStart) * 512;
+                    fAllocated = false;
+                }
+            }
+            else
+            {
+                /* Mark as unused and check for the first set bit. */
+                idxEnd = ASMBitNextSet(pBlock->pbmAllocated, cSectors, idxStart);
+                if (idxEnd != -1)
+                    cbThis = (idxEnd - idxStart) * 512;
+
+                rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData, pIoCtx,
+                                                            offStart, cbThis, NULL, NULL, &cbThis,
+                                                            NULL, VD_DISCARD_MARK_UNUSED);
+                if (      RT_FAILURE(rc)
+                    && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    break;
+
+                fAllocated = true;
+            }
+
+            idxStart  = idxEnd;
+            offStart += cbThis;
+            cbLeft   -= cbThis;
+        }
+
+        if (   RT_FAILURE(rc)
+            && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            break;
+
+        PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
+        Assert(pBlockRemove == pBlock);
+        RTListNodeRemove(&pBlock->NodeLru);
+
+        pDiscard->cbDiscarding -= pBlock->cbDiscard;
+        RTMemFree(pBlock->pbmAllocated);
+        RTMemFree(pBlock);
+    }
+
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+
+    Assert(RT_FAILURE(rc) || pDiscard->cbDiscarding <= cbDiscardingNew);
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Async discard helper - discards the current range if there is no matching
+ * block in the tree.
+ *
+ * @returns VBox status code.
+ * @param   pIoCtx    The I/O context to operate on.
+ */
+static int vdDiscardCurrentRangeAsync(PVDIOCTX pIoCtx)
+{
+    PVBOXHDD        pDisk         = pIoCtx->pDisk;
+    PVDDISCARDSTATE pDiscard      = pDisk->pDiscard;
+    uint64_t        offStart      = pIoCtx->Req.Discard.offCur;
+    size_t          cbThisDiscard = pIoCtx->Req.Discard.cbThisDiscard;
+    void *pbmAllocated = NULL;
+    size_t cbPreAllocated, cbPostAllocated;
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    /* No block found, try to discard using the backend first. */
+    rc = pDisk->pLast->Backend->pfnAsyncDiscard(pDisk->pLast->pBackendData, pIoCtx,
+                                                offStart, cbThisDiscard, &cbPreAllocated,
+                                                &cbPostAllocated, &cbThisDiscard,
+                                                &pbmAllocated, 0);
+    if (rc == VERR_VD_DISCARD_ALIGNMENT_NOT_MET)
+    {
+        /* Create new discard block. */
+        PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTMemAllocZ(sizeof(VDDISCARDBLOCK));
+        if (pBlock)
+        {
+            pBlock->Core.Key     = offStart - cbPreAllocated;
+            pBlock->Core.KeyLast = offStart + cbThisDiscard + cbPostAllocated - 1;
+            pBlock->cbDiscard    = cbPreAllocated + cbThisDiscard + cbPostAllocated;
+            pBlock->pbmAllocated = pbmAllocated;
+            bool fInserted = RTAvlrU64Insert(pDiscard->pTreeBlocks, &pBlock->Core);
+            Assert(fInserted);
+
+            RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
+            pDiscard->cbDiscarding += pBlock->cbDiscard;
+
+            Assert(pIoCtx->Req.Discard.cbDiscardLeft >= cbThisDiscard);
+            pIoCtx->Req.Discard.cbDiscardLeft -= cbThisDiscard;
+            pIoCtx->Req.Discard.offCur        += cbThisDiscard;
+            pIoCtx->Req.Discard.cbThisDiscard = cbThisDiscard;
+
+            if (pDiscard->cbDiscarding > VD_DISCARD_REMOVE_THRESHOLD)
+                rc = vdDiscardRemoveBlocksAsync(pDisk, pIoCtx, VD_DISCARD_REMOVE_THRESHOLD);
+            else
+                rc = VINF_SUCCESS;
+
+            if (RT_SUCCESS(rc))
+                pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync; /* Next part. */
+        }
+        else
+        {
+            RTMemFree(pbmAllocated);
+            rc = VERR_NO_MEMORY;
+        }
+    }
+    else if (   RT_SUCCESS(rc)
+             || rc == VERR_VD_ASYNC_IO_IN_PROGRESS) /* Save state and andvance to next range. */
+    {
+        Assert(pIoCtx->Req.Discard.cbDiscardLeft >= cbThisDiscard);
+        pIoCtx->Req.Discard.cbDiscardLeft -= cbThisDiscard;
+        pIoCtx->Req.Discard.offCur        += cbThisDiscard;
+        pIoCtx->Req.Discard.cbThisDiscard  = cbThisDiscard;
+        pIoCtx->pfnIoCtxTransferNext       = vdDiscardHelperAsync;
+        rc = VINF_SUCCESS;
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Async discard helper - entry point.
+ *
+ * @returns VBox status code.
+ * @param   pIoCtx    The I/O context to operate on.
+ */
+static int vdDiscardHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc             = VINF_SUCCESS;
+    PVBOXHDD  pDisk    = pIoCtx->pDisk;
+    PCRTRANGE paRanges = pIoCtx->Req.Discard.paRanges;
+    unsigned  cRanges  = pIoCtx->Req.Discard.cRanges;
+    PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    /* Check if the I/O context processed all ranges. */
+    if (   pIoCtx->Req.Discard.idxRange == cRanges
+        && !pIoCtx->Req.Discard.cbDiscardLeft)
+    {
+        LogFlowFunc(("All ranges discarded, completing\n"));
+        vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessDeferredReqs*/);
+        return VINF_SUCCESS;
+    }
+
+    if (pDisk->pIoCtxLockOwner != pIoCtx)
+        rc = vdIoCtxLockDisk(pDisk, pIoCtx);
+
+    if (RT_SUCCESS(rc))
+    {
+        uint64_t offStart      = pIoCtx->Req.Discard.offCur;
+        size_t   cbDiscardLeft = pIoCtx->Req.Discard.cbDiscardLeft;
+        size_t   cbThisDiscard;
+
+        if (RT_UNLIKELY(!pDiscard))
+        {
+            pDiscard = vdDiscardStateCreate();
+            if (!pDiscard)
+                return VERR_NO_MEMORY;
+
+            pDisk->pDiscard = pDiscard;
+        }
+
+        if (!pIoCtx->Req.Discard.cbDiscardLeft)
+        {
+            offStart      = paRanges[pIoCtx->Req.Discard.idxRange].offStart;
+            cbDiscardLeft = paRanges[pIoCtx->Req.Discard.idxRange].cbRange;
+            LogFlowFunc(("New range descriptor loaded (%u) offStart=%llu cbDiscard=%zu\n",
+                         pIoCtx->Req.Discard.idxRange, offStart, cbDiscardLeft));
+            pIoCtx->Req.Discard.idxRange++;
+        }
+
+        /* Look for a matching block in the AVL tree first. */
+        PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, false);
+        if (!pBlock || pBlock->Core.KeyLast < offStart)
+        {
+            PVDDISCARDBLOCK pBlockAbove = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, offStart, true);
+
+            /* Clip range to remain in the current block. */
+            if (pBlockAbove)
+                cbThisDiscard = RT_MIN(cbDiscardLeft, pBlockAbove->Core.KeyLast - offStart + 1);
+            else
+                cbThisDiscard = cbDiscardLeft;
+
+            Assert(!(cbThisDiscard % 512));
+            pIoCtx->Req.Discard.pBlock   = NULL;
+            pIoCtx->pfnIoCtxTransferNext = vdDiscardCurrentRangeAsync;
+        }
+        else
+        {
+            /* Range lies partly in the block, update allocation bitmap. */
+            int32_t idxStart, idxEnd;
+
+            cbThisDiscard = RT_MIN(cbDiscardLeft, pBlock->Core.KeyLast - offStart + 1);
+
+            AssertPtr(pBlock);
+
+            Assert(!(cbThisDiscard % 512));
+            Assert(!((offStart - pBlock->Core.Key) % 512));
+
+            idxStart = (offStart - pBlock->Core.Key) / 512;
+            idxEnd = idxStart + (cbThisDiscard / 512);
+
+            ASMBitClearRange(pBlock->pbmAllocated, idxStart, idxEnd);
+
+            cbDiscardLeft -= cbThisDiscard;
+            offStart      += cbThisDiscard;
+
+            /* Call the backend to discard the block if it is completely unallocated now. */
+            if (ASMBitFirstSet((volatile void *)pBlock->pbmAllocated, pBlock->cbDiscard / 512) == -1)
+            {
+                pIoCtx->Req.Discard.pBlock   = pBlock;
+                pIoCtx->pfnIoCtxTransferNext = vdDiscardWholeBlockAsync;
+                rc = VINF_SUCCESS;
+            }
+            else
+            {
+                RTListNodeRemove(&pBlock->NodeLru);
+                RTListPrepend(&pDiscard->ListLru, &pBlock->NodeLru);
+
+                /* Start with next range. */
+                pIoCtx->pfnIoCtxTransferNext = vdDiscardHelperAsync;
+                rc = VINF_SUCCESS;
+            }
+        }
+
+        /* Save state in the context. */
+        pIoCtx->Req.Discard.offCur        = offStart;
+        pIoCtx->Req.Discard.cbDiscardLeft = cbDiscardLeft;
+        pIoCtx->Req.Discard.cbThisDiscard = cbThisDiscard;
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
     return rc;
 }
@@ -3160 +3563 @@
                     ASMAtomicCmpXchgS32(&pIoCtxParent->rcReq, pIoCtx->rcReq, VINF_SUCCESS);
 
+                ASMAtomicDecU32(&pIoCtxParent->cDataTransfersPending);
+
                 if (pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE)
                 {
@@ -3166 +3571 @@
 
                     /* Update the parent state. */
-                    Assert(pIoCtxParent->cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
-                    ASMAtomicSubU32(&pIoCtxParent->cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
+                    Assert(pIoCtxParent->Req.Io.cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
+                    ASMAtomicSubU32(&pIoCtxParent->Req.Io.cbTransferLeft, pIoCtx->Type.Child.cbTransferParent);
                 }
                 else
@@ -3251 +3656 @@
                     vdThreadFinishWrite(pDisk);
                 }
-                else if (pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE)
+                else if (   pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE
+                         || pIoCtx->enmTxDir == VDIOCTXTXDIR_DISCARD)
                     vdThreadFinishWrite(pDisk);
                 else
@@ -3289 +3695 @@
 
     RTCritSectEnter(&pDisk->CritSect);
-    Assert(pIoCtx->cbTransferLeft >= cbTransfer);
-    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbTransfer);
+    Assert(pIoCtx->Req.Io.cbTransferLeft >= cbTransfer);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTransfer);
     ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
 
@@ -3565 +3971 @@
         size_t   cbTaskRead = 0;
 
-        cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->SgBuf, aSeg, &cSegments, cbRead);
+        cbTaskRead = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbRead);
 
         Assert(cSegments > 0);
@@ -3593 +3999 @@
         if (RT_SUCCESS(rc))
         {
-            AssertMsg(cbTaskRead <= pIoCtx->cbTransferLeft, ("Impossible!\n"));
-            ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbTaskRead);
+            AssertMsg(cbTaskRead <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskRead);
             ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
             vdIoTaskFree(pDisk, pIoTask);
@@ -3637 +4043 @@
         size_t   cbTaskWrite = 0;
 
-        cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->SgBuf, aSeg, &cSegments, cbWrite);
+        cbTaskWrite = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, aSeg, &cSegments, cbWrite);
 
         Assert(cSegments > 0);
@@ -3665 +4071 @@
         if (RT_SUCCESS(rc))
         {
-            AssertMsg(cbTaskWrite <= pIoCtx->cbTransferLeft, ("Impossible!\n"));
-            ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbTaskWrite);
+            AssertMsg(cbTaskWrite <= pIoCtx->Req.Io.cbTransferLeft, ("Impossible!\n"));
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbTaskWrite);
             ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
             vdIoTaskFree(pDisk, pIoTask);
@@ -3969 +4375 @@
     Assert(cbCopied == cbBuf);
 
-    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbCopied);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbCopied);
 
     return cbCopied;
@@ -3986 +4392 @@
     Assert(cbCopied == cbBuf);
 
-    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbCopied);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbCopied);
 
     return cbCopied;
@@ -4002 +4408 @@
     Assert(cbSet == cb);
 
-    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbSet);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbSet);
 
     return cbSet;
@@ -4017 +4423 @@
     VD_THREAD_IS_CRITSECT_OWNER(pDisk);
 
-    cbCreated = RTSgBufSegArrayCreate(&pIoCtx->SgBuf, paSeg, pcSeg, cbData);
+    cbCreated = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, paSeg, pcSeg, cbData);
     Assert(!paSeg || cbData == cbCreated);
 
@@ -4043 +4449 @@
     /* Continue */
     pIoCtx->fBlocked = false;
-    ASMAtomicSubU32(&pIoCtx->cbTransferLeft, cbCompleted);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, cbCompleted);
 
     /* Clear the pointer to next transfer function in case we have nothing to transfer anymore.
      * @todo: Find a better way to prevent vdIoCtxContinue from calling the read/write helper again. */
-    if (!pIoCtx->cbTransferLeft)
+    if (!pIoCtx->Req.Io.cbTransferLeft)
         pIoCtx->pfnIoCtxTransfer = NULL;
 
@@ -8617 +9023 @@
 
 
-VBOXDDU_DECL(int) VDDiscardRanges(PVBOXHDD pDisk, PCVDRANGE paRanges, unsigned cRanges)
+VBOXDDU_DECL(int) VDDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges)
 {
     int rc;
@@ -8861 +9267 @@
 }
 
+VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVBOXHDD pDisk, PCRTRANGE paRanges, unsigned cRanges,
+                                       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;
+
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
+                                     pfnComplete, pvUser1, pvUser2, NULL,
+                                     vdDiscardHelperAsync);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        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) && (   rc == VINF_VD_ASYNC_IO_FINISHED
+                                    || rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+

trunk/src/VBox/Storage/VDI.cpp

@@ -57 +57 @@
 static int  vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock);
 static int  vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx);
-static int  vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock, PVDIOCTX pIoCtx);
+static int  vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock, PVDIOCTX pIoCtx,
+                                    bool fUpdateHdr);
 
 /**
@@ -849 +850 @@
  */
 static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock,
-                                   PVDIOCTX pIoCtx)
-{
+                                   PVDIOCTX pIoCtx, bool fUpdateHdr)
+{
+    int rc = VINF_SUCCESS;
+
     /* Update image header. */
-    int rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
+    if (fUpdateHdr)
+        rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
+
     if (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
     {
@@ -964 +969 @@
         rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, cbImage - pImage->cbTotalBlockData);
     } while (0);
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Completion callback for meta/userdata reads or writes.
+ *
+ * @return  VBox status code.
+ *          VINF_SUCCESS if everything was successful and the transfer can continue.
+ *          VERR_VD_ASYNC_IO_IN_PROGRESS if there is another data transfer pending.
+ * @param   pBackendData    The opaque backend data.
+ * @param   pIoCtx          I/O context associated with this request.
+ * @param   pvUser          Opaque user data passed during a read/write request.
+ * @param   rcReq           Status code for the completed request.
+ */
+static DECLCALLBACK(int) vdiDiscardBlockAsyncUpdate(void *pBackendData, PVDIOCTX pIoCtx, void *pvUser, int rcReq)
+{
+    int rc = VINF_SUCCESS;
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
+    PVDIBLOCKDISCARDASYNC pDiscardAsync = (PVDIBLOCKDISCARDASYNC)pvUser;
+
+    switch (pDiscardAsync->enmState)
+    {
+        case VDIBLOCKDISCARDSTATE_READ_BLOCK:
+        {
+            PVDMETAXFER pMetaXfer;
+            uint64_t u64Offset = (uint64_t)pDiscardAsync->idxLastBlock * pImage->cbTotalBlockData + pImage->offStartData;
+            rc = vdIfIoIntFileReadMetaAsync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                            pDiscardAsync->pvBlock, pImage->cbTotalBlockData, pIoCtx,
+                                            &pMetaXfer, vdiDiscardBlockAsyncUpdate, pDiscardAsync);
+            if (RT_FAILURE(rc))
+                break;
+
+            /* Release immediately and go to next step. */
+            vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
+            pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_WRITE_BLOCK;
+        }
+        case VDIBLOCKDISCARDSTATE_WRITE_BLOCK:
+        {
+            /* Block read complete. Write to the new location (discarded block). */
+            uint64_t u64Offset = (uint64_t)pDiscardAsync->ptrBlockDiscard * pImage->cbTotalBlockData + pImage->offStartData;
+            rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                             pDiscardAsync->pvBlock, pImage->cbTotalBlockData, pIoCtx,
+                                             vdiDiscardBlockAsyncUpdate, pDiscardAsync);
+
+            pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_UPDATE_METADATA;
+            if (RT_FAILURE(rc))
+                break;
+        }
+        case VDIBLOCKDISCARDSTATE_UPDATE_METADATA:
+        {
+            int rc2;
+            uint64_t cbImage;
+
+            /* Block write complete. Update metadata. */
+            pImage->paBlocksRev[pDiscardAsync->idxLastBlock] = VDI_IMAGE_BLOCK_FREE;
+            pImage->paBlocks[pDiscardAsync->uBlock] = VDI_IMAGE_BLOCK_ZERO;
+
+            if (pDiscardAsync->idxLastBlock != pDiscardAsync->ptrBlockDiscard)
+            {
+                pImage->paBlocks[pDiscardAsync->uBlockLast] = pDiscardAsync->ptrBlockDiscard;
+                pImage->paBlocksRev[pDiscardAsync->ptrBlockDiscard] = pDiscardAsync->uBlockLast;
+
+                rc = vdiUpdateBlockInfoAsync(pImage, pDiscardAsync->uBlockLast, pIoCtx, false /* fUpdateHdr */);
+                if (   RT_FAILURE(rc)
+                    && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    break;
+            }
+
+            setImageBlocksAllocated(&pImage->Header, pDiscardAsync->idxLastBlock);
+            rc = vdiUpdateBlockInfoAsync(pImage, pDiscardAsync->uBlock, pIoCtx, true /* fUpdateHdr */);
+            if (   RT_FAILURE(rc)
+                && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+                break;
+
+            /* Set new file size. */
+            rc2 = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbImage);
+            if (RT_FAILURE(rc2))
+                break;
+
+            LogFlowFunc(("Set new size %llu\n", cbImage - pImage->cbTotalBlockData));
+            rc2 = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, cbImage - pImage->cbTotalBlockData);
+            if (RT_FAILURE(rc2))
+                rc = rc2;
+
+            /* Free discard state. */
+            RTMemFree(pDiscardAsync->pvBlock);
+            RTMemFree(pDiscardAsync);
+            break;
+        }
+        default:
+            AssertMsgFailed(("Invalid state %d\n", pDiscardAsync->enmState));
+    }
+
+    if (rc == VERR_VD_NOT_ENOUGH_METADATA)
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+
+    return rc;
+}
+
+/**
+ * Internal: Discard a whole block from the image filling the created hole with
+ * data from another block - async I/O version.
+ *
+ * @returns VBox status code.
+ * @param   pImage    VDI image instance data.
+ * @param   pIoCtx    I/O context associated with this request.
+ * @param   uBlock    The block to discard.
+ * @param   pvBlock   Memory to use for the I/O.
+ */
+static int vdiDiscardBlockAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
+                                unsigned uBlock, void *pvBlock)
+{
+    int rc = VINF_SUCCESS;
+    PVDIBLOCKDISCARDASYNC pDiscardAsync = NULL;
+
+    LogFlowFunc(("pImage=%#p uBlock=%u pvBlock=%#p\n",
+                 pImage, uBlock, pvBlock));
+
+    pDiscardAsync = (PVDIBLOCKDISCARDASYNC)RTMemAllocZ(sizeof(VDIBLOCKDISCARDASYNC));
+    if (RT_UNLIKELY(!pDiscardAsync))
+        return VERR_NO_MEMORY;
+
+    /* Init block discard state. */
+    pDiscardAsync->uBlock  = uBlock;
+    pDiscardAsync->pvBlock = pvBlock;
+    pDiscardAsync->ptrBlockDiscard = pImage->paBlocks[uBlock];
+    pDiscardAsync->idxLastBlock = getImageBlocksAllocated(&pImage->Header) - 1;
+    pDiscardAsync->uBlockLast = pImage->paBlocksRev[pDiscardAsync->idxLastBlock];
+
+    /*
+     * The block is empty, remove it.
+     * Read the last block of the image first.
+     */
+    if (pDiscardAsync->idxLastBlock != pDiscardAsync->ptrBlockDiscard)
+    {
+        LogFlowFunc(("Moving block [%u]=%u into [%u]=%u\n",
+                     pDiscardAsync->uBlockLast, pDiscardAsync->idxLastBlock,
+                     uBlock, pImage->paBlocks[uBlock]));
+        pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_READ_BLOCK;
+    }
+    else
+    {
+        pDiscardAsync->enmState = VDIBLOCKDISCARDSTATE_UPDATE_METADATA; /* Start immediately to shrink the image. */
+        LogFlowFunc(("Discard last block [%u]=%u\n", uBlock, pImage->paBlocks[uBlock]));
+    }
+
+    /* Call the update callback directly. */
+    rc = vdiDiscardBlockAsyncUpdate(pImage, pIoCtx, pDiscardAsync, VINF_SUCCESS);
 
     LogFlowFunc(("returns rc=%Rrc\n", rc));
@@ -2181 +2336 @@
                 setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
 
-                rc = vdiUpdateBlockInfoAsync(pImage, uBlock, pIoCtx);
+                rc = vdiUpdateBlockInfoAsync(pImage, uBlock, pIoCtx, true /* fUpdateHdr */);
                 if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
                     goto out;
@@ -2780 +2935 @@
     if (pvBlock)
         RTMemFree(pvBlock);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+/** @copydoc VBOXHDDBACKEND::pfnDiscard */
+static DECLCALLBACK(int) vdiAsyncDiscard(void *pBackendData, PVDIOCTX pIoCtx,
+                                         uint64_t uOffset, size_t cbDiscard,
+                                         size_t *pcbPreAllocated,
+                                         size_t *pcbPostAllocated,
+                                         size_t *pcbActuallyDiscarded,
+                                         void   **ppbmAllocationBitmap,
+                                         unsigned fDiscard)
+{
+    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
+    unsigned uBlock;
+    unsigned offDiscard;
+    int rc = VINF_SUCCESS;
+    void *pvBlock = NULL;
+
+    LogFlowFunc(("pBackendData=%#p pIoCtx=%#p uOffset=%llu cbDiscard=%zu pcbPreAllocated=%#p pcbPostAllocated=%#p pcbActuallyDiscarded=%#p ppbmAllocationBitmap=%#p fDiscard=%#x\n",
+                 pBackendData, pIoCtx, uOffset, cbDiscard, pcbPreAllocated, pcbPostAllocated, pcbActuallyDiscarded, ppbmAllocationBitmap, fDiscard));
+
+    AssertPtr(pImage);
+    Assert(!(uOffset % 512));
+    Assert(!(cbDiscard % 512));
+
+    AssertMsgReturn(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                    ("Image is readonly\n"), VERR_VD_IMAGE_READ_ONLY);
+    AssertMsgReturn(   uOffset + cbDiscard <= getImageDiskSize(&pImage->Header)
+                    && cbDiscard,
+                    ("Invalid parameters uOffset=%llu cbDiscard=%zu\n",
+                     uOffset, cbDiscard),
+                     VERR_INVALID_PARAMETER);
+
+    do
+    {
+        AssertMsgBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                           ("Image is opened readonly\n"),
+                           rc = VERR_VD_IMAGE_READ_ONLY);
+
+        AssertMsgBreakStmt(cbDiscard,
+                           ("cbDiscard=%u\n", cbDiscard),
+                           rc = VERR_INVALID_PARAMETER);
+
+        /* Calculate starting block number and offset inside it. */
+        uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
+        offDiscard = (unsigned)uOffset & pImage->uBlockMask;
+
+        /* Clip range to at most the rest of the block. */
+        cbDiscard = RT_MIN(cbDiscard, getImageBlockSize(&pImage->Header) - offDiscard);
+        Assert(!(cbDiscard % 512));
+
+        if (pcbPreAllocated)
+            *pcbPreAllocated = 0;
+
+        if (pcbPostAllocated)
+            *pcbPostAllocated = 0;
+
+        if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
+        {
+            uint8_t *pbBlockData;
+            size_t cbPreAllocated, cbPostAllocated;
+
+            cbPreAllocated = offDiscard % getImageBlockSize(&pImage->Header);
+            cbPostAllocated = getImageBlockSize(&pImage->Header) - cbDiscard - cbPreAllocated;
+
+            /* Read the block data. */
+            pvBlock = RTMemAlloc(pImage->cbTotalBlockData);
+            if (!pvBlock)
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+
+            if (!cbPreAllocated && !cbPostAllocated)
+            {
+                /*
+                 * Discarding a whole block, don't check for allocated sectors.
+                 * It is possible to just remove the whole block which avoids
+                 * one read and checking the whole block for data.
+                 */
+                rc = vdiDiscardBlockAsync(pImage, pIoCtx, uBlock, pvBlock);
+            }
+            else if (fDiscard & VD_DISCARD_MARK_UNUSED)
+            {
+                /* Just zero out the given range. */
+                memset(pvBlock, 0, cbDiscard);
+
+                uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData + offDiscard;
+                rc = vdIfIoIntFileWriteMetaAsync(pImage->pIfIo, pImage->pStorage,
+                                                 u64Offset, pvBlock, cbDiscard, pIoCtx,
+                                                 NULL, NULL);
+                RTMemFree(pvBlock);
+            }
+            else
+            {
+                /*
+                 * Read complete block as metadata, the I/O context has no memory buffer
+                 * and we need to access the content directly anyway.
+                 */
+                PVDMETAXFER pMetaXfer;
+                pbBlockData = (uint8_t *)pvBlock + pImage->offStartBlockData;
+
+                uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData + pImage->offStartData;
+                rc = vdIfIoIntFileReadMetaAsync(pImage->pIfIo, pImage->pStorage, u64Offset,
+                                                pbBlockData, pImage->cbTotalBlockData,
+                                                pIoCtx, &pMetaXfer, NULL, NULL);
+                if (RT_FAILURE(rc))
+                    break;
+
+                vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
+
+                /* Clear data. */
+                memset(pbBlockData + offDiscard , 0, cbDiscard);
+
+                Assert(!(cbDiscard % 4));
+                Assert(getImageBlockSize(&pImage->Header) * 8 <= UINT32_MAX);
+                if (ASMBitFirstSet((volatile void *)pbBlockData, getImageBlockSize(&pImage->Header) * 8) == -1)
+                    rc = vdiDiscardBlockAsync(pImage, pIoCtx, uBlock, pvBlock);
+                else
+                {
+                    /* Block has data, create allocation bitmap. */
+                    *pcbPreAllocated = cbPreAllocated;
+                    *pcbPostAllocated = cbPostAllocated;
+                    *ppbmAllocationBitmap = vdiAllocationBitmapCreate(pbBlockData, getImageBlockSize(&pImage->Header));
+                    if (RT_UNLIKELY(!*ppbmAllocationBitmap))
+                        rc = VERR_NO_MEMORY;
+                    else
+                        rc = VERR_VD_DISCARD_ALIGNMENT_NOT_MET;
+
+                    RTMemFree(pvBlock);
+                }
+            } /* if: no complete block discarded */
+        } /* if: Block is allocated. */
+        /* else: nothing to do. */
+    } while (0);
+
+    if (pcbActuallyDiscarded)
+        *pcbActuallyDiscarded = cbDiscard;
 
     LogFlowFunc(("returns %Rrc\n", rc));
@@ -2883 +3178 @@
     vdiResize,
     /* pfnDiscard */
-    vdiDiscard
+    vdiDiscard,
+    /* pfnAsyncDiscard */
+    vdiAsyncDiscard
 };

trunk/src/VBox/Storage/VDICore.h

@@ -556 +556 @@
 } VDIIMAGEDESC, *PVDIIMAGEDESC;
 
+/**
+ * Async block discard states.
+ */
+typedef enum VDIBLOCKDISCARDSTATE
+{
+    /** Invalid. */
+    VDIBLOCKDISCARDSTATE_INVALID = 0,
+    /** Read the last block. */
+    VDIBLOCKDISCARDSTATE_READ_BLOCK,
+    /** Write block into the hole. */
+    VDIBLOCKDISCARDSTATE_WRITE_BLOCK,
+    /** Update metadata. */
+    VDIBLOCKDISCARDSTATE_UPDATE_METADATA,
+    /** 32bit hack. */
+    VDIBLOCKDISCARDSTATE_32BIT_HACK = 0x7fffffff
+} VDIBLOCKDISCARDSTATE;
+
+/**
+ * Async block discard structure.
+ */
+typedef struct VDIBLOCKDISCARDASYNC
+{
+    /** State of the block discard. */
+    VDIBLOCKDISCARDSTATE    enmState;
+    /** Pointer to the block data. */
+    void                   *pvBlock;
+    /** Block index in the block table. */
+    unsigned                uBlock;
+    /** Block pointer to the block to discard. */
+    VDIIMAGEBLOCKPOINTER    ptrBlockDiscard;
+    /** Index of the last block in the reverse block table. */
+    unsigned                idxLastBlock;
+    /** Index of the last block in the block table (gathered from the reverse block table). */
+    unsigned                uBlockLast;
+} VDIBLOCKDISCARDASYNC, *PVDIBLOCKDISCARDASYNC;
+
 #endif
 

trunk/src/VBox/Storage/VHD.cpp

@@ -3141 +3141 @@
     vhdResize,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/VMDK.cpp

@@ -7192 +7192 @@
     NULL,
     /* pfnDiscard */
+    NULL,
+    /* pfnAsyncDiscard */
     NULL
 };

trunk/src/VBox/Storage/testcase/tstVDIo.cpp

@@ -134 +134 @@
     VDIOREQTXDIR_READ = 0,
     VDIOREQTXDIR_WRITE,
-    VDIOREQTXDIR_FLUSH
+    VDIOREQTXDIR_FLUSH,
+    VDIOREQTXDIR_DISCARD
 } VDIOREQTXDIR;
 
@@ -143 +144 @@
 {
     /** Transfer type. */
-    VDIOREQTXDIR enmTxDir;
+    VDIOREQTXDIR  enmTxDir;
     /** slot index. */
-    unsigned  idx;
+    unsigned      idx;
     /** Start offset. */
-    uint64_t  off;
+    uint64_t      off;
     /** Size to transfer. */
-    size_t    cbReq;
+    size_t        cbReq;
     /** S/G Buffer */
-    RTSGBUF   SgBuf;
+    RTSGBUF       SgBuf;
     /** Data segment */
-    RTSGSEG   DataSeg;
+    RTSGSEG       DataSeg;
     /** Flag whether the request is outstanding or not. */
     volatile bool fOutstanding;
@@ -385 +386 @@
     /* pcszName    chId enmType                          fFlags */
     {"disk",       'd', VDSCRIPTARGTYPE_STRING,          VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"off",        'o', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY},
-    {"size",       's', VDSCRIPTARGTYPE_UNSIGNED_NUMBER, VDSCRIPTARGDESC_FLAG_MANDATORY},
+    {"async",      'a', VDSCRIPTARGTYPE_BOOL,            0},
+    {"ranges",     'r', VDSCRIPTARGTYPE_STRING, VDSCRIPTARGDESC_FLAG_MANDATORY}
 };
 
@@ -955 +956 @@
                                             break;
                                         }
+                                        case VDIOREQTXDIR_DISCARD:
+                                            AssertMsgFailed(("Invalid\n"));
                                     }
 
@@ -983 +986 @@
                                             break;
                                         }
+                                        case VDIOREQTXDIR_DISCARD:
+                                            AssertMsgFailed(("Invalid\n"));
                                     }
 
@@ -1028 +1033 @@
                                             case VDIOREQTXDIR_FLUSH:
                                                 break;
+                                            case VDIOREQTXDIR_DISCARD:
+                                                AssertMsgFailed(("Invalid\n"));
                                         }
 
@@ -1264 +1271 @@
     const char *pcszDisk = NULL;
     PVDDISK pDisk = NULL;
-    uint64_t off;
-    size_t cbDiscard;
+    bool fAsync = false;
+    const char *pcszRanges = NULL;
 
     for (unsigned i = 0; i < cScriptArgs; i++)
@@ -1276 +1283 @@
                 break;
             }
-            case 'o':
-            {
-                off = paScriptArgs[i].u.u64;
-                break;
-            }
-            case 's':
-            {
-                cbDiscard = paScriptArgs[i].u.u64;
-                break;
-            }
-
+            case 'a':
+            {
+                fAsync = paScriptArgs[i].u.fFlag;
+                break;
+            }
+            case 'r':
+            {
+                pcszRanges = paScriptArgs[i].u.pcszString;
+                break;
+            }
             default:
                 AssertMsgFailed(("Invalid argument given!\n"));
         }
-
-        if (RT_FAILURE(rc))
-            break;
-    }
-
-    if (RT_SUCCESS(rc))
-    {
-        pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
-        if (!pDisk)
-            rc = VERR_NOT_FOUND;
-        else
-        {
-            VDRANGE Range;
-
-            Range.offStart = off;
-            Range.cbRange = cbDiscard;
-
-            rc = VDDiscardRanges(pDisk->pVD, &Range, 1);
+    }
+
+    pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
+    if (!pDisk)
+        rc = VERR_NOT_FOUND;
+    else
+    {
+        unsigned cRanges = 0;
+        PRTRANGE paRanges = NULL;
+
+        /*
+         * Parse the range string which should look like this:
+         * n,off1,cb1,off2,cb2,...
+         *
+         * <n> gives the number of ranges in the string and every off<i>,cb<i>
+         * pair afterwards is a start offset + number of bytes to discard entry.
+         */
+        do
+        {
+            rc = RTStrToUInt32Ex(pcszRanges, (char **)&pcszRanges, 10, &cRanges);
+            if (RT_FAILURE(rc) && (rc != VWRN_TRAILING_CHARS))
+                break;
+
+            if (!cRanges)
+            {
+                rc = VERR_INVALID_PARAMETER;
+                break;
+            }
+
+            paRanges = (PRTRANGE)RTMemAllocZ(cRanges * sizeof(RTRANGE));
+            if (!paRanges)
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+
+            if (*pcszRanges != ',')
+            {
+                rc = VERR_INVALID_PARAMETER;
+                break;
+            }
+
+            pcszRanges++;
+
+            /* Retrieve each pair from the string. */
+            for (unsigned i = 0; i < cRanges; i++)
+            {
+                uint64_t off;
+                uint32_t cb;
+
+                rc = RTStrToUInt64Ex(pcszRanges, (char **)&pcszRanges, 10, &off);
+                if (RT_FAILURE(rc) && (rc != VWRN_TRAILING_CHARS))
+                    break;
+
+                if (*pcszRanges != ',')
+                {
+                    switch (*pcszRanges)
+                    {
+                        case 'k':
+                        case 'K':
+                        {
+                            off *= _1K;
+                            break;
+                        }
+                        case 'm':
+                        case 'M':
+                        {
+                            off *= _1M;
+                            break;
+                        }
+                        case 'g':
+                        case 'G':
+                        {
+                            off *= _1G;
+                            break;
+                        }
+                        default:
+                        {
+                            RTPrintf("Invalid size suffix '%s'\n", pcszRanges);
+                            rc = VERR_INVALID_PARAMETER;
+                        }
+                    }
+                    if (RT_SUCCESS(rc))
+                        pcszRanges++;
+                }
+
+                if (*pcszRanges != ',')
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                    break;
+                }
+
+                pcszRanges++;
+
+                rc = RTStrToUInt32Ex(pcszRanges, (char **)&pcszRanges, 10, &cb);
+                if (RT_FAILURE(rc) && (rc != VWRN_TRAILING_CHARS))
+                    break;
+
+                if (*pcszRanges != ',')
+                {
+                    switch (*pcszRanges)
+                    {
+                        case 'k':
+                        case 'K':
+                        {
+                            cb *= _1K;
+                            break;
+                        }
+                        case 'm':
+                        case 'M':
+                        {
+                            cb *= _1M;
+                            break;
+                        }
+                        case 'g':
+                        case 'G':
+                        {
+                            cb *= _1G;
+                            break;
+                        }
+                        default:
+                        {
+                            RTPrintf("Invalid size suffix '%s'\n", pcszRanges);
+                            rc = VERR_INVALID_PARAMETER;
+                        }
+                    }
+                    if (RT_SUCCESS(rc))
+                        pcszRanges++;
+                }
+
+                if (   *pcszRanges != ','
+                    && !(i == cRanges - 1 && *pcszRanges == '\0'))
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                    break;
+                }
+
+                pcszRanges++;
+
+                paRanges[i].offStart = off;
+                paRanges[i].cbRange  = cb;
+            }
+        } while (0);
+
+        if (RT_SUCCESS(rc))
+        {
+            if (!fAsync)
+                rc = VDDiscardRanges(pDisk->pVD, paRanges, cRanges);
+            else
+            {
+                VDIOREQ IoReq;
+                RTSEMEVENT EventSem;
+
+                rc = RTSemEventCreate(&EventSem);
+                if (RT_SUCCESS(rc))
+                {
+                    memset(&IoReq, 0, sizeof(VDIOREQ));
+                    IoReq.enmTxDir = VDIOREQTXDIR_FLUSH;
+                    IoReq.pvUser   = pDisk;
+                    IoReq.idx      = 0;
+                    rc = VDAsyncDiscardRanges(pDisk->pVD, paRanges, cRanges, tstVDIoTestReqComplete, &IoReq, EventSem);
+                    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    {
+                        rc = RTSemEventWait(EventSem, RT_INDEFINITE_WAIT);
+                        AssertRC(rc);
+                    }
+                    else if (rc == VINF_VD_ASYNC_IO_FINISHED)
+                        rc = VINF_SUCCESS;
+
+                    RTSemEventDestroy(EventSem);
+                }
+            }
+
             if (   RT_SUCCESS(rc)
                 && pDisk->pMemDiskVerify)
             {
-                void *pv = RTMemAllocZ(cbDiscard);
-                if (pv)
+                for (unsigned i = 0; i < cRanges; i++)
                 {
-                    RTSGSEG SgSeg;
-                    RTSGBUF SgBuf;
-
-                    SgSeg.pvSeg = pv;
-                    SgSeg.cbSeg = cbDiscard;
-                    RTSgBufInit(&SgBuf, &SgSeg, 1);
-                    rc = VDMemDiskWrite(pDisk->pMemDiskVerify, off, cbDiscard, &SgBuf);
-                    RTMemFree(pv);
+                    void *pv = RTMemAllocZ(paRanges[i].cbRange);
+                    if (pv)
+                    {
+                        RTSGSEG SgSeg;
+                        RTSGBUF SgBuf;
+
+                        SgSeg.pvSeg = pv;
+                        SgSeg.cbSeg = paRanges[i].cbRange;
+                        RTSgBufInit(&SgBuf, &SgSeg, 1);
+                        rc = VDMemDiskWrite(pDisk->pMemDiskVerify, paRanges[i].offStart, paRanges[i].cbRange, &SgBuf);
+                        RTMemFree(pv);
+                    }
+                    else
+                    {
+                        rc = VERR_NO_MEMORY;
+                        break;
+                    }
                 }
-                else
-                    rc = VERR_NO_MEMORY;
-            }
-        }
+            }
+        }
+
+        if (paRanges)
+            RTMemFree(paRanges);
     }
 
@@ -1647 +1817 @@
                     case VDDBGIOLOGREQ_DISCARD:
                     {
-                        PVDRANGE paRanges = NULL;
+                        PRTRANGE paRanges = NULL;
                         unsigned cRanges = 0;
 
@@ -2726 +2896 @@
             }
             case VDIOREQTXDIR_FLUSH:
+            case VDIOREQTXDIR_DISCARD:
                 break;
         }