Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 9676 insertions, 0 deletions

diff --git a/src/VBox/Storage/VD.cpp b/src/VBox/Storage/VD.cpp
new file mode 100644
index 00000000..d0ec71dd
--- /dev/null
+++ b/src/VBox/Storage/VD.cpp
@@ -0,0 +1,9676 @@
+/* $Id: VD.cpp $ */
+/** @file
+ * VD - Virtual disk container implementation.
+ */
+
+/*
+ * Copyright (C) 2006-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_VD
+#include <VBox/vd.h>
+#include <VBox/err.h>
+#include <VBox/sup.h>
+#include <VBox/log.h>
+
+#include <iprt/alloc.h>
+#include <iprt/assert.h>
+#include <iprt/uuid.h>
+#include <iprt/file.h>
+#include <iprt/string.h>
+#include <iprt/asm.h>
+#include <iprt/param.h>
+#include <iprt/path.h>
+#include <iprt/sg.h>
+#include <iprt/semaphore.h>
+#include <iprt/vector.h>
+
+#include "VDInternal.h"
+
+/** Buffer size used for merging images. */
+#define VD_MERGE_BUFFER_SIZE    (16 * _1M)
+
+/** Maximum number of segments in one I/O task. */
+#define VD_IO_TASK_SEGMENTS_MAX 64
+
+/** Threshold after not recently used blocks are removed from the list. */
+#define VD_DISCARD_REMOVE_THRESHOLD (10 * _1M) /** @todo experiment */
+
+/**
+ * VD async I/O interface storage descriptor.
+ */
+typedef struct VDIIOFALLBACKSTORAGE
+{
+    /** File handle. */
+    RTFILE              File;
+    /** Completion callback. */
+    PFNVDCOMPLETED      pfnCompleted;
+    /** Thread for async access. */
+    RTTHREAD            ThreadAsync;
+} VDIIOFALLBACKSTORAGE, *PVDIIOFALLBACKSTORAGE;
+
+/**
+ * uModified bit flags.
+ */
+#define VD_IMAGE_MODIFIED_FLAG                  RT_BIT(0)
+#define VD_IMAGE_MODIFIED_FIRST                 RT_BIT(1)
+#define VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE   RT_BIT(2)
+
+
+# define VD_IS_LOCKED(a_pDisk) \
+    do \
+    { \
+        NOREF(a_pDisk); \
+        AssertMsg((a_pDisk)->fLocked, \
+                  ("Lock not held\n"));\
+    } while(0)
+
+/**
+ * VBox parent read descriptor, used internally for compaction.
+ */
+typedef struct VDPARENTSTATEDESC
+{
+    /** Pointer to disk descriptor. */
+    PVDISK pDisk;
+    /** Pointer to image descriptor. */
+    PVDIMAGE pImage;
+} VDPARENTSTATEDESC, *PVDPARENTSTATEDESC;
+
+/**
+ * Transfer direction.
+ */
+typedef enum VDIOCTXTXDIR
+{
+    /** Read */
+    VDIOCTXTXDIR_READ = 0,
+    /** Write */
+    VDIOCTXTXDIR_WRITE,
+    /** Flush */
+    VDIOCTXTXDIR_FLUSH,
+    /** Discard */
+    VDIOCTXTXDIR_DISCARD,
+    /** 32bit hack */
+    VDIOCTXTXDIR_32BIT_HACK = 0x7fffffff
+} VDIOCTXTXDIR, *PVDIOCTXTXDIR;
+
+/** Transfer function */
+typedef DECLCALLBACKTYPE(int, FNVDIOCTXTRANSFER ,(PVDIOCTX pIoCtx));
+/** Pointer to a transfer function. */
+typedef FNVDIOCTXTRANSFER *PFNVDIOCTXTRANSFER;
+
+/**
+ * I/O context
+ */
+typedef struct VDIOCTX
+{
+    /** Pointer to the next I/O context. */
+    struct VDIOCTX * volatile    pIoCtxNext;
+    /** Disk this is request is for. */
+    PVDISK                       pDisk;
+    /** Return code. */
+    int                          rcReq;
+    /** Various flags for the I/O context. */
+    uint32_t                     fFlags;
+    /** Number of data transfers currently pending. */
+    volatile uint32_t            cDataTransfersPending;
+    /** How many meta data transfers are pending. */
+    volatile uint32_t            cMetaTransfersPending;
+    /** Flag whether the request finished */
+    volatile bool                fComplete;
+    /** Temporary allocated memory which is freed
+     * when the context completes. */
+    void                        *pvAllocation;
+    /** Transfer function. */
+    PFNVDIOCTXTRANSFER           pfnIoCtxTransfer;
+    /** 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;
+            /** Number of bytes to clear in the buffer before the current read. */
+            size_t               cbBufClear;
+            /** Number of images to read. */
+            unsigned             cImagesRead;
+            /** Override for the parent image to start reading from. */
+            PVDIMAGE             pImageParentOverride;
+            /** Original offset of the transfer - required for filtering read requests. */
+            uint64_t             uOffsetXferOrig;
+            /** Original size of the transfer - required for fitlering read requests. */
+            size_t               cbXferOrig;
+        } 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;
+    /** Type dependent data (root/child) */
+    union
+    {
+        /** Root data */
+        struct
+        {
+            /** Completion callback */
+            PFNVDASYNCTRANSFERCOMPLETE   pfnComplete;
+            /** User argument 1 passed on completion. */
+            void                        *pvUser1;
+            /** User argument 2 passed on completion. */
+            void                        *pvUser2;
+        } Root;
+        /** Child data */
+        struct
+        {
+            /** Saved start offset */
+            uint64_t                     uOffsetSaved;
+            /** Saved transfer size */
+            size_t                       cbTransferLeftSaved;
+            /** Number of bytes transferred from the parent if this context completes. */
+            size_t                       cbTransferParent;
+            /** Number of bytes to pre read */
+            size_t                       cbPreRead;
+            /** Number of bytes to post read. */
+            size_t                       cbPostRead;
+            /** Number of bytes to write left in the parent. */
+            size_t                       cbWriteParent;
+            /** Write type dependent data. */
+            union
+            {
+                /** Optimized */
+                struct
+                {
+                    /** Bytes to fill to satisfy the block size. Not part of the virtual disk. */
+                    size_t               cbFill;
+                    /** Bytes to copy instead of reading from the parent */
+                    size_t               cbWriteCopy;
+                    /** Bytes to read from the image. */
+                    size_t               cbReadImage;
+                } Optimized;
+            } Write;
+        } Child;
+    } Type;
+} VDIOCTX;
+
+/** Default flags for an I/O context, i.e. unblocked and async. */
+#define VDIOCTX_FLAGS_DEFAULT                         (0)
+/** 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)
+/** Flag whether the read should update the cache. */
+#define VDIOCTX_FLAGS_READ_UPDATE_CACHE      RT_BIT_32(2)
+/** Flag whether free blocks should be zeroed.
+ * If false and no image has data for sepcified
+ * range VERR_VD_BLOCK_FREE is returned for the I/O context.
+ * Note that unallocated blocks are still zeroed
+ * if at least one image has valid data for a part
+ * of the range.
+ */
+#define VDIOCTX_FLAGS_ZERO_FREE_BLOCKS       RT_BIT_32(3)
+/** Don't free the I/O context when complete because
+ * it was alloacted elsewhere (stack, ...). */
+#define VDIOCTX_FLAGS_DONT_FREE              RT_BIT_32(4)
+/** Don't set the modified flag for this I/O context when writing. */
+#define VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG RT_BIT_32(5)
+/** The write filter was applied already and shouldn't be applied a second time.
+ * Used at the beginning of vdWriteHelperAsync() because it might be called
+ * multiple times.
+ */
+#define VDIOCTX_FLAGS_WRITE_FILTER_APPLIED   RT_BIT_32(6)
+
+/** NIL I/O context pointer value. */
+#define NIL_VDIOCTX ((PVDIOCTX)0)
+
+/**
+ * List node for deferred I/O contexts.
+ */
+typedef struct VDIOCTXDEFERRED
+{
+    /** Node in the list of deferred requests.
+     * A request can be deferred if the image is growing
+     * and the request accesses the same range or if
+     * the backend needs to read or write metadata from the disk
+     * before it can continue. */
+    RTLISTNODE NodeDeferred;
+    /** I/O context this entry points to. */
+    PVDIOCTX   pIoCtx;
+} VDIOCTXDEFERRED, *PVDIOCTXDEFERRED;
+
+/**
+ * I/O task.
+ */
+typedef struct VDIOTASK
+{
+    /** Next I/O task waiting in the list. */
+    struct VDIOTASK * volatile   pNext;
+    /** Storage this task belongs to. */
+    PVDIOSTORAGE                 pIoStorage;
+    /** Optional completion callback. */
+    PFNVDXFERCOMPLETED           pfnComplete;
+    /** Opaque user data. */
+    void                        *pvUser;
+    /** Completion status code for the task. */
+    int                          rcReq;
+    /** Flag whether this is a meta data transfer. */
+    bool                         fMeta;
+    /** Type dependent data. */
+    union
+    {
+        /** User data transfer. */
+        struct
+        {
+            /** Number of bytes this task transferred. */
+            uint32_t             cbTransfer;
+            /** Pointer to the I/O context the task belongs. */
+            PVDIOCTX             pIoCtx;
+        } User;
+        /** Meta data transfer. */
+        struct
+        {
+            /** Meta transfer this task is for. */
+            PVDMETAXFER          pMetaXfer;
+        } Meta;
+    } Type;
+} VDIOTASK;
+
+/**
+ * Storage handle.
+ */
+typedef struct VDIOSTORAGE
+{
+    /** Image I/O state this storage handle belongs to. */
+    PVDIO                        pVDIo;
+    /** AVL tree for pending async metadata transfers. */
+    PAVLRFOFFTREE                pTreeMetaXfers;
+    /** Storage handle */
+    void                        *pStorage;
+} VDIOSTORAGE;
+
+/**
+ *  Metadata transfer.
+ *
+ *  @note This entry can't be freed if either the list is not empty or
+ *  the reference counter is not 0.
+ *  The assumption is that the backends don't need to read huge amounts of
+ *  metadata to complete a transfer so the additional memory overhead should
+ *  be relatively small.
+ */
+typedef struct VDMETAXFER
+{
+    /** AVL core for fast search (the file offset is the key) */
+    AVLRFOFFNODECORE Core;
+    /** I/O storage for this transfer. */
+    PVDIOSTORAGE     pIoStorage;
+    /** Flags. */
+    uint32_t         fFlags;
+    /** List of I/O contexts waiting for this metadata transfer to complete. */
+    RTLISTNODE       ListIoCtxWaiting;
+    /** Number of references to this entry. */
+    unsigned         cRefs;
+    /** Size of the data stored with this entry. */
+    size_t           cbMeta;
+    /** Shadow buffer which is used in case a write is still active and other
+     * writes update the shadow buffer. */
+    uint8_t         *pbDataShw;
+    /** List of I/O contexts updating the shadow buffer while there is a write
+     * in progress. */
+    RTLISTNODE       ListIoCtxShwWrites;
+    /** Data stored - variable size. */
+    uint8_t          abData[1];
+} VDMETAXFER;
+
+/**
+ * The transfer direction for the metadata.
+ */
+#define VDMETAXFER_TXDIR_MASK  0x3
+#define VDMETAXFER_TXDIR_NONE  0x0
+#define VDMETAXFER_TXDIR_WRITE 0x1
+#define VDMETAXFER_TXDIR_READ  0x2
+#define VDMETAXFER_TXDIR_FLUSH 0x3
+#define VDMETAXFER_TXDIR_GET(flags)      ((flags) & VDMETAXFER_TXDIR_MASK)
+#define VDMETAXFER_TXDIR_SET(flags, dir) ((flags) = (flags & ~VDMETAXFER_TXDIR_MASK) | (dir))
+
+/** Forward declaration of the async discard helper. */
+static DECLCALLBACK(int) vdDiscardHelperAsync(PVDIOCTX pIoCtx);
+static DECLCALLBACK(int) vdWriteHelperAsync(PVDIOCTX pIoCtx);
+static void vdDiskProcessBlockedIoCtx(PVDISK pDisk);
+static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc);
+static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq);
+
+/**
+ * internal: issue error message.
+ */
+static int vdError(PVDISK pDisk, int rc, RT_SRC_POS_DECL,
+                   const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    if (pDisk->pInterfaceError)
+        pDisk->pInterfaceError->pfnError(pDisk->pInterfaceError->Core.pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, start read.
+ */
+DECLINLINE(int) vdThreadStartRead(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
+        rc = pDisk->pInterfaceThreadSync->pfnStartRead(pDisk->pInterfaceThreadSync->Core.pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, finish read.
+ */
+DECLINLINE(int) vdThreadFinishRead(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
+        rc = pDisk->pInterfaceThreadSync->pfnFinishRead(pDisk->pInterfaceThreadSync->Core.pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, start write.
+ */
+DECLINLINE(int) vdThreadStartWrite(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
+        rc = pDisk->pInterfaceThreadSync->pfnStartWrite(pDisk->pInterfaceThreadSync->Core.pvUser);
+    return rc;
+}
+
+/**
+ * internal: thread synchronization, finish write.
+ */
+DECLINLINE(int) vdThreadFinishWrite(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    if (RT_UNLIKELY(pDisk->pInterfaceThreadSync))
+        rc = pDisk->pInterfaceThreadSync->pfnFinishWrite(pDisk->pInterfaceThreadSync->Core.pvUser);
+    return rc;
+}
+
+/**
+ * internal: add image structure to the end of images list.
+ */
+static void vdAddImageToList(PVDISK pDisk, PVDIMAGE pImage)
+{
+    pImage->pPrev = NULL;
+    pImage->pNext = NULL;
+
+    if (pDisk->pBase)
+    {
+        Assert(pDisk->cImages > 0);
+        pImage->pPrev = pDisk->pLast;
+        pDisk->pLast->pNext = pImage;
+        pDisk->pLast = pImage;
+    }
+    else
+    {
+        Assert(pDisk->cImages == 0);
+        pDisk->pBase = pImage;
+        pDisk->pLast = pImage;
+    }
+
+    pDisk->cImages++;
+}
+
+/**
+ * internal: remove image structure from the images list.
+ */
+static void vdRemoveImageFromList(PVDISK pDisk, PVDIMAGE pImage)
+{
+    Assert(pDisk->cImages > 0);
+
+    if (pImage->pPrev)
+        pImage->pPrev->pNext = pImage->pNext;
+    else
+        pDisk->pBase = pImage->pNext;
+
+    if (pImage->pNext)
+        pImage->pNext->pPrev = pImage->pPrev;
+    else
+        pDisk->pLast = pImage->pPrev;
+
+    pImage->pPrev = NULL;
+    pImage->pNext = NULL;
+
+    pDisk->cImages--;
+}
+
+/**
+ * Release a referene to the filter decrementing the counter and destroying the filter
+ * when the counter reaches zero.
+ *
+ * @returns The new reference count.
+ * @param   pFilter    The filter to release.
+ */
+static uint32_t vdFilterRelease(PVDFILTER pFilter)
+{
+    uint32_t cRefs = ASMAtomicDecU32(&pFilter->cRefs);
+    if (!cRefs)
+    {
+        pFilter->pBackend->pfnDestroy(pFilter->pvBackendData);
+        RTMemFree(pFilter);
+    }
+
+    return cRefs;
+}
+
+/**
+ * Increments the reference counter of the given filter.
+ *
+ * @return The new reference count.
+ * @param  pFilter    The filter.
+ */
+static uint32_t vdFilterRetain(PVDFILTER pFilter)
+{
+    return ASMAtomicIncU32(&pFilter->cRefs);
+}
+
+/**
+ * internal: find image by index into the images list.
+ */
+static PVDIMAGE vdGetImageByNumber(PVDISK pDisk, unsigned nImage)
+{
+    PVDIMAGE pImage = pDisk->pBase;
+    if (nImage == VD_LAST_IMAGE)
+        return pDisk->pLast;
+    while (pImage && nImage)
+    {
+        pImage = pImage->pNext;
+        nImage--;
+    }
+    return pImage;
+}
+
+/**
+ * Creates a new region list from the given one converting to match the flags if necessary.
+ *
+ * @returns VBox status code.
+ * @param   pRegionList     The region list to convert from.
+ * @param   fFlags          The flags for the new region list.
+ * @param   ppRegionList    Where to store the new region list on success.
+ */
+static int vdRegionListConv(PCVDREGIONLIST pRegionList, uint32_t fFlags, PPVDREGIONLIST ppRegionList)
+{
+    int rc = VINF_SUCCESS;
+    PVDREGIONLIST pRegionListNew = (PVDREGIONLIST)RTMemDup(pRegionList,
+                                                           RT_UOFFSETOF_DYN(VDREGIONLIST, aRegions[pRegionList->cRegions]));
+    if (RT_LIKELY(pRegionListNew))
+    {
+        /* Do we have to convert anything? */
+        if (pRegionList->fFlags != fFlags)
+        {
+            uint64_t offRegionNext = 0;
+
+            pRegionListNew->fFlags = fFlags;
+            for (unsigned i = 0; i < pRegionListNew->cRegions; i++)
+            {
+                PVDREGIONDESC pRegion = &pRegionListNew->aRegions[i];
+
+                if (   (fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
+                    && !(pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS))
+                {
+                    Assert(!(pRegion->cRegionBlocksOrBytes % pRegion->cbBlock));
+
+                    /* Convert from bytes to logical blocks. */
+                    pRegion->offRegion            = offRegionNext;
+                    pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes / pRegion->cbBlock;
+                    offRegionNext += pRegion->cRegionBlocksOrBytes;
+                }
+                else
+                {
+                    /* Convert from logical blocks to bytes. */
+                    pRegion->offRegion            = offRegionNext;
+                    pRegion->cRegionBlocksOrBytes = pRegion->cRegionBlocksOrBytes * pRegion->cbBlock;
+                    offRegionNext += pRegion->cRegionBlocksOrBytes;
+                }
+            }
+        }
+
+        *ppRegionList = pRegionListNew;
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    return rc;
+}
+
+/**
+ * Returns the virtual size of the image in bytes.
+ *
+ * @returns Size of the given image in bytes.
+ * @param   pImage          The image to get the size from.
+ */
+static uint64_t vdImageGetSize(PVDIMAGE pImage)
+{
+    uint64_t cbImage = 0;
+
+    if (pImage->cbImage == VD_IMAGE_SIZE_UNINITIALIZED)
+    {
+        PCVDREGIONLIST pRegionList = NULL;
+        int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
+        if (RT_SUCCESS(rc))
+        {
+            if (pRegionList->fFlags & VD_REGION_LIST_F_LOC_SIZE_BLOCKS)
+            {
+                PVDREGIONLIST pRegionListConv = NULL;
+                rc = vdRegionListConv(pRegionList, 0, &pRegionListConv);
+                if (RT_SUCCESS(rc))
+                {
+                    for (uint32_t i = 0; i < pRegionListConv->cRegions; i++)
+                        cbImage += pRegionListConv->aRegions[i].cRegionBlocksOrBytes;
+
+                    VDRegionListFree(pRegionListConv);
+                }
+            }
+            else
+                for (uint32_t i = 0; i < pRegionList->cRegions; i++)
+                    cbImage += pRegionList->aRegions[i].cRegionBlocksOrBytes;
+
+            AssertPtr(pImage->Backend->pfnRegionListRelease);
+            pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
+            pImage->cbImage = cbImage; /* Cache the value. */
+        }
+    }
+    else
+        cbImage = pImage->cbImage;
+
+    return cbImage;
+}
+
+/**
+ * Applies the filter chain to the given write request.
+ *
+ * @returns VBox status code.
+ * @param   pDisk    The HDD container.
+ * @param   uOffset  The start offset of the write.
+ * @param   cbWrite  Number of bytes to write.
+ * @param   pIoCtx   The I/O context associated with the request.
+ */
+static int vdFilterChainApplyWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
+                                   PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    PVDFILTER pFilter;
+    RTListForEach(&pDisk->ListFilterChainWrite, pFilter, VDFILTER, ListNodeChainWrite)
+    {
+        rc = pFilter->pBackend->pfnFilterWrite(pFilter->pvBackendData, uOffset, cbWrite, pIoCtx);
+        if (RT_FAILURE(rc))
+            break;
+        /* Reset S/G buffer for the next filter. */
+        RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    }
+
+    return rc;
+}
+
+/**
+ * Applies the filter chain to the given read request.
+ *
+ * @returns VBox status code.
+ * @param   pDisk    The HDD container.
+ * @param   uOffset  The start offset of the read.
+ * @param   cbRead   Number of bytes read.
+ * @param   pIoCtx   The I/O context associated with the request.
+ */
+static int vdFilterChainApplyRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
+                                  PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    /* Reset buffer before starting. */
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+
+    PVDFILTER pFilter;
+    RTListForEach(&pDisk->ListFilterChainRead, pFilter, VDFILTER, ListNodeChainRead)
+    {
+        rc = pFilter->pBackend->pfnFilterRead(pFilter->pvBackendData, uOffset, cbRead, pIoCtx);
+        if (RT_FAILURE(rc))
+            break;
+        /* Reset S/G buffer for the next filter. */
+        RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    }
+
+    return rc;
+}
+
+DECLINLINE(void) vdIoCtxRootComplete(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    if (   RT_SUCCESS(pIoCtx->rcReq)
+        && pIoCtx->enmTxDir == VDIOCTXTXDIR_READ)
+        pIoCtx->rcReq = vdFilterChainApplyRead(pDisk, pIoCtx->Req.Io.uOffsetXferOrig,
+                                               pIoCtx->Req.Io.cbXferOrig, pIoCtx);
+
+    pIoCtx->Type.Root.pfnComplete(pIoCtx->Type.Root.pvUser1,
+                                  pIoCtx->Type.Root.pvUser2,
+                                  pIoCtx->rcReq);
+}
+
+/**
+ * Initialize the structure members of a given I/O context.
+ */
+DECLINLINE(void) vdIoCtxInit(PVDIOCTX pIoCtx, PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
+                             uint64_t uOffset, size_t cbTransfer, PVDIMAGE pImageStart,
+                             PCRTSGBUF pSgBuf, void *pvAllocation,
+                             PFNVDIOCTXTRANSFER pfnIoCtxTransfer, uint32_t fFlags)
+{
+    pIoCtx->pDisk                 = pDisk;
+    pIoCtx->enmTxDir              = enmTxDir;
+    pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbTransfer; Assert((uint32_t)cbTransfer == cbTransfer);
+    pIoCtx->Req.Io.uOffset        = uOffset;
+    pIoCtx->Req.Io.cbTransfer     = cbTransfer;
+    pIoCtx->Req.Io.pImageStart    = pImageStart;
+    pIoCtx->Req.Io.pImageCur      = pImageStart;
+    pIoCtx->Req.Io.cbBufClear     = 0;
+    pIoCtx->Req.Io.pImageParentOverride = NULL;
+    pIoCtx->Req.Io.uOffsetXferOrig      = uOffset;
+    pIoCtx->Req.Io.cbXferOrig           = cbTransfer;
+    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;
+    pIoCtx->pIoCtxParent          = NULL;
+
+    /* There is no S/G list for a flush request. */
+    if (   enmTxDir != VDIOCTXTXDIR_FLUSH
+        && enmTxDir != VDIOCTXTXDIR_DISCARD)
+        RTSgBufClone(&pIoCtx->Req.Io.SgBuf, pSgBuf);
+    else
+        memset(&pIoCtx->Req.Io.SgBuf, 0, sizeof(RTSGBUF));
+}
+
+/**
+ * Internal: Tries to read the desired range from the given cache.
+ *
+ * @returns VBox status code.
+ * @retval  VERR_VD_BLOCK_FREE if the block is not in the cache.
+ *          pcbRead will be set to the number of bytes not in the cache.
+ *          Everything thereafter might be in the cache.
+ * @param   pCache   The cache to read from.
+ * @param   uOffset  Offset of the virtual disk to read.
+ * @param   cbRead   How much to read.
+ * @param   pIoCtx   The I/O context to read into.
+ * @param   pcbRead  Where to store the number of bytes actually read.
+ *                   On success this indicates the number of bytes read from the cache.
+ *                   If VERR_VD_BLOCK_FREE is returned this gives the number of bytes
+ *                   which are not in the cache.
+ *                   In both cases everything beyond this value
+ *                   might or might not be in the cache.
+ */
+static int vdCacheReadHelper(PVDCACHE pCache, uint64_t uOffset,
+                             size_t cbRead, PVDIOCTX pIoCtx, size_t *pcbRead)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pCache=%#p uOffset=%llu pIoCtx=%p cbRead=%zu pcbRead=%#p\n",
+                 pCache, uOffset, pIoCtx, cbRead, pcbRead));
+
+    AssertPtr(pCache);
+    AssertPtr(pcbRead);
+
+    rc = pCache->Backend->pfnRead(pCache->pBackendData, uOffset, cbRead,
+                                  pIoCtx, pcbRead);
+
+    LogFlowFunc(("returns rc=%Rrc pcbRead=%zu\n", rc, *pcbRead));
+    return rc;
+}
+
+/**
+ * Internal: Writes data for the given block into the cache.
+ *
+ * @returns VBox status code.
+ * @param   pCache     The cache to write to.
+ * @param   uOffset    Offset of the virtual disk to write to the cache.
+ * @param   cbWrite    How much to write.
+ * @param   pIoCtx     The I/O context to write from.
+ * @param   pcbWritten How much data could be written, optional.
+ */
+static int vdCacheWriteHelper(PVDCACHE pCache, uint64_t uOffset, size_t cbWrite,
+                              PVDIOCTX pIoCtx, size_t *pcbWritten)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pCache=%#p uOffset=%llu pIoCtx=%p cbWrite=%zu pcbWritten=%#p\n",
+                 pCache, uOffset, pIoCtx, cbWrite, pcbWritten));
+
+    AssertPtr(pCache);
+    AssertPtr(pIoCtx);
+    Assert(cbWrite > 0);
+
+    if (pcbWritten)
+        rc = pCache->Backend->pfnWrite(pCache->pBackendData, uOffset, cbWrite,
+                                       pIoCtx, pcbWritten);
+    else
+    {
+        size_t cbWritten = 0;
+
+        do
+        {
+            rc = pCache->Backend->pfnWrite(pCache->pBackendData, uOffset, cbWrite,
+                                           pIoCtx, &cbWritten);
+            uOffset += cbWritten;
+            cbWrite -= cbWritten;
+        } while (   cbWrite
+                 && (   RT_SUCCESS(rc)
+                     || rc == VERR_VD_ASYNC_IO_IN_PROGRESS));
+    }
+
+    LogFlowFunc(("returns rc=%Rrc pcbWritten=%zu\n",
+                 rc, pcbWritten ? *pcbWritten : cbWrite));
+    return rc;
+}
+
+/**
+ * Creates a new empty discard state.
+ *
+ * @returns Pointer to the new discard state or NULL if out of memory.
+ */
+static PVDDISCARDSTATE vdDiscardStateCreate(void)
+{
+    PVDDISCARDSTATE pDiscard = (PVDDISCARDSTATE)RTMemAllocZ(sizeof(VDDISCARDSTATE));
+
+    if (pDiscard)
+    {
+        RTListInit(&pDiscard->ListLru);
+        pDiscard->pTreeBlocks = (PAVLRU64TREE)RTMemAllocZ(sizeof(AVLRU64TREE));
+        if (!pDiscard->pTreeBlocks)
+        {
+            RTMemFree(pDiscard);
+            pDiscard = NULL;
+        }
+    }
+
+    return pDiscard;
+}
+
+/**
+ * Removes the least recently used blocks from the waiting list until
+ * the new value is reached.
+ *
+ * @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 vdDiscardRemoveBlocks(PVDISK pDisk, PVDDISCARDSTATE pDiscard, size_t cbDiscardingNew)
+{
+    int rc = VINF_SUCCESS;
+
+    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 = (uint32_t)(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;
+
+
+                VDIOCTX IoCtx;
+                vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_DISCARD, 0, 0, NULL,
+                            NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+                rc = pDisk->pLast->Backend->pfnDiscard(pDisk->pLast->pBackendData,
+                                                            &IoCtx, offStart, cbThis, NULL,
+                                                            NULL, &cbThis, NULL,
+                                                            VD_DISCARD_MARK_UNUSED);
+                if (RT_FAILURE(rc))
+                    break;
+
+                fAllocated = true;
+            }
+
+            idxStart  = idxEnd;
+            offStart += cbThis;
+            cbLeft   -= cbThis;
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+
+        PVDDISCARDBLOCK pBlockRemove = (PVDDISCARDBLOCK)RTAvlrU64RangeRemove(pDiscard->pTreeBlocks, pBlock->Core.Key);
+        Assert(pBlockRemove == pBlock); NOREF(pBlockRemove);
+        RTListNodeRemove(&pBlock->NodeLru);
+
+        pDiscard->cbDiscarding -= pBlock->cbDiscard;
+        RTMemFree(pBlock->pbmAllocated);
+        RTMemFree(pBlock);
+    }
+
+    Assert(RT_FAILURE(rc) || pDiscard->cbDiscarding <= cbDiscardingNew);
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Destroys the current discard state, writing any waiting blocks to the image.
+ *
+ * @returns VBox status code.
+ * @param   pDisk    VD disk container.
+ */
+static int vdDiscardStateDestroy(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+
+    if (pDisk->pDiscard)
+    {
+        rc = vdDiscardRemoveBlocks(pDisk, pDisk->pDiscard, 0 /* Remove all blocks. */);
+        AssertRC(rc);
+        RTMemFree(pDisk->pDiscard->pTreeBlocks);
+        RTMemFree(pDisk->pDiscard);
+        pDisk->pDiscard = NULL;
+    }
+
+    return rc;
+}
+
+/**
+ * Marks the given range as allocated in the image.
+ * Required if there are discards in progress and a write to a block which can get discarded
+ * is written to.
+ *
+ * @returns VBox status code.
+ * @param   pDisk    VD container data.
+ * @param   uOffset  First byte to mark as allocated.
+ * @param   cbRange  Number of bytes to mark as allocated.
+ */
+static int vdDiscardSetRangeAllocated(PVDISK pDisk, uint64_t uOffset, size_t cbRange)
+{
+    PVDDISCARDSTATE pDiscard = pDisk->pDiscard;
+    int rc = VINF_SUCCESS;
+
+    if (pDiscard)
+    {
+        do
+        {
+            size_t cbThisRange = cbRange;
+            PVDDISCARDBLOCK pBlock = (PVDDISCARDBLOCK)RTAvlrU64RangeGet(pDiscard->pTreeBlocks, uOffset);
+
+            if (pBlock)
+            {
+                int32_t idxStart, idxEnd;
+
+                Assert(!(cbThisRange % 512));
+                Assert(!((uOffset - pBlock->Core.Key) % 512));
+
+                cbThisRange = RT_MIN(cbThisRange, pBlock->Core.KeyLast - uOffset + 1);
+
+                idxStart = (uOffset - pBlock->Core.Key) / 512;
+                idxEnd = idxStart + (int32_t)(cbThisRange / 512);
+                ASMBitSetRange(pBlock->pbmAllocated, idxStart, idxEnd);
+            }
+            else
+            {
+                pBlock = (PVDDISCARDBLOCK)RTAvlrU64GetBestFit(pDiscard->pTreeBlocks, uOffset, true);
+                if (pBlock)
+                    cbThisRange = RT_MIN(cbThisRange, pBlock->Core.Key - uOffset);
+            }
+
+            Assert(cbRange >= cbThisRange);
+
+            uOffset += cbThisRange;
+            cbRange -= cbThisRange;
+        } while (cbRange != 0);
+    }
+
+    return rc;
+}
+
+DECLINLINE(PVDIOCTX) vdIoCtxAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
+                                  uint64_t uOffset, size_t cbTransfer,
+                                  PVDIMAGE pImageStart,PCRTSGBUF pSgBuf,
+                                  void *pvAllocation, PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
+                                  uint32_t fFlags)
+{
+    PVDIOCTX pIoCtx = NULL;
+
+    pIoCtx = (PVDIOCTX)RTMemCacheAlloc(pDisk->hMemCacheIoCtx);
+    if (RT_LIKELY(pIoCtx))
+    {
+        vdIoCtxInit(pIoCtx, pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
+                    pSgBuf, pvAllocation, pfnIoCtxTransfer, fFlags);
+    }
+
+    return pIoCtx;
+}
+
+DECLINLINE(PVDIOCTX) vdIoCtxRootAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
+                                      uint64_t uOffset, size_t cbTransfer,
+                                      PVDIMAGE pImageStart, PCRTSGBUF pSgBuf,
+                                      PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                      void *pvUser1, void *pvUser2,
+                                      void *pvAllocation,
+                                      PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
+                                      uint32_t fFlags)
+{
+    PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
+                                   pSgBuf, pvAllocation, pfnIoCtxTransfer, fFlags);
+
+    if (RT_LIKELY(pIoCtx))
+    {
+        pIoCtx->pIoCtxParent          = NULL;
+        pIoCtx->Type.Root.pfnComplete = pfnComplete;
+        pIoCtx->Type.Root.pvUser1     = pvUser1;
+        pIoCtx->Type.Root.pvUser2     = pvUser2;
+    }
+
+    LogFlow(("Allocated root I/O context %#p\n", pIoCtx));
+    return pIoCtx;
+}
+
+DECLINLINE(void) vdIoCtxDiscardInit(PVDIOCTX pIoCtx, PVDISK pDisk, PCRTRANGE paRanges,
+                                    unsigned cRanges, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                    void *pvUser1, void *pvUser2, void *pvAllocation,
+                                    PFNVDIOCTXTRANSFER pfnIoCtxTransfer, uint32_t fFlags)
+{
+    pIoCtx->pIoCtxNext                = NULL;
+    pIoCtx->pDisk                     = pDisk;
+    pIoCtx->enmTxDir                  = VDIOCTXTXDIR_DISCARD;
+    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;
+    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;
+}
+
+DECLINLINE(PVDIOCTX) vdIoCtxDiscardAlloc(PVDISK pDisk, PCRTRANGE paRanges,
+                                         unsigned cRanges,
+                                         PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                         void *pvUser1, void *pvUser2,
+                                         void *pvAllocation,
+                                         PFNVDIOCTXTRANSFER pfnIoCtxTransfer,
+                                         uint32_t fFlags)
+{
+    PVDIOCTX pIoCtx = NULL;
+
+    pIoCtx = (PVDIOCTX)RTMemCacheAlloc(pDisk->hMemCacheIoCtx);
+    if (RT_LIKELY(pIoCtx))
+    {
+        vdIoCtxDiscardInit(pIoCtx, pDisk, paRanges, cRanges, pfnComplete, pvUser1,
+                           pvUser2, pvAllocation, pfnIoCtxTransfer, fFlags);
+    }
+
+    LogFlow(("Allocated discard I/O context %#p\n", pIoCtx));
+    return pIoCtx;
+}
+
+DECLINLINE(PVDIOCTX) vdIoCtxChildAlloc(PVDISK pDisk, VDIOCTXTXDIR enmTxDir,
+                                       uint64_t uOffset, size_t cbTransfer,
+                                       PVDIMAGE pImageStart, PCRTSGBUF pSgBuf,
+                                       PVDIOCTX pIoCtxParent, size_t cbTransferParent,
+                                       size_t cbWriteParent, void *pvAllocation,
+                                       PFNVDIOCTXTRANSFER pfnIoCtxTransfer)
+{
+    PVDIOCTX pIoCtx = vdIoCtxAlloc(pDisk, enmTxDir, uOffset, cbTransfer, pImageStart,
+                                   pSgBuf, pvAllocation, pfnIoCtxTransfer, pIoCtxParent->fFlags & ~VDIOCTX_FLAGS_DONT_FREE);
+
+    AssertPtr(pIoCtxParent);
+    Assert(!pIoCtxParent->pIoCtxParent);
+
+    if (RT_LIKELY(pIoCtx))
+    {
+        pIoCtx->pIoCtxParent                   = pIoCtxParent;
+        pIoCtx->Type.Child.uOffsetSaved        = uOffset;
+        pIoCtx->Type.Child.cbTransferLeftSaved = cbTransfer;
+        pIoCtx->Type.Child.cbTransferParent    = cbTransferParent;
+        pIoCtx->Type.Child.cbWriteParent       = cbWriteParent;
+    }
+
+    LogFlow(("Allocated child I/O context %#p\n", pIoCtx));
+    return pIoCtx;
+}
+
+DECLINLINE(PVDIOTASK) vdIoTaskUserAlloc(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser, PVDIOCTX pIoCtx, uint32_t cbTransfer)
+{
+    PVDIOTASK pIoTask = NULL;
+
+    pIoTask = (PVDIOTASK)RTMemCacheAlloc(pIoStorage->pVDIo->pDisk->hMemCacheIoTask);
+    if (pIoTask)
+    {
+        pIoTask->pIoStorage           = pIoStorage;
+        pIoTask->pfnComplete          = pfnComplete;
+        pIoTask->pvUser               = pvUser;
+        pIoTask->fMeta                = false;
+        pIoTask->Type.User.cbTransfer = cbTransfer;
+        pIoTask->Type.User.pIoCtx     = pIoCtx;
+    }
+
+    return pIoTask;
+}
+
+DECLINLINE(PVDIOTASK) vdIoTaskMetaAlloc(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser, PVDMETAXFER pMetaXfer)
+{
+    PVDIOTASK pIoTask = NULL;
+
+    pIoTask = (PVDIOTASK)RTMemCacheAlloc(pIoStorage->pVDIo->pDisk->hMemCacheIoTask);
+    if (pIoTask)
+    {
+        pIoTask->pIoStorage          = pIoStorage;
+        pIoTask->pfnComplete         = pfnComplete;
+        pIoTask->pvUser              = pvUser;
+        pIoTask->fMeta               = true;
+        pIoTask->Type.Meta.pMetaXfer = pMetaXfer;
+    }
+
+    return pIoTask;
+}
+
+DECLINLINE(void) vdIoCtxFree(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    Log(("Freeing I/O context %#p\n", pIoCtx));
+
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_FREE))
+    {
+        if (pIoCtx->pvAllocation)
+            RTMemFree(pIoCtx->pvAllocation);
+#ifdef DEBUG
+        memset(&pIoCtx->pDisk, 0xff, sizeof(void *));
+#endif
+        RTMemCacheFree(pDisk->hMemCacheIoCtx, pIoCtx);
+    }
+}
+
+DECLINLINE(void) vdIoTaskFree(PVDISK pDisk, PVDIOTASK pIoTask)
+{
+#ifdef DEBUG
+    memset(pIoTask, 0xff, sizeof(VDIOTASK));
+#endif
+    RTMemCacheFree(pDisk->hMemCacheIoTask, pIoTask);
+}
+
+DECLINLINE(void) vdIoCtxChildReset(PVDIOCTX pIoCtx)
+{
+    AssertPtr(pIoCtx->pIoCtxParent);
+
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    pIoCtx->Req.Io.uOffset        = pIoCtx->Type.Child.uOffsetSaved;
+    pIoCtx->Req.Io.cbTransferLeft = (uint32_t)pIoCtx->Type.Child.cbTransferLeftSaved;
+    Assert((uint32_t)pIoCtx->Type.Child.cbTransferLeftSaved == pIoCtx->Type.Child.cbTransferLeftSaved);
+}
+
+DECLINLINE(PVDMETAXFER) vdMetaXferAlloc(PVDIOSTORAGE pIoStorage, uint64_t uOffset, size_t cb)
+{
+    PVDMETAXFER pMetaXfer = (PVDMETAXFER)RTMemAlloc(RT_UOFFSETOF_DYN(VDMETAXFER, abData[cb]));
+
+    if (RT_LIKELY(pMetaXfer))
+    {
+        pMetaXfer->Core.Key     = uOffset;
+        pMetaXfer->Core.KeyLast = uOffset + cb - 1;
+        pMetaXfer->fFlags       = VDMETAXFER_TXDIR_NONE;
+        pMetaXfer->cbMeta       = cb;
+        pMetaXfer->pIoStorage   = pIoStorage;
+        pMetaXfer->cRefs        = 0;
+        pMetaXfer->pbDataShw    = NULL;
+        RTListInit(&pMetaXfer->ListIoCtxWaiting);
+        RTListInit(&pMetaXfer->ListIoCtxShwWrites);
+    }
+    return pMetaXfer;
+}
+
+DECLINLINE(void) vdIoCtxAddToWaitingList(volatile PVDIOCTX *ppList, PVDIOCTX pIoCtx)
+{
+    /* Put it on the waiting list. */
+    PVDIOCTX pNext = ASMAtomicUoReadPtrT(ppList, PVDIOCTX);
+    PVDIOCTX pHeadOld;
+    pIoCtx->pIoCtxNext = pNext;
+    while (!ASMAtomicCmpXchgExPtr(ppList, pIoCtx, pNext, &pHeadOld))
+    {
+        pNext = pHeadOld;
+        Assert(pNext != pIoCtx);
+        pIoCtx->pIoCtxNext = pNext;
+        ASMNopPause();
+    }
+}
+
+DECLINLINE(void) vdIoCtxDefer(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    LogFlowFunc(("Deferring I/O context pIoCtx=%#p\n", pIoCtx));
+
+    Assert(!pIoCtx->pIoCtxParent && !(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED));
+    pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+    vdIoCtxAddToWaitingList(&pDisk->pIoCtxBlockedHead, pIoCtx);
+}
+
+static size_t vdIoCtxCopy(PVDIOCTX pIoCtxDst, PVDIOCTX pIoCtxSrc, size_t cbData)
+{
+    return RTSgBufCopy(&pIoCtxDst->Req.Io.SgBuf, &pIoCtxSrc->Req.Io.SgBuf, cbData);
+}
+
+#if 0 /* unused */
+static int vdIoCtxCmp(PVDIOCTX pIoCtx1, PVDIOCTX pIoCtx2, size_t cbData)
+{
+    return RTSgBufCmp(&pIoCtx1->Req.Io.SgBuf, &pIoCtx2->Req.Io.SgBuf, cbData);
+}
+#endif
+
+static size_t vdIoCtxCopyTo(PVDIOCTX pIoCtx, const uint8_t *pbData, size_t cbData)
+{
+    return RTSgBufCopyFromBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
+}
+
+static size_t vdIoCtxCopyFrom(PVDIOCTX pIoCtx, uint8_t *pbData, size_t cbData)
+{
+    return RTSgBufCopyToBuf(&pIoCtx->Req.Io.SgBuf, pbData, cbData);
+}
+
+static size_t vdIoCtxSet(PVDIOCTX pIoCtx, uint8_t ch, size_t cbData)
+{
+    return RTSgBufSet(&pIoCtx->Req.Io.SgBuf, ch, cbData);
+}
+
+/**
+ * Returns whether the given I/O context has completed.
+ *
+ * @returns Flag whether the I/O context is complete.
+ * @param   pIoCtx          The I/O context to check.
+ */
+DECLINLINE(bool) vdIoCtxIsComplete(PVDIOCTX pIoCtx)
+{
+    if (   !pIoCtx->cMetaTransfersPending
+        && !pIoCtx->cDataTransfersPending
+        && !pIoCtx->pfnIoCtxTransfer)
+        return true;
+
+    /*
+     * We complete the I/O context in case of an error
+     * if there is no I/O task pending.
+     */
+    if (   RT_FAILURE(pIoCtx->rcReq)
+        && !pIoCtx->cMetaTransfersPending
+        && !pIoCtx->cDataTransfersPending)
+        return true;
+
+    return false;
+}
+
+/**
+ * Returns whether the given I/O context is blocked due to a metadata transfer
+ * or because the backend blocked it.
+ *
+ * @returns Flag whether the I/O context is blocked.
+ * @param   pIoCtx          The I/O context to check.
+ */
+DECLINLINE(bool) vdIoCtxIsBlocked(PVDIOCTX pIoCtx)
+{
+    /* Don't change anything if there is a metadata transfer pending or we are blocked. */
+    if (   pIoCtx->cMetaTransfersPending
+        || (pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
+        return true;
+
+    return false;
+}
+
+/**
+ * Process the I/O context, core method which assumes that the I/O context
+ * acquired the lock.
+ *
+ * @returns VBox status code.
+ * @param   pIoCtx    I/O context to process.
+ */
+static int vdIoCtxProcessLocked(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pIoCtx->pDisk);
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    if (!vdIoCtxIsComplete(pIoCtx))
+    {
+        if (!vdIoCtxIsBlocked(pIoCtx))
+        {
+            if (pIoCtx->pfnIoCtxTransfer)
+            {
+                /* Call the transfer function advancing to the next while there is no error. */
+                while (   pIoCtx->pfnIoCtxTransfer
+                       && !pIoCtx->cMetaTransfersPending
+                       && RT_SUCCESS(rc))
+                {
+                    LogFlowFunc(("calling transfer function %#p\n", pIoCtx->pfnIoCtxTransfer));
+                    rc = pIoCtx->pfnIoCtxTransfer(pIoCtx);
+
+                    /* Advance to the next part of the transfer if the current one succeeded. */
+                    if (RT_SUCCESS(rc))
+                    {
+                        pIoCtx->pfnIoCtxTransfer = pIoCtx->pfnIoCtxTransferNext;
+                        pIoCtx->pfnIoCtxTransferNext = NULL;
+                    }
+                }
+            }
+
+            if (   RT_SUCCESS(rc)
+                && !pIoCtx->cMetaTransfersPending
+                && !pIoCtx->cDataTransfersPending
+                && !(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
+                rc = VINF_VD_ASYNC_IO_FINISHED;
+            else if (   RT_SUCCESS(rc)
+                     || rc == VERR_VD_NOT_ENOUGH_METADATA
+                     || rc == VERR_VD_IOCTX_HALT)
+                rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+            else if (   RT_FAILURE(rc)
+                        && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
+            {
+                ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rc, VINF_SUCCESS);
+
+                /*
+                 * The I/O context completed if we have an error and there is no data
+                 * or meta data transfer pending.
+                 */
+                if (   !pIoCtx->cMetaTransfersPending
+                    && !pIoCtx->cDataTransfersPending)
+                    rc = VINF_VD_ASYNC_IO_FINISHED;
+                else
+                    rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+            }
+        }
+        else
+            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+    }
+    else
+        rc = VINF_VD_ASYNC_IO_FINISHED;
+
+    LogFlowFunc(("pIoCtx=%#p rc=%Rrc cDataTransfersPending=%u cMetaTransfersPending=%u fComplete=%RTbool\n",
+                 pIoCtx, rc, pIoCtx->cDataTransfersPending, pIoCtx->cMetaTransfersPending,
+                 pIoCtx->fComplete));
+
+    return rc;
+}
+
+/**
+ * Processes the list of waiting I/O contexts.
+ *
+ * @returns VBox status code, only valid if pIoCtxRc is not NULL, treat as void
+ *          function otherwise.
+ * @param   pDisk    The disk structure.
+ * @param   pIoCtxRc An I/O context handle which waits on the list. When processed
+ *                   The status code is returned. NULL if there is no I/O context
+ *                   to return the status code for.
+ */
+static int vdDiskProcessWaitingIoCtx(PVDISK pDisk, PVDIOCTX pIoCtxRc)
+{
+    int rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+
+    LogFlowFunc(("pDisk=%#p pIoCtxRc=%#p\n", pDisk, pIoCtxRc));
+
+    VD_IS_LOCKED(pDisk);
+
+    /* Get the waiting list and process it in FIFO order. */
+    PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxHead, NULL, PVDIOCTX);
+
+    /* Reverse it. */
+    PVDIOCTX pCur = pIoCtxHead;
+    pIoCtxHead = NULL;
+    while (pCur)
+    {
+        PVDIOCTX pInsert = pCur;
+        pCur = pCur->pIoCtxNext;
+        pInsert->pIoCtxNext = pIoCtxHead;
+        pIoCtxHead = pInsert;
+    }
+
+    /* Process now. */
+    pCur = pIoCtxHead;
+    while (pCur)
+    {
+        int rcTmp;
+        PVDIOCTX pTmp = pCur;
+
+        pCur = pCur->pIoCtxNext;
+        pTmp->pIoCtxNext = NULL;
+
+        /*
+         * Need to clear the sync flag here if there is a new I/O context
+         * with it set and the context is not given in pIoCtxRc.
+         * This happens most likely on a different thread and that one shouldn't
+         * process the context synchronously.
+         *
+         * The thread who issued the context will wait on the event semaphore
+         * anyway which is signalled when the completion handler is called.
+         */
+        if (   pTmp->fFlags & VDIOCTX_FLAGS_SYNC
+            && pTmp != pIoCtxRc)
+            pTmp->fFlags &= ~VDIOCTX_FLAGS_SYNC;
+
+        rcTmp = vdIoCtxProcessLocked(pTmp);
+        if (pTmp == pIoCtxRc)
+        {
+            if (   rcTmp == VINF_VD_ASYNC_IO_FINISHED
+                && RT_SUCCESS(pTmp->rcReq)
+                && pTmp->enmTxDir == VDIOCTXTXDIR_READ)
+            {
+                   int rc2 = vdFilterChainApplyRead(pDisk, pTmp->Req.Io.uOffsetXferOrig,
+                                                    pTmp->Req.Io.cbXferOrig, pTmp);
+                    if (RT_FAILURE(rc2))
+                        rcTmp = rc2;
+            }
+
+            /* The given I/O context was processed, pass the return code to the caller. */
+            if (   rcTmp == VINF_VD_ASYNC_IO_FINISHED
+                && (pTmp->fFlags & VDIOCTX_FLAGS_SYNC))
+                rc = pTmp->rcReq;
+            else
+                rc = rcTmp;
+        }
+        else if (   rcTmp == VINF_VD_ASYNC_IO_FINISHED
+                 && ASMAtomicCmpXchgBool(&pTmp->fComplete, true, false))
+        {
+            LogFlowFunc(("Waiting I/O context completed pTmp=%#p\n", pTmp));
+            vdThreadFinishWrite(pDisk);
+
+            bool fFreeCtx = RT_BOOL(!(pTmp->fFlags & VDIOCTX_FLAGS_DONT_FREE));
+            vdIoCtxRootComplete(pDisk, pTmp);
+
+            if (fFreeCtx)
+                vdIoCtxFree(pDisk, pTmp);
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Processes the list of blocked I/O contexts.
+ *
+ * @param   pDisk    The disk structure.
+ */
+static void vdDiskProcessBlockedIoCtx(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    VD_IS_LOCKED(pDisk);
+
+    /* Get the waiting list and process it in FIFO order. */
+    PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxBlockedHead, NULL, PVDIOCTX);
+
+    /* Reverse it. */
+    PVDIOCTX pCur = pIoCtxHead;
+    pIoCtxHead = NULL;
+    while (pCur)
+    {
+        PVDIOCTX pInsert = pCur;
+        pCur = pCur->pIoCtxNext;
+        pInsert->pIoCtxNext = pIoCtxHead;
+        pIoCtxHead = pInsert;
+    }
+
+    /* Process now. */
+    pCur = pIoCtxHead;
+    while (pCur)
+    {
+        int rc;
+        PVDIOCTX pTmp = pCur;
+
+        pCur = pCur->pIoCtxNext;
+        pTmp->pIoCtxNext = NULL;
+
+        Assert(!pTmp->pIoCtxParent);
+        Assert(pTmp->fFlags & VDIOCTX_FLAGS_BLOCKED);
+        pTmp->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
+
+        rc = vdIoCtxProcessLocked(pTmp);
+        if (   rc == VINF_VD_ASYNC_IO_FINISHED
+            && ASMAtomicCmpXchgBool(&pTmp->fComplete, true, false))
+        {
+            LogFlowFunc(("Waiting I/O context completed pTmp=%#p\n", pTmp));
+            vdThreadFinishWrite(pDisk);
+
+            bool fFreeCtx = RT_BOOL(!(pTmp->fFlags & VDIOCTX_FLAGS_DONT_FREE));
+            vdIoCtxRootComplete(pDisk, pTmp);
+            if (fFreeCtx)
+                vdIoCtxFree(pDisk, pTmp);
+        }
+    }
+
+    LogFlowFunc(("returns\n"));
+}
+
+/**
+ * Processes the I/O context trying to lock the criticial section.
+ * The context is deferred if the critical section is busy.
+ *
+ * @returns VBox status code.
+ * @param   pIoCtx    The I/O context to process.
+ */
+static int vdIoCtxProcessTryLockDefer(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK pDisk = pIoCtx->pDisk;
+
+    Log(("Defer pIoCtx=%#p\n", pIoCtx));
+
+    /* Put it on the waiting list first. */
+    vdIoCtxAddToWaitingList(&pDisk->pIoCtxHead, pIoCtx);
+
+    if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
+    {
+        /* Leave it again, the context will be processed just before leaving the lock. */
+        LogFlowFunc(("Successfully acquired the lock\n"));
+        rc = vdDiskUnlock(pDisk, pIoCtx);
+    }
+    else
+    {
+        LogFlowFunc(("Lock is held\n"));
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+    }
+
+    return rc;
+}
+
+/**
+ * Process the I/O context in a synchronous manner, waiting
+ * for it to complete.
+ *
+ * @returns VBox status code of the completed request.
+ * @param   pIoCtx            The sync I/O context.
+ * @param   hEventComplete    Event sempahore to wait on for completion.
+ */
+static int vdIoCtxProcessSync(PVDIOCTX pIoCtx, RTSEMEVENT hEventComplete)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK pDisk = pIoCtx->pDisk;
+
+    LogFlowFunc(("pIoCtx=%p\n", pIoCtx));
+
+    AssertMsg(pIoCtx->fFlags & (VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE),
+              ("I/O context is not marked as synchronous\n"));
+
+    rc = vdIoCtxProcessTryLockDefer(pIoCtx);
+    if (rc == VINF_VD_ASYNC_IO_FINISHED)
+        rc = VINF_SUCCESS;
+
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        rc = RTSemEventWait(hEventComplete, RT_INDEFINITE_WAIT);
+        AssertRC(rc);
+    }
+
+    rc = pIoCtx->rcReq;
+    vdIoCtxFree(pDisk, pIoCtx);
+
+    return rc;
+}
+
+DECLINLINE(bool) vdIoCtxIsDiskLockOwner(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    return pDisk->pIoCtxLockOwner == pIoCtx;
+}
+
+static int vdIoCtxLockDisk(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    LogFlowFunc(("pDisk=%#p pIoCtx=%#p\n", pDisk, pIoCtx));
+
+    if (!ASMAtomicCmpXchgPtr(&pDisk->pIoCtxLockOwner, pIoCtx, NIL_VDIOCTX))
+    {
+        Assert(pDisk->pIoCtxLockOwner != pIoCtx); /* No nesting allowed. */
+        vdIoCtxDefer(pDisk, pIoCtx);
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+    }
+
+    LogFlowFunc(("returns -> %Rrc\n", rc));
+    return rc;
+}
+
+static void vdIoCtxUnlockDisk(PVDISK pDisk, PVDIOCTX pIoCtx, bool fProcessBlockedReqs)
+{
+    RT_NOREF1(pIoCtx);
+    LogFlowFunc(("pDisk=%#p pIoCtx=%#p fProcessBlockedReqs=%RTbool\n",
+                 pDisk, pIoCtx, fProcessBlockedReqs));
+
+    VD_IS_LOCKED(pDisk);
+
+    LogFlow(("Unlocking disk lock owner is %#p\n", pDisk->pIoCtxLockOwner));
+    Assert(pDisk->pIoCtxLockOwner == pIoCtx);
+    ASMAtomicXchgPtrT(&pDisk->pIoCtxLockOwner, NIL_VDIOCTX, PVDIOCTX);
+
+    if (fProcessBlockedReqs)
+    {
+        /* Process any blocked writes if the current request didn't caused another growing. */
+        vdDiskProcessBlockedIoCtx(pDisk);
+    }
+
+    LogFlowFunc(("returns\n"));
+}
+
+/**
+ * Internal: Reads a given amount of data from the image chain of the disk.
+ **/
+static int vdDiskReadHelper(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
+                            uint64_t uOffset, size_t cbRead, PVDIOCTX pIoCtx, size_t *pcbThisRead)
+{
+    RT_NOREF1(pDisk);
+    int rc = VINF_SUCCESS;
+    size_t cbThisRead = cbRead;
+
+    AssertPtr(pcbThisRead);
+
+    *pcbThisRead = 0;
+
+    /*
+     * 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, cbThisRead, pIoCtx,
+                                  &cbThisRead);
+
+    if (rc == VERR_VD_BLOCK_FREE)
+    {
+        for (PVDIMAGE pCurrImage = pImageParentOverride ? pImageParentOverride : pImage->pPrev;
+             pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
+             pCurrImage = pCurrImage->pPrev)
+        {
+            rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                              uOffset, cbThisRead, pIoCtx,
+                                              &cbThisRead);
+        }
+    }
+
+    if (RT_SUCCESS(rc) || rc == VERR_VD_BLOCK_FREE)
+        *pcbThisRead = cbThisRead;
+
+    return rc;
+}
+
+/**
+ * internal: read the specified amount of data in whatever blocks the backend
+ * will give us - async version.
+ */
+static DECLCALLBACK(int) vdReadHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc;
+    PVDISK pDisk                = pIoCtx->pDisk;
+    size_t cbToRead               = pIoCtx->Req.Io.cbTransfer;
+    uint64_t uOffset              = pIoCtx->Req.Io.uOffset;
+    PVDIMAGE pCurrImage           = pIoCtx->Req.Io.pImageCur;
+    PVDIMAGE pImageParentOverride = pIoCtx->Req.Io.pImageParentOverride;
+    unsigned cImagesRead          = pIoCtx->Req.Io.cImagesRead;
+    size_t cbThisRead;
+
+    /*
+     * Check whether there is a full block write in progress which was not allocated.
+     * Defer I/O if the range interferes but only if it does not belong to the
+     * write doing the allocation.
+     */
+    if (   pDisk->pIoCtxLockOwner != NIL_VDIOCTX
+        && uOffset >= pDisk->uOffsetStartLocked
+        && uOffset < pDisk->uOffsetEndLocked
+        && (   !pIoCtx->pIoCtxParent
+            || pIoCtx->pIoCtxParent != pDisk->pIoCtxLockOwner))
+    {
+        Log(("Interferring read while allocating a new block => deferring read\n"));
+        vdIoCtxDefer(pDisk, pIoCtx);
+        return VERR_VD_ASYNC_IO_IN_PROGRESS;
+    }
+
+    /* Loop until all reads started or we have a backend which needs to read metadata. */
+    do
+    {
+        /* Search for image with allocated block. Do not attempt to read more
+         * than the previous reads marked as valid. Otherwise this would return
+         * stale data when different block sizes are used for the images. */
+        cbThisRead = cbToRead;
+
+        if (   pDisk->pCache
+            && !pImageParentOverride)
+        {
+            rc = vdCacheReadHelper(pDisk->pCache, uOffset, cbThisRead,
+                                   pIoCtx, &cbThisRead);
+            if (rc == VERR_VD_BLOCK_FREE)
+            {
+                rc = vdDiskReadHelper(pDisk, pCurrImage, NULL, uOffset, cbThisRead,
+                                      pIoCtx, &cbThisRead);
+
+                /* If the read was successful, write the data back into the cache. */
+                if (   RT_SUCCESS(rc)
+                    && pIoCtx->fFlags & VDIOCTX_FLAGS_READ_UPDATE_CACHE)
+                {
+                    rc = vdCacheWriteHelper(pDisk->pCache, uOffset, cbThisRead,
+                                            pIoCtx, NULL);
+                }
+            }
+        }
+        else
+        {
+            /*
+             * Try to read from the given image.
+             * If the block is not allocated read from override chain if present.
+             */
+            rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                              uOffset, cbThisRead, pIoCtx,
+                                              &cbThisRead);
+
+            if (   rc == VERR_VD_BLOCK_FREE
+                && cImagesRead != 1)
+            {
+                unsigned cImagesToProcess = cImagesRead;
+
+                pCurrImage = pImageParentOverride ? pImageParentOverride : pCurrImage->pPrev;
+                pIoCtx->Req.Io.pImageParentOverride = NULL;
+
+                while (pCurrImage && rc == VERR_VD_BLOCK_FREE)
+                {
+                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                                      uOffset, cbThisRead,
+                                                      pIoCtx, &cbThisRead);
+                    if (cImagesToProcess == 1)
+                        break;
+                    else if (cImagesToProcess > 0)
+                        cImagesToProcess--;
+
+                    if (rc == VERR_VD_BLOCK_FREE)
+                        pCurrImage = pCurrImage->pPrev;
+                }
+            }
+        }
+
+        /* The task state will be updated on success already, don't do it here!. */
+        if (rc == VERR_VD_BLOCK_FREE)
+        {
+            /* No image in the chain contains the data for the block. */
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbThisRead); Assert(cbThisRead == (uint32_t)cbThisRead);
+
+            /* Fill the free space with 0 if we are told to do so
+             * or a previous read returned valid data. */
+            if (pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS)
+                vdIoCtxSet(pIoCtx, '\0', cbThisRead);
+            else
+                pIoCtx->Req.Io.cbBufClear += cbThisRead;
+
+            if (pIoCtx->Req.Io.pImageCur->uOpenFlags & VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS)
+                rc = VINF_VD_NEW_ZEROED_BLOCK;
+            else
+                rc = VINF_SUCCESS;
+        }
+        else if (rc == VERR_VD_IOCTX_HALT)
+        {
+            uOffset  += cbThisRead;
+            cbToRead -= cbThisRead;
+            pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+        }
+        else if (   RT_SUCCESS(rc)
+                 || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        {
+            /* First not free block, fill the space before with 0. */
+            if (   pIoCtx->Req.Io.cbBufClear
+                && !(pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS))
+            {
+                RTSGBUF SgBuf;
+                RTSgBufClone(&SgBuf, &pIoCtx->Req.Io.SgBuf);
+                RTSgBufReset(&SgBuf);
+                RTSgBufSet(&SgBuf, 0, pIoCtx->Req.Io.cbBufClear);
+                pIoCtx->Req.Io.cbBufClear = 0;
+                pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
+            }
+            rc = VINF_SUCCESS;
+        }
+
+        if (RT_FAILURE(rc))
+            break;
+
+        cbToRead -= cbThisRead;
+        uOffset  += cbThisRead;
+        pCurrImage = pIoCtx->Req.Io.pImageStart; /* Start with the highest image in the chain. */
+    } while (cbToRead != 0 && RT_SUCCESS(rc));
+
+    if (   rc == VERR_VD_NOT_ENOUGH_METADATA
+        || rc == VERR_VD_IOCTX_HALT)
+    {
+        /* Save the current state. */
+        pIoCtx->Req.Io.uOffset    = uOffset;
+        pIoCtx->Req.Io.cbTransfer = cbToRead;
+        pIoCtx->Req.Io.pImageCur  = pCurrImage ? pCurrImage : pIoCtx->Req.Io.pImageStart;
+    }
+
+    return (!(pIoCtx->fFlags & VDIOCTX_FLAGS_ZERO_FREE_BLOCKS))
+           ? VERR_VD_BLOCK_FREE
+           : rc;
+}
+
+/**
+ * internal: parent image read wrapper for compacting.
+ */
+static DECLCALLBACK(int) vdParentRead(void *pvUser, uint64_t uOffset, void *pvBuf,
+                                      size_t cbRead)
+{
+    PVDPARENTSTATEDESC pParentState = (PVDPARENTSTATEDESC)pvUser;
+
+    /** @todo
+     * Only used for compaction so far which is not possible to mix with async I/O.
+     * Needs to be changed if we want to support online compaction of images.
+     */
+    bool fLocked = ASMAtomicXchgBool(&pParentState->pDisk->fLocked, true);
+    AssertMsgReturn(!fLocked,
+                    ("Calling synchronous parent read while another thread holds the disk lock\n"),
+                    VERR_VD_INVALID_STATE);
+
+    /* Fake an I/O context. */
+    RTSGSEG Segment;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
+
+    Segment.pvSeg = pvBuf;
+    Segment.cbSeg = cbRead;
+    RTSgBufInit(&SgBuf, &Segment, 1);
+    vdIoCtxInit(&IoCtx, pParentState->pDisk, VDIOCTXTXDIR_READ, uOffset, cbRead, pParentState->pImage,
+                &SgBuf, NULL, NULL, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_ZERO_FREE_BLOCKS);
+    int rc = vdReadHelperAsync(&IoCtx);
+    ASMAtomicXchgBool(&pParentState->pDisk->fLocked, false);
+    return rc;
+}
+
+/**
+ * Extended version of vdReadHelper(), implementing certain optimizations
+ * for image cloning.
+ *
+ * @returns VBox status code.
+ * @param   pDisk                   The disk to read from.
+ * @param   pImage                  The image to start reading from.
+ * @param   pImageParentOverride    The parent image to read from
+ *                                  if the starting image returns a free block.
+ *                                  If NULL is passed the real parent of the image
+ *                                  in the chain is used.
+ * @param   uOffset                 Offset in the disk to start reading from.
+ * @param   pvBuf                   Where to store the read data.
+ * @param   cbRead                  How much to read.
+ * @param   fZeroFreeBlocks         Flag whether free blocks should be zeroed.
+ *                                  If false and no image has data for sepcified
+ *                                  range VERR_VD_BLOCK_FREE is returned.
+ *                                  Note that unallocated blocks are still zeroed
+ *                                  if at least one image has valid data for a part
+ *                                  of the range.
+ * @param   fUpdateCache            Flag whether to update the attached cache if
+ *                                  available.
+ * @param   cImagesRead             Number of images in the chain to read until
+ *                                  the read is cut off. A value of 0 disables the cut off.
+ */
+static int vdReadHelperEx(PVDISK pDisk, PVDIMAGE pImage, PVDIMAGE pImageParentOverride,
+                          uint64_t uOffset, void *pvBuf, size_t cbRead,
+                          bool fZeroFreeBlocks, bool fUpdateCache, unsigned cImagesRead)
+{
+    int rc = VINF_SUCCESS;
+    uint32_t fFlags = VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE;
+    RTSGSEG Segment;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
+    RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
+
+    rc = RTSemEventCreate(&hEventComplete);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    if (fZeroFreeBlocks)
+        fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
+    if (fUpdateCache)
+        fFlags |= VDIOCTX_FLAGS_READ_UPDATE_CACHE;
+
+    Segment.pvSeg = pvBuf;
+    Segment.cbSeg = cbRead;
+    RTSgBufInit(&SgBuf, &Segment, 1);
+    vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_READ, uOffset, cbRead, pImage, &SgBuf,
+                NULL, vdReadHelperAsync, fFlags);
+
+    IoCtx.Req.Io.pImageParentOverride = pImageParentOverride;
+    IoCtx.Req.Io.cImagesRead = cImagesRead;
+    IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
+    IoCtx.Type.Root.pvUser1     = pDisk;
+    IoCtx.Type.Root.pvUser2     = hEventComplete;
+    rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
+    RTSemEventDestroy(hEventComplete);
+    return rc;
+}
+
+/**
+ * internal: read the specified amount of data in whatever blocks the backend
+ * will give us.
+ */
+static int vdReadHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
+                        void *pvBuf, size_t cbRead, bool fUpdateCache)
+{
+    return vdReadHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbRead,
+                          true /* fZeroFreeBlocks */, fUpdateCache, 0);
+}
+
+/**
+ * internal: mark the disk as not modified.
+ */
+static void vdResetModifiedFlag(PVDISK pDisk)
+{
+    if (pDisk->uModified & VD_IMAGE_MODIFIED_FLAG)
+    {
+        /* generate new last-modified uuid */
+        if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
+        {
+            RTUUID Uuid;
+
+            RTUuidCreate(&Uuid);
+            pDisk->pLast->Backend->pfnSetModificationUuid(pDisk->pLast->pBackendData,
+                                                          &Uuid);
+
+            if (pDisk->pCache)
+                pDisk->pCache->Backend->pfnSetModificationUuid(pDisk->pCache->pBackendData,
+                                                               &Uuid);
+        }
+
+        pDisk->uModified &= ~VD_IMAGE_MODIFIED_FLAG;
+    }
+}
+
+/**
+ * internal: mark the disk as modified.
+ */
+static void vdSetModifiedFlag(PVDISK pDisk)
+{
+    pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
+    if (pDisk->uModified & VD_IMAGE_MODIFIED_FIRST)
+    {
+        pDisk->uModified &= ~VD_IMAGE_MODIFIED_FIRST;
+
+        /* First modify, so create a UUID and ensure it's written to disk. */
+        vdResetModifiedFlag(pDisk);
+
+        if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
+        {
+            VDIOCTX IoCtx;
+            vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, NULL,
+                        NULL, NULL, NULL, VDIOCTX_FLAGS_SYNC);
+            pDisk->pLast->Backend->pfnFlush(pDisk->pLast->pBackendData, &IoCtx);
+        }
+    }
+}
+
+/**
+ * internal: write buffer to the image, taking care of block boundaries and
+ * write optimizations.
+ */
+static int vdWriteHelperEx(PVDISK pDisk, PVDIMAGE pImage,
+                           PVDIMAGE pImageParentOverride, uint64_t uOffset,
+                           const void *pvBuf, size_t cbWrite,
+                           uint32_t fFlags, unsigned cImagesRead)
+{
+    int rc = VINF_SUCCESS;
+    RTSGSEG Segment;
+    RTSGBUF SgBuf;
+    VDIOCTX IoCtx;
+    RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
+
+    rc = RTSemEventCreate(&hEventComplete);
+    if (RT_FAILURE(rc))
+        return rc;
+
+    fFlags |= VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE;
+
+    Segment.pvSeg = (void *)pvBuf;
+    Segment.cbSeg = cbWrite;
+    RTSgBufInit(&SgBuf, &Segment, 1);
+    vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_WRITE, uOffset, cbWrite, pImage, &SgBuf,
+                NULL, vdWriteHelperAsync, fFlags);
+
+    IoCtx.Req.Io.pImageParentOverride = pImageParentOverride;
+    IoCtx.Req.Io.cImagesRead = cImagesRead;
+    IoCtx.pIoCtxParent          = NULL;
+    IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
+    IoCtx.Type.Root.pvUser1     = pDisk;
+    IoCtx.Type.Root.pvUser2     = hEventComplete;
+    if (RT_SUCCESS(rc))
+        rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
+
+    RTSemEventDestroy(hEventComplete);
+    return rc;
+}
+
+/**
+ * internal: write buffer to the image, taking care of block boundaries and
+ * write optimizations.
+ */
+static int vdWriteHelper(PVDISK pDisk, PVDIMAGE pImage, uint64_t uOffset,
+                         const void *pvBuf, size_t cbWrite, uint32_t fFlags)
+{
+    return vdWriteHelperEx(pDisk, pImage, NULL, uOffset, pvBuf, cbWrite,
+                           fFlags, 0);
+}
+
+/**
+ * Internal: Copies the content of one disk to another one applying optimizations
+ * to speed up the copy process if possible.
+ */
+static int vdCopyHelper(PVDISK pDiskFrom, PVDIMAGE pImageFrom, PVDISK pDiskTo,
+                        uint64_t cbSize, unsigned cImagesFromRead, unsigned cImagesToRead,
+                        bool fSuppressRedundantIo, PVDINTERFACEPROGRESS pIfProgress,
+                        PVDINTERFACEPROGRESS pDstIfProgress)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    uint64_t uOffset = 0;
+    uint64_t cbRemaining = cbSize;
+    void *pvBuf = NULL;
+    bool fLockReadFrom = false;
+    bool fLockWriteTo = false;
+    bool fBlockwiseCopy = false;
+    unsigned uProgressOld = 0;
+
+    LogFlowFunc(("pDiskFrom=%#p pImageFrom=%#p pDiskTo=%#p cbSize=%llu cImagesFromRead=%u cImagesToRead=%u fSuppressRedundantIo=%RTbool pIfProgress=%#p pDstIfProgress=%#p\n",
+                 pDiskFrom, pImageFrom, pDiskTo, cbSize, cImagesFromRead, cImagesToRead, fSuppressRedundantIo, pDstIfProgress, pDstIfProgress));
+
+    if (   (fSuppressRedundantIo || (cImagesFromRead > 0))
+        && RTListIsEmpty(&pDiskFrom->ListFilterChainRead))
+        fBlockwiseCopy = true;
+
+    /* Allocate tmp buffer. */
+    pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
+    if (!pvBuf)
+        return rc;
+
+    do
+    {
+        size_t cbThisRead = RT_MIN(VD_MERGE_BUFFER_SIZE, cbRemaining);
+
+        /* Note that we don't attempt to synchronize cross-disk accesses.
+         * It wouldn't be very difficult to do, just the lock order would
+         * need to be defined somehow to prevent deadlocks. Postpone such
+         * magic as there is no use case for this. */
+
+        rc2 = vdThreadStartRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = true;
+
+        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, cbThisRead, &IoCtx,
+                                              &cbThisRead);
+
+            if (   rc == VERR_VD_BLOCK_FREE
+                && cImagesFromRead != 1)
+            {
+                unsigned cImagesToProcess = cImagesFromRead;
+
+                for (PVDIMAGE pCurrImage = pImageFrom->pPrev;
+                     pCurrImage != NULL && rc == VERR_VD_BLOCK_FREE;
+                     pCurrImage = pCurrImage->pPrev)
+                {
+                    rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                                           uOffset, cbThisRead,
+                                                           &IoCtx, &cbThisRead);
+                    if (cImagesToProcess == 1)
+                        break;
+                    else if (cImagesToProcess > 0)
+                        cImagesToProcess--;
+                }
+            }
+        }
+        else
+            rc = vdReadHelper(pDiskFrom, pImageFrom, uOffset, pvBuf, cbThisRead,
+                              false /* fUpdateCache */);
+
+        if (RT_FAILURE(rc) && rc != VERR_VD_BLOCK_FREE)
+            break;
+
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = false;
+
+        if (rc != VERR_VD_BLOCK_FREE)
+        {
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+
+            /* Only do collapsed I/O if we are copying the data blockwise. */
+            rc = vdWriteHelperEx(pDiskTo, pDiskTo->pLast, NULL, uOffset, pvBuf,
+                                 cbThisRead, VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG /* fFlags */,
+                                 fBlockwiseCopy ? cImagesToRead : 0);
+            if (RT_FAILURE(rc))
+                break;
+
+            rc2 = vdThreadFinishWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = false;
+        }
+        else /* Don't propagate the error to the outside */
+            rc = VINF_SUCCESS;
+
+        uOffset += cbThisRead;
+        cbRemaining -= cbThisRead;
+
+        unsigned uProgressNew = uOffset * 99 / cbSize;
+        if (uProgressNew != uProgressOld)
+        {
+            uProgressOld = uProgressNew;
+
+            if (pIfProgress && pIfProgress->pfnProgress)
+            {
+                rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
+                                              uProgressOld);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+            if (pDstIfProgress && pDstIfProgress->pfnProgress)
+            {
+                rc = pDstIfProgress->pfnProgress(pDstIfProgress->Core.pvUser,
+                                                 uProgressOld);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+        }
+    } while (uOffset < cbSize);
+
+    RTMemFree(pvBuf);
+
+    if (fLockReadFrom)
+    {
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+    }
+
+    if (fLockWriteTo)
+    {
+        rc2 = vdThreadFinishWrite(pDiskTo);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+/**
+ * Flush helper async version.
+ */
+static DECLCALLBACK(int) vdSetModifiedHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
+
+    rc = pImage->Backend->pfnFlush(pImage->pBackendData, pIoCtx);
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+
+    return rc;
+}
+
+/**
+ * internal: mark the disk as modified - async version.
+ */
+static int vdSetModifiedFlagAsync(PVDISK pDisk, PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    pDisk->uModified |= VD_IMAGE_MODIFIED_FLAG;
+    if (pDisk->uModified & VD_IMAGE_MODIFIED_FIRST)
+    {
+        rc = vdIoCtxLockDisk(pDisk, pIoCtx);
+        if (RT_SUCCESS(rc))
+        {
+            pDisk->uModified &= ~VD_IMAGE_MODIFIED_FIRST;
+
+            /* First modify, so create a UUID and ensure it's written to disk. */
+            vdResetModifiedFlag(pDisk);
+
+            if (!(pDisk->uModified & VD_IMAGE_MODIFIED_DISABLE_UUID_UPDATE))
+            {
+                PVDIOCTX pIoCtxFlush = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_FLUSH,
+                                                         0, 0, pDisk->pLast,
+                                                         NULL, pIoCtx, 0, 0, NULL,
+                                                         vdSetModifiedHelperAsync);
+
+                if (pIoCtxFlush)
+                {
+                    rc = vdIoCtxProcessLocked(pIoCtxFlush);
+                    if (rc == VINF_VD_ASYNC_IO_FINISHED)
+                    {
+                        vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs */);
+                        vdIoCtxFree(pDisk, pIoCtxFlush);
+                    }
+                    else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+                    {
+                        ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+                        pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+                    }
+                    else /* Another error */
+                        vdIoCtxFree(pDisk, pIoCtxFlush);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+        }
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperCommitAsync(PVDIOCTX pIoCtx)
+{
+    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->pfnWrite(pImage->pBackendData,
+                                   pIoCtx->Req.Io.uOffset - cbPreRead,
+                                   cbPreRead + cbThisWrite + cbPostRead,
+                                   pIoCtx, NULL, &cbPreRead, &cbPostRead, 0);
+    Assert(rc != VERR_VD_BLOCK_FREE);
+    Assert(rc == VERR_VD_NOT_ENOUGH_METADATA || cbPreRead == 0);
+    Assert(rc == VERR_VD_NOT_ENOUGH_METADATA || cbPostRead == 0);
+    if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+    else if (rc == VERR_VD_IOCTX_HALT)
+    {
+        pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+        rc = VINF_SUCCESS;
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperOptimizedCmpAndWriteAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    size_t cbThisWrite    = 0;
+    size_t cbPreRead      = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead     = pIoCtx->Type.Child.cbPostRead;
+    size_t cbWriteCopy    = pIoCtx->Type.Child.Write.Optimized.cbWriteCopy;
+    size_t cbFill         = pIoCtx->Type.Child.Write.Optimized.cbFill;
+    size_t cbReadImage    = pIoCtx->Type.Child.Write.Optimized.cbReadImage;
+    PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    AssertPtr(pIoCtxParent);
+    Assert(!pIoCtxParent->pIoCtxParent);
+    Assert(!pIoCtx->Req.Io.cbTransferLeft && !pIoCtx->cMetaTransfersPending);
+
+    vdIoCtxChildReset(pIoCtx);
+    cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
+
+    /* Check if the write would modify anything in this block. */
+    if (!RTSgBufCmp(&pIoCtx->Req.Io.SgBuf, &pIoCtxParent->Req.Io.SgBuf, cbThisWrite))
+    {
+        RTSGBUF SgBufSrcTmp;
+
+        RTSgBufClone(&SgBufSrcTmp, &pIoCtxParent->Req.Io.SgBuf);
+        RTSgBufAdvance(&SgBufSrcTmp, cbThisWrite);
+        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->Req.Io.cbTransferLeft, 0);
+            RTSgBufAdvance(&pIoCtxParent->Req.Io.SgBuf, cbThisWrite);
+            return VINF_VD_ASYNC_IO_FINISHED;
+        }
+    }
+
+    /* Copy the data to the right place in the buffer. */
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbPreRead);
+    vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
+
+    /* Handle the data that goes after the write to fill the block. */
+    if (cbPostRead)
+    {
+        /* Now assemble the remaining data. */
+        if (cbWriteCopy)
+        {
+            /*
+             * The S/G buffer of the parent needs to be cloned because
+             * it is not allowed to modify the state.
+             */
+            RTSGBUF SgBufParentTmp;
+
+            RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->Req.Io.SgBuf);
+            RTSgBufCopy(&pIoCtx->Req.Io.SgBuf, &SgBufParentTmp, cbWriteCopy);
+        }
+
+        /* Zero out the remainder of this block. Will never be visible, as this
+         * is beyond the limit of the image. */
+        if (cbFill)
+        {
+            RTSgBufAdvance(&pIoCtx->Req.Io.SgBuf, cbReadImage);
+            vdIoCtxSet(pIoCtx, '\0', cbFill);
+        }
+    }
+
+    /* Write the full block to the virtual disk. */
+    RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+    pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperOptimizedPreReadAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
+
+    if (   pIoCtx->Req.Io.cbTransferLeft
+        && !pIoCtx->cDataTransfersPending)
+        rc = vdReadHelperAsync(pIoCtx);
+
+    if (   (   RT_SUCCESS(rc)
+            || (rc == VERR_VD_ASYNC_IO_IN_PROGRESS))
+        && (   pIoCtx->Req.Io.cbTransferLeft
+            || pIoCtx->cMetaTransfersPending))
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+    else
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedCmpAndWriteAsync;
+
+    return rc;
+}
+
+/**
+ * internal: write a complete block (only used for diff images), taking the
+ * remaining data from parent images. This implementation optimizes out writes
+ * that do not change the data relative to the state as of the parent images.
+ * All backends which support differential/growing images support this - async version.
+ */
+static DECLCALLBACK(int) vdWriteHelperOptimizedAsync(PVDIOCTX pIoCtx)
+{
+    PVDISK pDisk = pIoCtx->pDisk;
+    uint64_t uOffset   = pIoCtx->Type.Child.uOffsetSaved;
+    size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    size_t cbPreRead   = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead  = pIoCtx->Type.Child.cbPostRead;
+    size_t cbWrite     = pIoCtx->Type.Child.cbWriteParent;
+    size_t cbFill = 0;
+    size_t cbWriteCopy = 0;
+    size_t cbReadImage = 0;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    AssertPtr(pIoCtx->pIoCtxParent);
+    Assert(!pIoCtx->pIoCtxParent->pIoCtxParent);
+
+    if (cbPostRead)
+    {
+        /* Figure out how much we cannot read from the image, because
+         * the last block to write might exceed the nominal size of the
+         * image for technical reasons. */
+        if (uOffset + cbThisWrite + cbPostRead > pDisk->cbSize)
+            cbFill = uOffset + cbThisWrite + cbPostRead - pDisk->cbSize;
+
+        /* If we have data to be written, use that instead of reading
+         * data from the image. */
+        if (cbWrite > cbThisWrite)
+            cbWriteCopy = RT_MIN(cbWrite - cbThisWrite, cbPostRead);
+
+        /* The rest must be read from the image. */
+        cbReadImage = cbPostRead - cbWriteCopy - cbFill;
+    }
+
+    pIoCtx->Type.Child.Write.Optimized.cbFill      = cbFill;
+    pIoCtx->Type.Child.Write.Optimized.cbWriteCopy = cbWriteCopy;
+    pIoCtx->Type.Child.Write.Optimized.cbReadImage = cbReadImage;
+
+    /* Read the entire data of the block so that we can compare whether it will
+     * be modified by the write or not. */
+    size_t cbTmp = cbPreRead + cbThisWrite + cbPostRead - cbFill; Assert(cbTmp == (uint32_t)cbTmp);
+    pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbTmp;
+    pIoCtx->Req.Io.cbTransfer     = pIoCtx->Req.Io.cbTransferLeft;
+    pIoCtx->Req.Io.uOffset       -= cbPreRead;
+
+    /* Next step */
+    pIoCtx->pfnIoCtxTransferNext = vdWriteHelperOptimizedPreReadAsync;
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vdWriteHelperStandardReadImageAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
+
+    if (   pIoCtx->Req.Io.cbTransferLeft
+        && !pIoCtx->cDataTransfersPending)
+        rc = vdReadHelperAsync(pIoCtx);
+
+    if (   RT_SUCCESS(rc)
+        && (   pIoCtx->Req.Io.cbTransferLeft
+            || pIoCtx->cMetaTransfersPending))
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+    else
+    {
+        size_t cbFill = pIoCtx->Type.Child.Write.Optimized.cbFill;
+
+        /* Zero out the remainder of this block. Will never be visible, as this
+         * is beyond the limit of the image. */
+        if (cbFill)
+            vdIoCtxSet(pIoCtx, '\0', cbFill);
+
+        /* Write the full block to the virtual disk. */
+        RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+
+        vdIoCtxChildReset(pIoCtx);
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperStandardAssemble(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    size_t cbPostRead  = pIoCtx->Type.Child.cbPostRead;
+    size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    vdIoCtxCopy(pIoCtx, pIoCtxParent, cbThisWrite);
+    if (cbPostRead)
+    {
+        size_t cbFill = pIoCtx->Type.Child.Write.Optimized.cbFill;
+        size_t cbWriteCopy = pIoCtx->Type.Child.Write.Optimized.cbWriteCopy;
+        size_t cbReadImage = pIoCtx->Type.Child.Write.Optimized.cbReadImage;
+
+        /* Now assemble the remaining data. */
+        if (cbWriteCopy)
+        {
+            /*
+             * The S/G buffer of the parent needs to be cloned because
+             * it is not allowed to modify the state.
+             */
+            RTSGBUF SgBufParentTmp;
+
+            RTSgBufClone(&SgBufParentTmp, &pIoCtxParent->Req.Io.SgBuf);
+            RTSgBufCopy(&pIoCtx->Req.Io.SgBuf, &SgBufParentTmp, cbWriteCopy);
+        }
+
+        if (cbReadImage)
+        {
+            /* Read remaining data. */
+            pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardReadImageAsync;
+
+            /* Read the data that goes before the write to fill the block. */
+            pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbReadImage; Assert(cbReadImage == (uint32_t)cbReadImage);
+            pIoCtx->Req.Io.cbTransfer     = pIoCtx->Req.Io.cbTransferLeft;
+            pIoCtx->Req.Io.uOffset       += cbWriteCopy;
+        }
+        else
+        {
+            /* Zero out the remainder of this block. Will never be visible, as this
+             * is beyond the limit of the image. */
+            if (cbFill)
+                vdIoCtxSet(pIoCtx, '\0', cbFill);
+
+            /* Write the full block to the virtual disk. */
+            RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+            vdIoCtxChildReset(pIoCtx);
+            pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
+        }
+    }
+    else
+    {
+        /* Write the full block to the virtual disk. */
+        RTSgBufReset(&pIoCtx->Req.Io.SgBuf);
+        vdIoCtxChildReset(pIoCtx);
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperCommitAsync;
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperStandardPreReadAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    pIoCtx->fFlags |= VDIOCTX_FLAGS_ZERO_FREE_BLOCKS;
+
+    if (   pIoCtx->Req.Io.cbTransferLeft
+        && !pIoCtx->cDataTransfersPending)
+        rc = vdReadHelperAsync(pIoCtx);
+
+    if (   RT_SUCCESS(rc)
+        && (   pIoCtx->Req.Io.cbTransferLeft
+            || pIoCtx->cMetaTransfersPending))
+        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+     else
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardAssemble;
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdWriteHelperStandardAsync(PVDIOCTX pIoCtx)
+{
+    PVDISK pDisk = pIoCtx->pDisk;
+    uint64_t uOffset   = pIoCtx->Type.Child.uOffsetSaved;
+    size_t cbThisWrite = pIoCtx->Type.Child.cbTransferParent;
+    size_t cbPreRead   = pIoCtx->Type.Child.cbPreRead;
+    size_t cbPostRead  = pIoCtx->Type.Child.cbPostRead;
+    size_t cbWrite     = pIoCtx->Type.Child.cbWriteParent;
+    size_t cbFill = 0;
+    size_t cbWriteCopy = 0;
+    size_t cbReadImage = 0;
+
+    LogFlowFunc(("pIoCtx=%#p\n", pIoCtx));
+
+    AssertPtr(pIoCtx->pIoCtxParent);
+    Assert(!pIoCtx->pIoCtxParent->pIoCtxParent);
+
+    /* Calculate the amount of data to read that goes after the write to fill the block. */
+    if (cbPostRead)
+    {
+        /* If we have data to be written, use that instead of reading
+         * data from the image. */
+        if (cbWrite > cbThisWrite)
+            cbWriteCopy = RT_MIN(cbWrite - cbThisWrite, cbPostRead);
+        else
+            cbWriteCopy = 0;
+
+        /* Figure out how much we cannot read from the image, because
+         * the last block to write might exceed the nominal size of the
+         * image for technical reasons. */
+        if (uOffset + cbThisWrite + cbPostRead > pDisk->cbSize)
+            cbFill = uOffset + cbThisWrite + cbPostRead - pDisk->cbSize;
+
+        /* The rest must be read from the image. */
+        cbReadImage = cbPostRead - cbWriteCopy - cbFill;
+    }
+
+    pIoCtx->Type.Child.Write.Optimized.cbFill      = cbFill;
+    pIoCtx->Type.Child.Write.Optimized.cbWriteCopy = cbWriteCopy;
+    pIoCtx->Type.Child.Write.Optimized.cbReadImage = cbReadImage;
+
+    /* Next step */
+    if (cbPreRead)
+    {
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardPreReadAsync;
+
+        /* Read the data that goes before the write to fill the block. */
+        pIoCtx->Req.Io.cbTransferLeft = (uint32_t)cbPreRead; Assert(cbPreRead == (uint32_t)cbPreRead);
+        pIoCtx->Req.Io.cbTransfer     = pIoCtx->Req.Io.cbTransferLeft;
+        pIoCtx->Req.Io.uOffset       -= cbPreRead;
+    }
+    else
+        pIoCtx->pfnIoCtxTransferNext = vdWriteHelperStandardAssemble;
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * internal: write buffer to the image, taking care of block boundaries and
+ * write optimizations - async version.
+ */
+static DECLCALLBACK(int) vdWriteHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc;
+    size_t cbWrite   = pIoCtx->Req.Io.cbTransfer;
+    uint64_t uOffset = pIoCtx->Req.Io.uOffset;
+    PVDIMAGE pImage  = pIoCtx->Req.Io.pImageCur;
+    PVDISK pDisk   = pIoCtx->pDisk;
+    unsigned fWrite;
+    size_t cbThisWrite;
+    size_t cbPreRead, cbPostRead;
+
+    /* Apply write filter chain here if it was not done already. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_WRITE_FILTER_APPLIED))
+    {
+        rc = vdFilterChainApplyWrite(pDisk, uOffset, cbWrite, pIoCtx);
+        if (RT_FAILURE(rc))
+            return rc;
+        pIoCtx->fFlags |= VDIOCTX_FLAGS_WRITE_FILTER_APPLIED;
+    }
+
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_SET_MODIFIED_FLAG))
+    {
+        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;
+
+    /* Loop until all written. */
+    do
+    {
+        /* Try to write the possibly partial block to the last opened image.
+         * This works when the block is already allocated in this image or
+         * if it is a full-block write (and allocation isn't suppressed below).
+         * For image formats which don't support zero blocks, it's beneficial
+         * to avoid unnecessarily allocating unchanged blocks. This prevents
+         * unwanted expanding of images. VMDK is an example. */
+        cbThisWrite = cbWrite;
+
+        /*
+         * Check whether there is a full block write in progress which was not allocated.
+         * Defer I/O if the range interferes.
+         */
+        if (   pDisk->pIoCtxLockOwner != NIL_VDIOCTX
+            && uOffset >= pDisk->uOffsetStartLocked
+            && uOffset < pDisk->uOffsetEndLocked)
+        {
+            Log(("Interferring write while allocating a new block => deferring write\n"));
+            vdIoCtxDefer(pDisk, pIoCtx);
+            rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+            break;
+        }
+
+        fWrite =   (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
+                 ? 0 : VD_WRITE_NO_ALLOC;
+        rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffset, cbThisWrite,
+                                       pIoCtx, &cbThisWrite, &cbPreRead, &cbPostRead,
+                                       fWrite);
+        if (rc == VERR_VD_BLOCK_FREE)
+        {
+            /* Lock the disk .*/
+            rc = vdIoCtxLockDisk(pDisk, pIoCtx);
+            if (RT_SUCCESS(rc))
+            {
+                /*
+                 * Allocate segment and buffer in one go.
+                 * A bit hackish but avoids the need to allocate memory twice.
+                 */
+                PRTSGBUF pTmp = (PRTSGBUF)RTMemAlloc(cbPreRead + cbThisWrite + cbPostRead + sizeof(RTSGSEG) + sizeof(RTSGBUF));
+                AssertBreakStmt(pTmp, rc = VERR_NO_MEMORY);
+                PRTSGSEG pSeg = (PRTSGSEG)(pTmp + 1);
+
+                pSeg->pvSeg = pSeg + 1;
+                pSeg->cbSeg = cbPreRead + cbThisWrite + cbPostRead;
+                RTSgBufInit(pTmp, pSeg, 1);
+
+                PVDIOCTX pIoCtxWrite = vdIoCtxChildAlloc(pDisk, VDIOCTXTXDIR_WRITE,
+                                                         uOffset, pSeg->cbSeg, pImage,
+                                                         pTmp,
+                                                         pIoCtx, cbThisWrite,
+                                                         cbWrite,
+                                                         pTmp,
+                                                           (pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME)
+                                                         ? vdWriteHelperStandardAsync
+                                                         : vdWriteHelperOptimizedAsync);
+                if (!pIoCtxWrite)
+                {
+                    RTMemTmpFree(pTmp);
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+
+                LogFlowFunc(("Disk is growing because of pIoCtx=%#p pIoCtxWrite=%#p\n",
+                             pIoCtx, pIoCtxWrite));
+
+                /* Save the current range for the growing operation to check for intersecting requests later. */
+                pDisk->uOffsetStartLocked = uOffset - cbPreRead;
+                pDisk->uOffsetEndLocked = uOffset + cbThisWrite + cbPostRead;
+
+                pIoCtxWrite->Type.Child.cbPreRead  = cbPreRead;
+                pIoCtxWrite->Type.Child.cbPostRead = cbPostRead;
+                pIoCtxWrite->Req.Io.pImageParentOverride = pIoCtx->Req.Io.pImageParentOverride;
+
+                /* Process the write request */
+                rc = vdIoCtxProcessLocked(pIoCtxWrite);
+
+                if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
+                {
+                    vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs*/ );
+                    vdIoCtxFree(pDisk, pIoCtxWrite);
+                    break;
+                }
+                else if (   rc == VINF_VD_ASYNC_IO_FINISHED
+                         && ASMAtomicCmpXchgBool(&pIoCtxWrite->fComplete, true, false))
+                {
+                    LogFlow(("Child write request completed\n"));
+                    Assert(pIoCtx->Req.Io.cbTransferLeft >= cbThisWrite);
+                    Assert(cbThisWrite == (uint32_t)cbThisWrite);
+                    rc = pIoCtxWrite->rcReq;
+                    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbThisWrite);
+                    vdIoCtxUnlockDisk(pDisk, pIoCtx, false /* fProcessDeferredReqs*/ );
+                    vdIoCtxFree(pDisk, pIoCtxWrite);
+                }
+                else
+                {
+                    LogFlow(("Child write pending\n"));
+                    ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+                    pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+                    rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+                    cbWrite -= cbThisWrite;
+                    uOffset += cbThisWrite;
+                    break;
+                }
+            }
+            else
+            {
+                rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
+                break;
+            }
+        }
+
+        if (rc == VERR_VD_IOCTX_HALT)
+        {
+            cbWrite -= cbThisWrite;
+            uOffset += cbThisWrite;
+            pIoCtx->fFlags |= VDIOCTX_FLAGS_BLOCKED;
+            break;
+        }
+        else if (rc == VERR_VD_NOT_ENOUGH_METADATA)
+            break;
+
+        cbWrite -= cbThisWrite;
+        uOffset += cbThisWrite;
+    } while (cbWrite != 0 && (RT_SUCCESS(rc) || rc == VERR_VD_ASYNC_IO_IN_PROGRESS));
+
+    if (   rc == VERR_VD_ASYNC_IO_IN_PROGRESS
+        || rc == VERR_VD_NOT_ENOUGH_METADATA
+        || rc == VERR_VD_IOCTX_HALT)
+    {
+        /*
+         * Tell the caller that we don't need to go back here because all
+         * writes are initiated.
+         */
+        if (   !cbWrite
+            && rc != VERR_VD_IOCTX_HALT)
+            rc = VINF_SUCCESS;
+
+        pIoCtx->Req.Io.uOffset    = uOffset;
+        pIoCtx->Req.Io.cbTransfer = cbWrite;
+    }
+
+    return rc;
+}
+
+/**
+ * Flush helper async version.
+ */
+static DECLCALLBACK(int) vdFlushHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK pDisk = pIoCtx->pDisk;
+    PVDIMAGE pImage = pIoCtx->Req.Io.pImageCur;
+
+    rc = vdIoCtxLockDisk(pDisk, pIoCtx);
+    if (RT_SUCCESS(rc))
+    {
+        /* Mark the whole disk as locked. */
+        pDisk->uOffsetStartLocked = 0;
+        pDisk->uOffsetEndLocked = UINT64_C(0xffffffffffffffff);
+
+        vdResetModifiedFlag(pDisk);
+        rc = pImage->Backend->pfnFlush(pImage->pBackendData, pIoCtx);
+        if (   (   RT_SUCCESS(rc)
+                || rc == VERR_VD_ASYNC_IO_IN_PROGRESS
+                || rc == VERR_VD_IOCTX_HALT)
+            && pDisk->pCache)
+        {
+            rc = pDisk->pCache->Backend->pfnFlush(pDisk->pCache->pBackendData, pIoCtx);
+            if (   RT_SUCCESS(rc)
+                || (   rc != VERR_VD_ASYNC_IO_IN_PROGRESS
+                    && rc != VERR_VD_IOCTX_HALT))
+                vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessBlockedReqs */);
+            else if (rc != VERR_VD_IOCTX_HALT)
+                rc = VINF_SUCCESS;
+        }
+        else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+            rc = VINF_SUCCESS;
+        else if (rc != VERR_VD_IOCTX_HALT)/* Some other error. */
+            vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessBlockedReqs */);
+    }
+
+    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 DECLCALLBACK(int) vdDiscardWholeBlockAsync(PVDIOCTX pIoCtx)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK 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->pfnDiscard(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); RT_NOREF1(pBlockRemove);
+
+        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   pIoCtx             The I/O context associated with this discard operation.
+ * @param   cbDiscardingNew    How many bytes should be waiting on success.
+ *                             The number of bytes waiting can be less.
+ */
+static int vdDiscardRemoveBlocksAsync(PVDISK 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 = (uint32_t)(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->pfnDiscard(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); NOREF(pBlockRemove);
+        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 DECLCALLBACK(int) vdDiscardCurrentRangeAsync(PVDIOCTX pIoCtx)
+{
+    PVDISK        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->pfnDiscard(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); NOREF(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 DECLCALLBACK(int) vdDiscardHelperAsync(PVDIOCTX pIoCtx)
+{
+    int rc             = VINF_SUCCESS;
+    PVDISK  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;
+
+        pDisk->uOffsetStartLocked = offStart;
+        pDisk->uOffsetEndLocked = offStart + cbDiscardLeft;
+
+        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 + (int32_t)(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, (uint32_t)(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;
+}
+
+/**
+ * VD async I/O interface open callback.
+ */
+static DECLCALLBACK(int) vdIOOpenFallback(void *pvUser, const char *pszLocation,
+                                          uint32_t fOpen, PFNVDCOMPLETED pfnCompleted,
+                                          void **ppStorage)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)RTMemAllocZ(sizeof(VDIIOFALLBACKSTORAGE));
+
+    if (!pStorage)
+        return VERR_NO_MEMORY;
+
+    pStorage->pfnCompleted = pfnCompleted;
+
+    /* Open the file. */
+    int rc = RTFileOpen(&pStorage->File, pszLocation, fOpen);
+    if (RT_SUCCESS(rc))
+    {
+        *ppStorage = pStorage;
+        return VINF_SUCCESS;
+    }
+
+    RTMemFree(pStorage);
+    return rc;
+}
+
+/**
+ * VD async I/O interface close callback.
+ */
+static DECLCALLBACK(int) vdIOCloseFallback(void *pvUser, void *pvStorage)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    RTFileClose(pStorage->File);
+    RTMemFree(pStorage);
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vdIODeleteFallback(void *pvUser, const char *pcszFilename)
+{
+    RT_NOREF1(pvUser);
+    return RTFileDelete(pcszFilename);
+}
+
+static DECLCALLBACK(int) vdIOMoveFallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
+{
+    RT_NOREF1(pvUser);
+    return RTFileMove(pcszSrc, pcszDst, fMove);
+}
+
+static DECLCALLBACK(int) vdIOGetFreeSpaceFallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
+{
+    RT_NOREF1(pvUser);
+    return RTFsQuerySizes(pcszFilename, NULL, pcbFreeSpace, NULL, NULL);
+}
+
+static DECLCALLBACK(int) vdIOGetModificationTimeFallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
+{
+    RT_NOREF1(pvUser);
+    RTFSOBJINFO info;
+    int rc = RTPathQueryInfo(pcszFilename, &info, RTFSOBJATTRADD_NOTHING);
+    if (RT_SUCCESS(rc))
+        *pModificationTime = info.ModificationTime;
+    return rc;
+}
+
+/**
+ * VD async I/O interface callback for retrieving the file size.
+ */
+static DECLCALLBACK(int) vdIOGetSizeFallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileQuerySize(pStorage->File, pcbSize);
+}
+
+/**
+ * VD async I/O interface callback for setting the file size.
+ */
+static DECLCALLBACK(int) vdIOSetSizeFallback(void *pvUser, void *pvStorage, uint64_t cbSize)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileSetSize(pStorage->File, cbSize);
+}
+
+/**
+ * VD async I/O interface callback for setting the file allocation size.
+ */
+static DECLCALLBACK(int) vdIOSetAllocationSizeFallback(void *pvUser, void *pvStorage, uint64_t cbSize,
+                                                       uint32_t fFlags)
+{
+    RT_NOREF2(pvUser, fFlags);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileSetAllocationSize(pStorage->File, cbSize, RTFILE_ALLOC_SIZE_F_DEFAULT);
+}
+
+/**
+ * VD async I/O interface callback for a synchronous write to the file.
+ */
+static DECLCALLBACK(int) vdIOWriteSyncFallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+                                               const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileWriteAt(pStorage->File, uOffset, pvBuf, cbWrite, pcbWritten);
+}
+
+/**
+ * VD async I/O interface callback for a synchronous read from the file.
+ */
+static DECLCALLBACK(int) vdIOReadSyncFallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+                                              void *pvBuf, size_t cbRead, size_t *pcbRead)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileReadAt(pStorage->File, uOffset, pvBuf, cbRead, pcbRead);
+}
+
+/**
+ * VD async I/O interface callback for a synchronous flush of the file data.
+ */
+static DECLCALLBACK(int) vdIOFlushSyncFallback(void *pvUser, void *pvStorage)
+{
+    RT_NOREF1(pvUser);
+    PVDIIOFALLBACKSTORAGE pStorage = (PVDIIOFALLBACKSTORAGE)pvStorage;
+
+    return RTFileFlush(pStorage->File);
+}
+
+/**
+ * Internal - Continues an I/O context after
+ * it was halted because of an active transfer.
+ */
+static int vdIoCtxContinue(PVDIOCTX pIoCtx, int rcReq)
+{
+    PVDISK pDisk = pIoCtx->pDisk;
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    if (RT_FAILURE(rcReq))
+        ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rcReq, VINF_SUCCESS);
+
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_BLOCKED))
+    {
+        /* Continue the transfer */
+        rc = vdIoCtxProcessLocked(pIoCtx);
+
+        if (   rc == VINF_VD_ASYNC_IO_FINISHED
+            && ASMAtomicCmpXchgBool(&pIoCtx->fComplete, true, false))
+        {
+            LogFlowFunc(("I/O context completed pIoCtx=%#p\n", pIoCtx));
+            bool fFreeCtx = RT_BOOL(!(pIoCtx->fFlags & VDIOCTX_FLAGS_DONT_FREE));
+            if (pIoCtx->pIoCtxParent)
+            {
+                PVDIOCTX pIoCtxParent = pIoCtx->pIoCtxParent;
+
+                Assert(!pIoCtxParent->pIoCtxParent);
+                if (RT_FAILURE(pIoCtx->rcReq))
+                    ASMAtomicCmpXchgS32(&pIoCtxParent->rcReq, pIoCtx->rcReq, VINF_SUCCESS);
+
+                ASMAtomicDecU32(&pIoCtxParent->cDataTransfersPending);
+
+                if (pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE)
+                {
+                    LogFlowFunc(("I/O context transferred %u bytes for the parent pIoCtxParent=%p\n",
+                                 pIoCtx->Type.Child.cbTransferParent, pIoCtxParent));
+
+                    /* Update the parent state. */
+                    Assert(pIoCtxParent->Req.Io.cbTransferLeft >= pIoCtx->Type.Child.cbTransferParent);
+                    ASMAtomicSubU32(&pIoCtxParent->Req.Io.cbTransferLeft, (uint32_t)pIoCtx->Type.Child.cbTransferParent);
+                }
+                else
+                    Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH);
+
+                /*
+                 * A completed child write means that we finished growing the image.
+                 * We have to process any pending writes now.
+                 */
+                vdIoCtxUnlockDisk(pDisk, pIoCtxParent, false /* fProcessDeferredReqs */);
+
+                /* Unblock the parent */
+                pIoCtxParent->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
+
+                rc = vdIoCtxProcessLocked(pIoCtxParent);
+
+                if (   rc == VINF_VD_ASYNC_IO_FINISHED
+                    && ASMAtomicCmpXchgBool(&pIoCtxParent->fComplete, true, false))
+                {
+                    LogFlowFunc(("Parent I/O context completed pIoCtxParent=%#p rcReq=%Rrc\n", pIoCtxParent, pIoCtxParent->rcReq));
+                    bool fFreeParentCtx = RT_BOOL(!(pIoCtxParent->fFlags & VDIOCTX_FLAGS_DONT_FREE));
+                    vdIoCtxRootComplete(pDisk, pIoCtxParent);
+                    vdThreadFinishWrite(pDisk);
+
+                    if (fFreeParentCtx)
+                        vdIoCtxFree(pDisk, pIoCtxParent);
+                    vdDiskProcessBlockedIoCtx(pDisk);
+                }
+                else if (!vdIoCtxIsDiskLockOwner(pDisk, pIoCtx))
+                {
+                    /* Process any pending writes if the current request didn't caused another growing. */
+                    vdDiskProcessBlockedIoCtx(pDisk);
+                }
+            }
+            else
+            {
+                if (pIoCtx->enmTxDir == VDIOCTXTXDIR_FLUSH)
+                {
+                    vdIoCtxUnlockDisk(pDisk, pIoCtx, true /* fProcessDerredReqs */);
+                    vdThreadFinishWrite(pDisk);
+                }
+                else if (   pIoCtx->enmTxDir == VDIOCTXTXDIR_WRITE
+                         || pIoCtx->enmTxDir == VDIOCTXTXDIR_DISCARD)
+                    vdThreadFinishWrite(pDisk);
+                else
+                {
+                    Assert(pIoCtx->enmTxDir == VDIOCTXTXDIR_READ);
+                    vdThreadFinishRead(pDisk);
+                }
+
+                LogFlowFunc(("I/O context completed pIoCtx=%#p rcReq=%Rrc\n", pIoCtx, pIoCtx->rcReq));
+                vdIoCtxRootComplete(pDisk, pIoCtx);
+            }
+
+            if (fFreeCtx)
+                vdIoCtxFree(pDisk, pIoCtx);
+        }
+    }
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Internal - Called when user transfer completed.
+ */
+static int vdUserXferCompleted(PVDIOSTORAGE pIoStorage, PVDIOCTX pIoCtx,
+                               PFNVDXFERCOMPLETED pfnComplete, void *pvUser,
+                               size_t cbTransfer, int rcReq)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK pDisk = pIoCtx->pDisk;
+
+    LogFlowFunc(("pIoStorage=%#p pIoCtx=%#p pfnComplete=%#p pvUser=%#p cbTransfer=%zu rcReq=%Rrc\n",
+                 pIoStorage, pIoCtx, pfnComplete, pvUser, cbTransfer, rcReq));
+
+    VD_IS_LOCKED(pDisk);
+
+    Assert(pIoCtx->Req.Io.cbTransferLeft >= cbTransfer);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbTransfer); Assert(cbTransfer == (uint32_t)cbTransfer);
+    ASMAtomicDecU32(&pIoCtx->cDataTransfersPending);
+
+    if (pfnComplete)
+        rc = pfnComplete(pIoStorage->pVDIo->pBackendData, pIoCtx, pvUser, rcReq);
+
+    if (RT_SUCCESS(rc))
+        rc = vdIoCtxContinue(pIoCtx, rcReq);
+    else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
+        rc = VINF_SUCCESS;
+
+    return rc;
+}
+
+static void vdIoCtxContinueDeferredList(PVDIOSTORAGE pIoStorage, PRTLISTANCHOR pListWaiting,
+                                        PFNVDXFERCOMPLETED pfnComplete, void *pvUser, int rcReq)
+{
+    LogFlowFunc(("pIoStorage=%#p pListWaiting=%#p pfnComplete=%#p pvUser=%#p rcReq=%Rrc\n",
+                 pIoStorage, pListWaiting, pfnComplete, pvUser, rcReq));
+
+    /* Go through the waiting list and continue the I/O contexts. */
+    while (!RTListIsEmpty(pListWaiting))
+    {
+        int rc = VINF_SUCCESS;
+        PVDIOCTXDEFERRED pDeferred = RTListGetFirst(pListWaiting, VDIOCTXDEFERRED, NodeDeferred);
+        PVDIOCTX pIoCtx = pDeferred->pIoCtx;
+        RTListNodeRemove(&pDeferred->NodeDeferred);
+
+        RTMemFree(pDeferred);
+        ASMAtomicDecU32(&pIoCtx->cMetaTransfersPending);
+
+        if (pfnComplete)
+            rc = pfnComplete(pIoStorage->pVDIo->pBackendData, pIoCtx, pvUser, rcReq);
+
+        LogFlow(("Completion callback for I/O context %#p returned %Rrc\n", pIoCtx, rc));
+
+        if (RT_SUCCESS(rc))
+        {
+            rc = vdIoCtxContinue(pIoCtx, rcReq);
+            AssertRC(rc);
+        }
+        else
+            Assert(rc == VERR_VD_ASYNC_IO_IN_PROGRESS);
+    }
+}
+
+/**
+ * Internal - Called when a meta transfer completed.
+ */
+static int vdMetaXferCompleted(PVDIOSTORAGE pIoStorage, PFNVDXFERCOMPLETED pfnComplete, void *pvUser,
+                               PVDMETAXFER pMetaXfer, int rcReq)
+{
+    PVDISK pDisk = pIoStorage->pVDIo->pDisk;
+    RTLISTANCHOR ListIoCtxWaiting;
+    bool fFlush;
+
+    LogFlowFunc(("pIoStorage=%#p pfnComplete=%#p pvUser=%#p pMetaXfer=%#p rcReq=%Rrc\n",
+                 pIoStorage, pfnComplete, pvUser, pMetaXfer, rcReq));
+
+    VD_IS_LOCKED(pDisk);
+
+    fFlush = VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_FLUSH;
+
+    if (!fFlush)
+    {
+        RTListMove(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxWaiting);
+
+        if (RT_FAILURE(rcReq))
+        {
+            /* Remove from the AVL tree. */
+            LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
+            bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
+            Assert(fRemoved); NOREF(fRemoved);
+            /* If this was a write check if there is a shadow buffer with updated data. */
+            if (pMetaXfer->pbDataShw)
+            {
+                Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
+                Assert(!RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites));
+                RTListConcatenate(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxShwWrites);
+                RTMemFree(pMetaXfer->pbDataShw);
+                pMetaXfer->pbDataShw = NULL;
+            }
+            RTMemFree(pMetaXfer);
+        }
+        else
+        {
+            /* Increase the reference counter to make sure it doesn't go away before the last context is processed. */
+            pMetaXfer->cRefs++;
+        }
+    }
+    else
+        RTListMove(&ListIoCtxWaiting, &pMetaXfer->ListIoCtxWaiting);
+
+    VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
+    vdIoCtxContinueDeferredList(pIoStorage, &ListIoCtxWaiting, pfnComplete, pvUser, rcReq);
+
+    /*
+     * If there is a shadow buffer and the previous write was successful update with the
+     * new data and trigger a new write.
+     */
+    if (   pMetaXfer->pbDataShw
+        && RT_SUCCESS(rcReq)
+        && VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE)
+    {
+        LogFlowFunc(("pMetaXfer=%#p Updating from shadow buffer and triggering new write\n", pMetaXfer));
+        memcpy(pMetaXfer->abData, pMetaXfer->pbDataShw, pMetaXfer->cbMeta);
+        RTMemFree(pMetaXfer->pbDataShw);
+        pMetaXfer->pbDataShw = NULL;
+        Assert(!RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites));
+
+        /* Setup a new I/O write. */
+        PVDIOTASK pIoTask = vdIoTaskMetaAlloc(pIoStorage, pfnComplete, pvUser, pMetaXfer);
+        if (RT_LIKELY(pIoTask))
+        {
+            void *pvTask = NULL;
+            RTSGSEG Seg;
+
+            Seg.cbSeg = pMetaXfer->cbMeta;
+            Seg.pvSeg = pMetaXfer->abData;
+
+            VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_WRITE);
+            rcReq = pIoStorage->pVDIo->pInterfaceIo->pfnWriteAsync(pIoStorage->pVDIo->pInterfaceIo->Core.pvUser,
+                                                                   pIoStorage->pStorage,
+                                                                   pMetaXfer->Core.Key, &Seg, 1,
+                                                                   pMetaXfer->cbMeta, pIoTask,
+                                                                   &pvTask);
+            if (   RT_SUCCESS(rcReq)
+                || rcReq != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            {
+                VDMETAXFER_TXDIR_SET(pMetaXfer->fFlags, VDMETAXFER_TXDIR_NONE);
+                vdIoTaskFree(pDisk, pIoTask);
+            }
+            else
+                RTListMove(&pMetaXfer->ListIoCtxWaiting, &pMetaXfer->ListIoCtxShwWrites);
+        }
+        else
+            rcReq = VERR_NO_MEMORY;
+
+        /* Cleanup if there was an error or the request completed already. */
+        if (rcReq != VERR_VD_ASYNC_IO_IN_PROGRESS)
+            vdIoCtxContinueDeferredList(pIoStorage, &pMetaXfer->ListIoCtxShwWrites, pfnComplete, pvUser, rcReq);
+    }
+
+    /* Remove if not used anymore. */
+    if (!fFlush)
+    {
+        pMetaXfer->cRefs--;
+        if (!pMetaXfer->cRefs && RTListIsEmpty(&pMetaXfer->ListIoCtxWaiting))
+        {
+            /* Remove from the AVL tree. */
+            LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
+            bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
+            Assert(fRemoved); NOREF(fRemoved);
+            RTMemFree(pMetaXfer);
+        }
+    }
+    else if (fFlush)
+        RTMemFree(pMetaXfer);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Processes a list of waiting I/O tasks. The disk lock must be held by caller.
+ *
+ * @param   pDisk    The disk to process the list for.
+ */
+static void vdIoTaskProcessWaitingList(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    VD_IS_LOCKED(pDisk);
+
+    PVDIOTASK pHead = ASMAtomicXchgPtrT(&pDisk->pIoTasksPendingHead, NULL, PVDIOTASK);
+
+    Log(("I/O task list cleared\n"));
+
+    /* Reverse order. */
+    PVDIOTASK pCur = pHead;
+    pHead = NULL;
+    while (pCur)
+    {
+        PVDIOTASK pInsert = pCur;
+        pCur = pCur->pNext;
+        pInsert->pNext = pHead;
+        pHead = pInsert;
+    }
+
+    while (pHead)
+    {
+        PVDIOSTORAGE pIoStorage = pHead->pIoStorage;
+
+        if (!pHead->fMeta)
+            vdUserXferCompleted(pIoStorage, pHead->Type.User.pIoCtx,
+                                pHead->pfnComplete, pHead->pvUser,
+                                pHead->Type.User.cbTransfer, pHead->rcReq);
+        else
+            vdMetaXferCompleted(pIoStorage, pHead->pfnComplete, pHead->pvUser,
+                                pHead->Type.Meta.pMetaXfer, pHead->rcReq);
+
+        pCur = pHead;
+        pHead = pHead->pNext;
+        vdIoTaskFree(pDisk, pCur);
+    }
+}
+
+/**
+ * Process any I/O context on the halted list.
+ *
+ * @param   pDisk    The disk.
+ */
+static void vdIoCtxProcessHaltedList(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    VD_IS_LOCKED(pDisk);
+
+    /* Get the waiting list and process it in FIFO order. */
+    PVDIOCTX pIoCtxHead = ASMAtomicXchgPtrT(&pDisk->pIoCtxHaltedHead, NULL, PVDIOCTX);
+
+    /* Reverse it. */
+    PVDIOCTX pCur = pIoCtxHead;
+    pIoCtxHead = NULL;
+    while (pCur)
+    {
+        PVDIOCTX pInsert = pCur;
+        pCur = pCur->pIoCtxNext;
+        pInsert->pIoCtxNext = pIoCtxHead;
+        pIoCtxHead = pInsert;
+    }
+
+    /* Process now. */
+    pCur = pIoCtxHead;
+    while (pCur)
+    {
+        PVDIOCTX pTmp = pCur;
+
+        pCur = pCur->pIoCtxNext;
+        pTmp->pIoCtxNext = NULL;
+
+        /* Continue */
+        pTmp->fFlags &= ~VDIOCTX_FLAGS_BLOCKED;
+        vdIoCtxContinue(pTmp, pTmp->rcReq);
+    }
+}
+
+/**
+ * Unlock the disk and process pending tasks.
+ *
+ * @returns VBox status code.
+ * @param   pDisk    The disk to unlock.
+ * @param   pIoCtxRc The I/O context to get the status code from, optional.
+ */
+static int vdDiskUnlock(PVDISK pDisk, PVDIOCTX pIoCtxRc)
+{
+    int rc = VINF_SUCCESS;
+
+    VD_IS_LOCKED(pDisk);
+
+    /*
+     * Process the list of waiting I/O tasks first
+     * because they might complete I/O contexts.
+     * Same for the list of halted I/O contexts.
+     * Afterwards comes the list of new I/O contexts.
+     */
+    vdIoTaskProcessWaitingList(pDisk);
+    vdIoCtxProcessHaltedList(pDisk);
+    rc = vdDiskProcessWaitingIoCtx(pDisk, pIoCtxRc);
+    ASMAtomicXchgBool(&pDisk->fLocked, false);
+
+    /*
+     * Need to check for new I/O tasks and waiting I/O contexts now
+     * again as other threads might added them while we processed
+     * previous lists.
+     */
+    while (   ASMAtomicUoReadPtrT(&pDisk->pIoCtxHead, PVDIOCTX) != NULL
+           || ASMAtomicUoReadPtrT(&pDisk->pIoTasksPendingHead, PVDIOTASK) != NULL
+           || ASMAtomicUoReadPtrT(&pDisk->pIoCtxHaltedHead, PVDIOCTX) != NULL)
+    {
+        /* Try lock disk again. */
+        if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
+        {
+            vdIoTaskProcessWaitingList(pDisk);
+            vdIoCtxProcessHaltedList(pDisk);
+            vdDiskProcessWaitingIoCtx(pDisk, NULL);
+            ASMAtomicXchgBool(&pDisk->fLocked, false);
+        }
+        else /* Let the other thread everything when he unlocks the disk. */
+            break;
+    }
+
+    return rc;
+}
+
+/**
+ * Try to lock the disk to complete pressing of the I/O task.
+ * The completion is deferred if the disk is locked already.
+ *
+ * @param   pIoTask  The I/O task to complete.
+ */
+static void vdXferTryLockDiskDeferIoTask(PVDIOTASK pIoTask)
+{
+    PVDIOSTORAGE pIoStorage = pIoTask->pIoStorage;
+    PVDISK pDisk = pIoStorage->pVDIo->pDisk;
+
+    Log(("Deferring I/O task pIoTask=%p\n", pIoTask));
+
+    /* Put it on the waiting list. */
+    PVDIOTASK pNext = ASMAtomicUoReadPtrT(&pDisk->pIoTasksPendingHead, PVDIOTASK);
+    PVDIOTASK pHeadOld;
+    pIoTask->pNext = pNext;
+    while (!ASMAtomicCmpXchgExPtr(&pDisk->pIoTasksPendingHead, pIoTask, pNext, &pHeadOld))
+    {
+        pNext = pHeadOld;
+        Assert(pNext != pIoTask);
+        pIoTask->pNext = pNext;
+        ASMNopPause();
+    }
+
+    if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
+    {
+        /* Release disk lock, it will take care of processing all lists. */
+        vdDiskUnlock(pDisk, NULL);
+    }
+}
+
+static DECLCALLBACK(int) vdIOIntReqCompleted(void *pvUser, int rcReq)
+{
+    PVDIOTASK pIoTask = (PVDIOTASK)pvUser;
+
+    LogFlowFunc(("Task completed pIoTask=%#p\n", pIoTask));
+
+    pIoTask->rcReq = rcReq;
+    vdXferTryLockDiskDeferIoTask(pIoTask);
+    return VINF_SUCCESS;
+}
+
+/**
+ * VD I/O interface callback for opening a file.
+ */
+static DECLCALLBACK(int) vdIOIntOpen(void *pvUser, const char *pszLocation,
+                                     unsigned uOpenFlags, PPVDIOSTORAGE ppIoStorage)
+{
+    int rc = VINF_SUCCESS;
+    PVDIO pVDIo             = (PVDIO)pvUser;
+    PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
+
+    if (!pIoStorage)
+        return VERR_NO_MEMORY;
+
+    /* Create the AVl tree. */
+    pIoStorage->pTreeMetaXfers = (PAVLRFOFFTREE)RTMemAllocZ(sizeof(AVLRFOFFTREE));
+    if (pIoStorage->pTreeMetaXfers)
+    {
+        rc = pVDIo->pInterfaceIo->pfnOpen(pVDIo->pInterfaceIo->Core.pvUser,
+                                          pszLocation, uOpenFlags,
+                                          vdIOIntReqCompleted,
+                                          &pIoStorage->pStorage);
+        if (RT_SUCCESS(rc))
+        {
+            pIoStorage->pVDIo = pVDIo;
+            *ppIoStorage = pIoStorage;
+            return VINF_SUCCESS;
+        }
+
+        RTMemFree(pIoStorage->pTreeMetaXfers);
+    }
+    else
+        rc = VERR_NO_MEMORY;
+
+    RTMemFree(pIoStorage);
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntTreeMetaXferDestroy(PAVLRFOFFNODECORE pNode, void *pvUser)
+{
+    RT_NOREF2(pNode, pvUser);
+    AssertMsgFailed(("Tree should be empty at this point!\n"));
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) vdIOIntClose(void *pvUser, PVDIOSTORAGE pIoStorage)
+{
+    int rc = VINF_SUCCESS;
+    PVDIO pVDIo = (PVDIO)pvUser;
+
+    /* We free everything here, even if closing the file failed for some reason. */
+    rc = pVDIo->pInterfaceIo->pfnClose(pVDIo->pInterfaceIo->Core.pvUser, pIoStorage->pStorage);
+    RTAvlrFileOffsetDestroy(pIoStorage->pTreeMetaXfers, vdIOIntTreeMetaXferDestroy, NULL);
+    RTMemFree(pIoStorage->pTreeMetaXfers);
+    RTMemFree(pIoStorage);
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntDelete(void *pvUser, const char *pcszFilename)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnDelete(pVDIo->pInterfaceIo->Core.pvUser,
+                                          pcszFilename);
+}
+
+static DECLCALLBACK(int) vdIOIntMove(void *pvUser, const char *pcszSrc, const char *pcszDst,
+                                     unsigned fMove)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnMove(pVDIo->pInterfaceIo->Core.pvUser,
+                                        pcszSrc, pcszDst, fMove);
+}
+
+static DECLCALLBACK(int) vdIOIntGetFreeSpace(void *pvUser, const char *pcszFilename,
+                                             int64_t *pcbFreeSpace)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnGetFreeSpace(pVDIo->pInterfaceIo->Core.pvUser,
+                                                pcszFilename, pcbFreeSpace);
+}
+
+static DECLCALLBACK(int) vdIOIntGetModificationTime(void *pvUser, const char *pcszFilename,
+                                                    PRTTIMESPEC pModificationTime)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnGetModificationTime(pVDIo->pInterfaceIo->Core.pvUser,
+                                                       pcszFilename, pModificationTime);
+}
+
+static DECLCALLBACK(int) vdIOIntGetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
+                                        uint64_t *pcbSize)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnGetSize(pVDIo->pInterfaceIo->Core.pvUser,
+                                           pIoStorage->pStorage, pcbSize);
+}
+
+static DECLCALLBACK(int) vdIOIntSetSize(void *pvUser, PVDIOSTORAGE pIoStorage,
+                                        uint64_t cbSize)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    return pVDIo->pInterfaceIo->pfnSetSize(pVDIo->pInterfaceIo->Core.pvUser,
+                                           pIoStorage->pStorage, cbSize);
+}
+
+static DECLCALLBACK(int) vdIOIntSetAllocationSize(void *pvUser, PVDIOSTORAGE pIoStorage,
+                                                  uint64_t cbSize, uint32_t fFlags,
+                                                  PVDINTERFACEPROGRESS pIfProgress,
+                                                  unsigned uPercentStart, unsigned uPercentSpan)
+{
+    PVDIO pVDIo = (PVDIO)pvUser;
+    int rc = pVDIo->pInterfaceIo->pfnSetAllocationSize(pVDIo->pInterfaceIo->Core.pvUser,
+                                                       pIoStorage->pStorage, cbSize, fFlags);
+    if (rc == VERR_NOT_SUPPORTED)
+    {
+        /* Fallback if the underlying medium does not support optimized storage allocation. */
+        uint64_t cbSizeCur = 0;
+        rc = pVDIo->pInterfaceIo->pfnGetSize(pVDIo->pInterfaceIo->Core.pvUser,
+                                             pIoStorage->pStorage, &cbSizeCur);
+        if (RT_SUCCESS(rc))
+        {
+            if (cbSizeCur < cbSize)
+            {
+                const size_t cbBuf = 128 * _1K;
+                void *pvBuf = RTMemTmpAllocZ(cbBuf);
+                if (RT_LIKELY(pvBuf))
+                {
+                    uint64_t cbFill = cbSize - cbSizeCur;
+                    uint64_t uOff = 0;
+
+                    /* Write data to all blocks. */
+                    while (   uOff < cbFill
+                           && RT_SUCCESS(rc))
+                    {
+                        size_t cbChunk = (size_t)RT_MIN(cbFill - uOff, cbBuf);
+
+                        rc = pVDIo->pInterfaceIo->pfnWriteSync(pVDIo->pInterfaceIo->Core.pvUser,
+                                                               pIoStorage->pStorage, cbSizeCur + uOff,
+                                                               pvBuf, cbChunk, NULL);
+                        if (RT_SUCCESS(rc))
+                        {
+                            uOff += cbChunk;
+
+                            rc = vdIfProgress(pIfProgress, uPercentStart + uOff * uPercentSpan / cbFill);
+                        }
+                    }
+
+                    RTMemTmpFree(pvBuf);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+            else if (cbSizeCur > cbSize)
+                rc = pVDIo->pInterfaceIo->pfnSetSize(pVDIo->pInterfaceIo->Core.pvUser,
+                                                     pIoStorage->pStorage, cbSize);
+        }
+    }
+
+    if (RT_SUCCESS(rc))
+        rc = vdIfProgress(pIfProgress, uPercentStart + uPercentSpan);
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntReadUser(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                                         PVDIOCTX pIoCtx, size_t cbRead)
+{
+    int rc = VINF_SUCCESS;
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbRead=%u\n",
+                 pvUser, pIoStorage, uOffset, pIoCtx, cbRead));
+
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    Assert(cbRead > 0);
+
+    if (   (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
+        || !pVDIo->pInterfaceIo->pfnReadAsync)
+    {
+        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);
+        if (RT_SUCCESS(rc))
+        {
+            Assert(cbRead == (uint32_t)cbRead);
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbRead);
+        }
+    }
+    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 = 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));
+#endif
+
+            Assert(cbTaskRead == (uint32_t)cbTaskRead);
+            PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, NULL, NULL, pIoCtx, (uint32_t)cbTaskRead);
+
+            if (!pIoTask)
+                return VERR_NO_MEMORY;
+
+            ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+
+            void *pvTask;
+            Log(("Spawning pIoTask=%p pIoCtx=%p\n", pIoTask, pIoCtx));
+            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, (uint32_t)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;
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntWriteUser(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                                          PVDIOCTX pIoCtx, size_t cbWrite, PFNVDXFERCOMPLETED pfnComplete,
+                                          void *pvCompleteUser)
+{
+    int rc = VINF_SUCCESS;
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pIoCtx=%#p cbWrite=%u\n",
+                 pvUser, pIoStorage, uOffset, pIoCtx, cbWrite));
+
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    Assert(cbWrite > 0);
+
+    if (   (pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC)
+        || !pVDIo->pInterfaceIo->pfnWriteAsync)
+    {
+        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);
+        if (RT_SUCCESS(rc))
+        {
+            Assert(pIoCtx->Req.Io.cbTransferLeft >= cbWrite);
+            ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbWrite);
+        }
+    }
+    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));
+#endif
+
+            Assert(cbTaskWrite == (uint32_t)cbTaskWrite);
+            PVDIOTASK pIoTask = vdIoTaskUserAlloc(pIoStorage, pfnComplete, pvCompleteUser, pIoCtx, (uint32_t)cbTaskWrite);
+
+            if (!pIoTask)
+                return VERR_NO_MEMORY;
+
+            ASMAtomicIncU32(&pIoCtx->cDataTransfersPending);
+
+            void *pvTask;
+            Log(("Spawning pIoTask=%p pIoCtx=%p\n", pIoTask, pIoCtx));
+            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, (uint32_t)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;
+}
+
+static DECLCALLBACK(int) vdIOIntReadMeta(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                                         void *pvBuf, size_t cbRead, PVDIOCTX pIoCtx,
+                                         PPVDMETAXFER ppMetaXfer, PFNVDXFERCOMPLETED pfnComplete,
+                                         void *pvCompleteUser)
+{
+    PVDIO pVDIo     = (PVDIO)pvUser;
+    PVDISK pDisk  = pVDIo->pDisk;
+    int rc = VINF_SUCCESS;
+    RTSGSEG Seg;
+    PVDIOTASK pIoTask;
+    PVDMETAXFER pMetaXfer = NULL;
+    void *pvTask = NULL;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pvBuf=%#p cbRead=%u\n",
+                 pvUser, pIoStorage, uOffset, pvBuf, cbRead));
+
+    AssertMsgReturn(   pIoCtx
+                    || (!ppMetaXfer && !pfnComplete && !pvCompleteUser),
+                    ("A synchronous metadata read is requested but the parameters are wrong\n"),
+                    VERR_INVALID_POINTER);
+
+    /** @todo Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC
+        || !pVDIo->pInterfaceIo->pfnReadAsync)
+    {
+        /* Handle synchronous metadata I/O. */
+        /** @todo Integrate with metadata transfers below. */
+        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"));
+#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); NOREF(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(RT_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);
+                if (pMetaXfer->pbDataShw)
+                    memcpy(pvBuf, pMetaXfer->pbDataShw, cbRead);
+                else
+                    memcpy(pvBuf, pMetaXfer->abData, cbRead);
+                *ppMetaXfer = pMetaXfer;
+            }
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntWriteMeta(void *pvUser, PVDIOSTORAGE pIoStorage, uint64_t uOffset,
+                                          const void *pvBuf, size_t cbWrite, PVDIOCTX pIoCtx,
+                                          PFNVDXFERCOMPLETED pfnComplete, void *pvCompleteUser)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    int rc = VINF_SUCCESS;
+    RTSGSEG Seg;
+    PVDIOTASK pIoTask;
+    PVDMETAXFER pMetaXfer = NULL;
+    bool fInTree = false;
+    void *pvTask = NULL;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p uOffset=%llu pvBuf=%#p cbWrite=%u\n",
+                 pvUser, pIoStorage, uOffset, pvBuf, cbWrite));
+
+    AssertMsgReturn(   pIoCtx
+                    || (!pfnComplete && !pvCompleteUser),
+                    ("A synchronous metadata write is requested but the parameters are wrong\n"),
+                    VERR_INVALID_POINTER);
+
+    /** @todo Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC
+        || !pVDIo->pInterfaceIo->pfnWriteAsync)
+    {
+        /* Handle synchronous metadata I/O. */
+        /** @todo Integrate with metadata transfers below. */
+        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;
+        }
+
+        if (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")); NOREF(fRemoved);
+                    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); NOREF(fInserted);
+                }
+
+                RTListAppend(&pMetaXfer->ListIoCtxWaiting, &pDeferred->NodeDeferred);
+            }
+            else
+            {
+                RTMemFree(pMetaXfer);
+                pMetaXfer = NULL;
+            }
+        }
+        else
+        {
+            /* I/O is in progress, update shadow buffer and add to waiting list. */
+            Assert(VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
+            if (!pMetaXfer->pbDataShw)
+            {
+                /* Allocate shadow buffer and set initial state. */
+                LogFlowFunc(("pMetaXfer=%#p Creating shadow buffer\n", pMetaXfer));
+                pMetaXfer->pbDataShw = (uint8_t *)RTMemAlloc(pMetaXfer->cbMeta);
+                if (RT_LIKELY(pMetaXfer->pbDataShw))
+                    memcpy(pMetaXfer->pbDataShw, pMetaXfer->abData, pMetaXfer->cbMeta);
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+
+            if (RT_SUCCESS(rc))
+            {
+                /* Update with written data and append to waiting list. */
+                PVDIOCTXDEFERRED pDeferred = (PVDIOCTXDEFERRED)RTMemAllocZ(sizeof(VDIOCTXDEFERRED));
+                if (pDeferred)
+                {
+                    LogFlowFunc(("pMetaXfer=%#p Updating shadow buffer\n", pMetaXfer));
+
+                    RTListInit(&pDeferred->NodeDeferred);
+                    pDeferred->pIoCtx = pIoCtx;
+                    ASMAtomicIncU32(&pIoCtx->cMetaTransfersPending);
+                    memcpy(pMetaXfer->pbDataShw, pvBuf, cbWrite);
+                    RTListAppend(&pMetaXfer->ListIoCtxShwWrites, &pDeferred->NodeDeferred);
+                }
+                else
+                {
+                    /*
+                     * Free shadow buffer if there is no one depending on it, i.e.
+                     * we just allocated it.
+                     */
+                    if (RTListIsEmpty(&pMetaXfer->ListIoCtxShwWrites))
+                    {
+                        RTMemFree(pMetaXfer->pbDataShw);
+                        pMetaXfer->pbDataShw = NULL;
+                    }
+                    rc = VERR_NO_MEMORY;
+                }
+            }
+        }
+    }
+
+    LogFlowFunc(("returns rc=%Rrc\n", rc));
+    return rc;
+}
+
+static DECLCALLBACK(void) vdIOIntMetaXferRelease(void *pvUser, PVDMETAXFER pMetaXfer)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    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_IS_LOCKED(pDisk);
+
+    Assert(   VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE
+           || VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_WRITE);
+    Assert(pMetaXfer->cRefs > 0);
+
+    pMetaXfer->cRefs--;
+    if (   !pMetaXfer->cRefs
+        && RTListIsEmpty(&pMetaXfer->ListIoCtxWaiting)
+        && VDMETAXFER_TXDIR_GET(pMetaXfer->fFlags) == VDMETAXFER_TXDIR_NONE)
+    {
+        /* Free the meta data entry. */
+        LogFlow(("Removing meta xfer=%#p\n", pMetaXfer));
+        bool fRemoved = RTAvlrFileOffsetRemove(pIoStorage->pTreeMetaXfers, pMetaXfer->Core.Key) != NULL;
+        AssertMsg(fRemoved, ("Metadata transfer wasn't removed\n")); NOREF(fRemoved);
+
+        RTMemFree(pMetaXfer);
+    }
+}
+
+static DECLCALLBACK(int) vdIOIntFlush(void *pvUser, PVDIOSTORAGE pIoStorage, PVDIOCTX pIoCtx,
+                                      PFNVDXFERCOMPLETED pfnComplete, void *pvCompleteUser)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    int rc = VINF_SUCCESS;
+    PVDIOTASK pIoTask;
+    PVDMETAXFER pMetaXfer = NULL;
+    void *pvTask = NULL;
+
+    LogFlowFunc(("pvUser=%#p pIoStorage=%#p pIoCtx=%#p\n",
+                 pvUser, pIoStorage, pIoCtx));
+
+    AssertMsgReturn(   pIoCtx
+                    || (!pfnComplete && !pvCompleteUser),
+                    ("A synchronous metadata write is requested but the parameters are wrong\n"),
+                    VERR_INVALID_POINTER);
+
+    /** @todo Enable check for sync I/O later. */
+    if (   pIoCtx
+        && !(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    if (pVDIo->fIgnoreFlush)
+        return VINF_SUCCESS;
+
+    if (   !pIoCtx
+        || pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC
+        || !pVDIo->pInterfaceIo->pfnFlushAsync)
+    {
+        /* Handle synchronous flushes. */
+        /** @todo Integrate with metadata transfers below. */
+        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;
+}
+
+static DECLCALLBACK(size_t) vdIOIntIoCtxCopyTo(void *pvUser, PVDIOCTX pIoCtx,
+                                               const void *pvBuf, size_t cbBuf)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    size_t cbCopied = 0;
+
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    cbCopied = vdIoCtxCopyTo(pIoCtx, (uint8_t *)pvBuf, cbBuf);
+    Assert(cbCopied == cbBuf);
+
+    /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft >= cbCopied); - triggers with vdCopyHelper/dmgRead.
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCopied);
+
+    return cbCopied;
+}
+
+static DECLCALLBACK(size_t) vdIOIntIoCtxCopyFrom(void *pvUser, PVDIOCTX pIoCtx,
+                                                 void *pvBuf, size_t cbBuf)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    size_t cbCopied = 0;
+
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    cbCopied = vdIoCtxCopyFrom(pIoCtx, (uint8_t *)pvBuf, cbBuf);
+    Assert(cbCopied == cbBuf);
+
+    /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft > cbCopied); - triggers with vdCopyHelper/dmgRead.
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCopied);
+
+    return cbCopied;
+}
+
+static DECLCALLBACK(size_t) vdIOIntIoCtxSet(void *pvUser, PVDIOCTX pIoCtx, int ch, size_t cb)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    size_t cbSet = 0;
+
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+
+    cbSet = vdIoCtxSet(pIoCtx, ch, cb);
+    Assert(cbSet == cb);
+
+    /// @todo Assert(pIoCtx->Req.Io.cbTransferLeft >= cbSet); - triggers with vdCopyHelper/dmgRead.
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbSet);
+
+    return cbSet;
+}
+
+static DECLCALLBACK(size_t) vdIOIntIoCtxSegArrayCreate(void *pvUser, PVDIOCTX pIoCtx,
+                                                       PRTSGSEG paSeg, unsigned *pcSeg,
+                                                       size_t cbData)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    size_t cbCreated = 0;
+
+    /** @todo It is possible that this gets called from a filter plugin
+     * outside of the disk lock. Refine assertion or remove completely. */
+#if 0
+    /** @todo Enable check for sync I/O later. */
+    if (!(pIoCtx->fFlags & VDIOCTX_FLAGS_SYNC))
+        VD_IS_LOCKED(pDisk);
+#else
+    NOREF(pDisk);
+#endif
+
+    cbCreated = RTSgBufSegArrayCreate(&pIoCtx->Req.Io.SgBuf, paSeg, pcSeg, cbData);
+    Assert(!paSeg || cbData == cbCreated);
+
+    return cbCreated;
+}
+
+static DECLCALLBACK(void) vdIOIntIoCtxCompleted(void *pvUser, PVDIOCTX pIoCtx, int rcReq,
+                                                size_t cbCompleted)
+{
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+
+    LogFlowFunc(("pvUser=%#p pIoCtx=%#p rcReq=%Rrc cbCompleted=%zu\n",
+                 pvUser, pIoCtx, rcReq, cbCompleted));
+
+    /*
+     * Grab the disk critical section to avoid races with other threads which
+     * might still modify the I/O context.
+     * 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 blocked state yet.
+     * It can overwrite the state to true before we call vdIoCtxContinue and the
+     * the request would hang indefinite.
+     */
+    ASMAtomicCmpXchgS32(&pIoCtx->rcReq, rcReq, VINF_SUCCESS);
+    Assert(pIoCtx->Req.Io.cbTransferLeft >= cbCompleted);
+    ASMAtomicSubU32(&pIoCtx->Req.Io.cbTransferLeft, (uint32_t)cbCompleted);
+
+    /* Set next transfer function if the current one finished.
+     * @todo: Find a better way to prevent vdIoCtxContinue from calling the current helper again. */
+    if (!pIoCtx->Req.Io.cbTransferLeft)
+    {
+        pIoCtx->pfnIoCtxTransfer = pIoCtx->pfnIoCtxTransferNext;
+        pIoCtx->pfnIoCtxTransferNext = NULL;
+    }
+
+    vdIoCtxAddToWaitingList(&pDisk->pIoCtxHaltedHead, pIoCtx);
+    if (ASMAtomicCmpXchgBool(&pDisk->fLocked, true, false))
+    {
+        /* Immediately drop the lock again, it will take care of processing the list. */
+        vdDiskUnlock(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;
+}
+
+static DECLCALLBACK(size_t) vdIOIntIoCtxGetDataUnitSize(void *pvUser, PVDIOCTX pIoCtx)
+{
+    RT_NOREF1(pIoCtx);
+    PVDIO    pVDIo = (PVDIO)pvUser;
+    PVDISK pDisk = pVDIo->pDisk;
+    size_t cbSector = 0;
+
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, VD_LAST_IMAGE);
+    AssertPtrReturn(pImage, 0);
+
+    PCVDREGIONLIST pRegionList = NULL;
+    int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
+    if (RT_SUCCESS(rc))
+    {
+        cbSector = pRegionList->aRegions[0].cbBlock;
+
+        AssertPtr(pImage->Backend->pfnRegionListRelease);
+        pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
+    }
+
+    return cbSector;
+}
+
+/**
+ * VD I/O interface callback for opening a file (limited version for VDGetFormat).
+ */
+static DECLCALLBACK(int) vdIOIntOpenLimited(void *pvUser, const char *pszLocation,
+                                            uint32_t fOpen, PPVDIOSTORAGE ppIoStorage)
+{
+    int rc = VINF_SUCCESS;
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    PVDIOSTORAGE pIoStorage = (PVDIOSTORAGE)RTMemAllocZ(sizeof(VDIOSTORAGE));
+
+    if (!pIoStorage)
+        return VERR_NO_MEMORY;
+
+    rc = pInterfaceIo->pfnOpen(NULL, pszLocation, fOpen, NULL, &pIoStorage->pStorage);
+    if (RT_SUCCESS(rc))
+        *ppIoStorage = pIoStorage;
+    else
+        RTMemFree(pIoStorage);
+
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntCloseLimited(void *pvUser, PVDIOSTORAGE pIoStorage)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    int rc = pInterfaceIo->pfnClose(NULL, pIoStorage->pStorage);
+
+    RTMemFree(pIoStorage);
+    return rc;
+}
+
+static DECLCALLBACK(int) vdIOIntDeleteLimited(void *pvUser, const char *pcszFilename)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnDelete(NULL, pcszFilename);
+}
+
+static DECLCALLBACK(int) vdIOIntMoveLimited(void *pvUser, const char *pcszSrc,
+                                            const char *pcszDst, unsigned fMove)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnMove(NULL, pcszSrc, pcszDst, fMove);
+}
+
+static DECLCALLBACK(int) vdIOIntGetFreeSpaceLimited(void *pvUser, const char *pcszFilename,
+                                                    int64_t *pcbFreeSpace)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnGetFreeSpace(NULL, pcszFilename, pcbFreeSpace);
+}
+
+static DECLCALLBACK(int) vdIOIntGetModificationTimeLimited(void *pvUser,
+                                                           const char *pcszFilename,
+                                                           PRTTIMESPEC pModificationTime)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnGetModificationTime(NULL, pcszFilename, pModificationTime);
+}
+
+static DECLCALLBACK(int) vdIOIntGetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
+                                               uint64_t *pcbSize)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnGetSize(NULL, pIoStorage->pStorage, pcbSize);
+}
+
+static DECLCALLBACK(int) vdIOIntSetSizeLimited(void *pvUser, PVDIOSTORAGE pIoStorage,
+                                               uint64_t cbSize)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+    return pInterfaceIo->pfnSetSize(NULL, pIoStorage->pStorage, cbSize);
+}
+
+static DECLCALLBACK(int) vdIOIntWriteUserLimited(void *pvUser, PVDIOSTORAGE pStorage,
+                                                 uint64_t uOffset, PVDIOCTX pIoCtx,
+                                                 size_t cbWrite,
+                                                 PFNVDXFERCOMPLETED pfnComplete,
+                                                 void *pvCompleteUser)
+{
+    NOREF(pvUser);
+    NOREF(pStorage);
+    NOREF(uOffset);
+    NOREF(pIoCtx);
+    NOREF(cbWrite);
+    NOREF(pfnComplete);
+    NOREF(pvCompleteUser);
+    AssertMsgFailedReturn(("This needs to be implemented when called\n"), VERR_NOT_IMPLEMENTED);
+}
+
+static DECLCALLBACK(int) vdIOIntReadUserLimited(void *pvUser, PVDIOSTORAGE pStorage,
+                                                uint64_t uOffset, PVDIOCTX pIoCtx,
+                                                size_t cbRead)
+{
+    NOREF(pvUser);
+    NOREF(pStorage);
+    NOREF(uOffset);
+    NOREF(pIoCtx);
+    NOREF(cbRead);
+    AssertMsgFailedReturn(("This needs to be implemented when called\n"), VERR_NOT_IMPLEMENTED);
+}
+
+static DECLCALLBACK(int) vdIOIntWriteMetaLimited(void *pvUser, PVDIOSTORAGE pStorage,
+                                                 uint64_t uOffset, const void *pvBuffer,
+                                                 size_t cbBuffer, PVDIOCTX pIoCtx,
+                                                 PFNVDXFERCOMPLETED pfnComplete,
+                                                 void *pvCompleteUser)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+
+    AssertMsgReturn(!pIoCtx && !pfnComplete && !pvCompleteUser,
+                    ("Async I/O not implemented for the limited interface"),
+                    VERR_NOT_SUPPORTED);
+
+    return pInterfaceIo->pfnWriteSync(NULL, pStorage->pStorage, uOffset, pvBuffer, cbBuffer, NULL);
+}
+
+static DECLCALLBACK(int) vdIOIntReadMetaLimited(void *pvUser, PVDIOSTORAGE pStorage,
+                                                uint64_t uOffset, void *pvBuffer,
+                                                size_t cbBuffer, PVDIOCTX pIoCtx,
+                                                PPVDMETAXFER ppMetaXfer,
+                                                PFNVDXFERCOMPLETED pfnComplete,
+                                                void *pvCompleteUser)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+
+    AssertMsgReturn(!pIoCtx && !ppMetaXfer && !pfnComplete && !pvCompleteUser,
+                    ("Async I/O not implemented for the limited interface"),
+                    VERR_NOT_SUPPORTED);
+
+    return pInterfaceIo->pfnReadSync(NULL, pStorage->pStorage, uOffset, pvBuffer, cbBuffer, NULL);
+}
+
+#if 0 /* unsed */
+static int vdIOIntMetaXferReleaseLimited(void *pvUser, PVDMETAXFER pMetaXfer)
+{
+    /* This is a NOP in this case. */
+    NOREF(pvUser);
+    NOREF(pMetaXfer);
+    return VINF_SUCCESS;
+}
+#endif
+
+static DECLCALLBACK(int) vdIOIntFlushLimited(void *pvUser, PVDIOSTORAGE pStorage,
+                                             PVDIOCTX pIoCtx,
+                                             PFNVDXFERCOMPLETED pfnComplete,
+                                             void *pvCompleteUser)
+{
+    PVDINTERFACEIO pInterfaceIo = (PVDINTERFACEIO)pvUser;
+
+    AssertMsgReturn(!pIoCtx && !pfnComplete && !pvCompleteUser,
+                    ("Async I/O not implemented for the limited interface"),
+                    VERR_NOT_SUPPORTED);
+
+    return pInterfaceIo->pfnFlushSync(NULL, pStorage->pStorage);
+}
+
+/**
+ * internal: send output to the log (unconditionally).
+ */
+static DECLCALLBACK(int) vdLogMessage(void *pvUser, const char *pszFormat, va_list args)
+{
+    NOREF(pvUser);
+    RTLogPrintfV(pszFormat, args);
+    return VINF_SUCCESS;
+}
+
+DECLINLINE(int) vdMessageWrapper(PVDISK pDisk, const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    int rc = pDisk->pInterfaceError->pfnMessage(pDisk->pInterfaceError->Core.pvUser,
+                                                pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+
+/**
+ * internal: adjust PCHS geometry
+ */
+static void vdFixupPCHSGeometry(PVDGEOMETRY pPCHS, uint64_t cbSize)
+{
+    /* Fix broken PCHS geometry. Can happen for two reasons: either the backend
+     * mixes up PCHS and LCHS, or the application used to create the source
+     * image has put garbage in it. Additionally, if the PCHS geometry covers
+     * more than the image size, set it back to the default. */
+    if (   pPCHS->cHeads > 16
+        || pPCHS->cSectors > 63
+        || pPCHS->cCylinders == 0
+        || (uint64_t)pPCHS->cHeads * pPCHS->cSectors * pPCHS->cCylinders * 512 > cbSize)
+    {
+        Assert(!(RT_MIN(cbSize / 512 / 16 / 63, 16383) - (uint32_t)RT_MIN(cbSize / 512 / 16 / 63, 16383)));
+        pPCHS->cCylinders = (uint32_t)RT_MIN(cbSize / 512 / 16 / 63, 16383);
+        pPCHS->cHeads = 16;
+        pPCHS->cSectors = 63;
+    }
+}
+
+/**
+ * internal: adjust LCHS geometry
+ */
+static void vdFixupLCHSGeometry(PVDGEOMETRY pLCHS, uint64_t cbSize)
+{
+    /* Fix broken LCHS geometry. Can happen for two reasons: either the backend
+     * mixes up PCHS and LCHS, or the application used to create the source
+     * image has put garbage in it. The fix in this case is to clear the LCHS
+     * geometry to trigger autodetection when it is used next. If the geometry
+     * already says "please autodetect" (cylinders=0) keep it. */
+    if (   (   pLCHS->cHeads > 255
+            || pLCHS->cHeads == 0
+            || pLCHS->cSectors > 63
+            || pLCHS->cSectors == 0)
+        && pLCHS->cCylinders != 0)
+    {
+        pLCHS->cCylinders = 0;
+        pLCHS->cHeads = 0;
+        pLCHS->cSectors = 0;
+    }
+    /* Always recompute the number of cylinders stored in the LCHS
+     * geometry if it isn't set to "autotedetect" at the moment.
+     * This is very useful if the destination image size is
+     * larger or smaller than the source image size. Do not modify
+     * the number of heads and sectors. Windows guests hate it. */
+    if (   pLCHS->cCylinders != 0
+        && pLCHS->cHeads != 0 /* paranoia */
+        && pLCHS->cSectors != 0 /* paranoia */)
+    {
+        Assert(!(RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024) - (uint32_t)RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024)));
+        pLCHS->cCylinders = (uint32_t)RT_MIN(cbSize / 512 / pLCHS->cHeads / pLCHS->cSectors, 1024);
+    }
+}
+
+/**
+ * Sets the I/O callbacks of the given interface to the fallback methods
+ *
+ * @param   pIfIo    The I/O interface to setup.
+ */
+static void vdIfIoFallbackCallbacksSetup(PVDINTERFACEIO pIfIo)
+{
+    pIfIo->pfnOpen                = vdIOOpenFallback;
+    pIfIo->pfnClose               = vdIOCloseFallback;
+    pIfIo->pfnDelete              = vdIODeleteFallback;
+    pIfIo->pfnMove                = vdIOMoveFallback;
+    pIfIo->pfnGetFreeSpace        = vdIOGetFreeSpaceFallback;
+    pIfIo->pfnGetModificationTime = vdIOGetModificationTimeFallback;
+    pIfIo->pfnGetSize             = vdIOGetSizeFallback;
+    pIfIo->pfnSetSize             = vdIOSetSizeFallback;
+    pIfIo->pfnSetAllocationSize   = vdIOSetAllocationSizeFallback;
+    pIfIo->pfnReadSync            = vdIOReadSyncFallback;
+    pIfIo->pfnWriteSync           = vdIOWriteSyncFallback;
+    pIfIo->pfnFlushSync           = vdIOFlushSyncFallback;
+    pIfIo->pfnReadAsync           = NULL;
+    pIfIo->pfnWriteAsync          = NULL;
+    pIfIo->pfnFlushAsync          = NULL;
+}
+
+/**
+ * Sets the internal I/O callbacks of the given interface.
+ *
+ * @param   pIfIoInt    The internal I/O interface to setup.
+ */
+static void vdIfIoIntCallbacksSetup(PVDINTERFACEIOINT pIfIoInt)
+{
+    pIfIoInt->pfnOpen                 = vdIOIntOpen;
+    pIfIoInt->pfnClose                = vdIOIntClose;
+    pIfIoInt->pfnDelete               = vdIOIntDelete;
+    pIfIoInt->pfnMove                 = vdIOIntMove;
+    pIfIoInt->pfnGetFreeSpace         = vdIOIntGetFreeSpace;
+    pIfIoInt->pfnGetModificationTime  = vdIOIntGetModificationTime;
+    pIfIoInt->pfnGetSize              = vdIOIntGetSize;
+    pIfIoInt->pfnSetSize              = vdIOIntSetSize;
+    pIfIoInt->pfnSetAllocationSize    = vdIOIntSetAllocationSize;
+    pIfIoInt->pfnReadUser             = vdIOIntReadUser;
+    pIfIoInt->pfnWriteUser            = vdIOIntWriteUser;
+    pIfIoInt->pfnReadMeta             = vdIOIntReadMeta;
+    pIfIoInt->pfnWriteMeta            = vdIOIntWriteMeta;
+    pIfIoInt->pfnMetaXferRelease      = vdIOIntMetaXferRelease;
+    pIfIoInt->pfnFlush                = vdIOIntFlush;
+    pIfIoInt->pfnIoCtxCopyFrom        = vdIOIntIoCtxCopyFrom;
+    pIfIoInt->pfnIoCtxCopyTo          = vdIOIntIoCtxCopyTo;
+    pIfIoInt->pfnIoCtxSet             = vdIOIntIoCtxSet;
+    pIfIoInt->pfnIoCtxSegArrayCreate  = vdIOIntIoCtxSegArrayCreate;
+    pIfIoInt->pfnIoCtxCompleted       = vdIOIntIoCtxCompleted;
+    pIfIoInt->pfnIoCtxIsSynchronous   = vdIOIntIoCtxIsSynchronous;
+    pIfIoInt->pfnIoCtxIsZero          = vdIOIntIoCtxIsZero;
+    pIfIoInt->pfnIoCtxGetDataUnitSize = vdIOIntIoCtxGetDataUnitSize;
+}
+
+/**
+ * Internally used completion handler for synchronous I/O contexts.
+ */
+static DECLCALLBACK(void) vdIoCtxSyncComplete(void *pvUser1, void *pvUser2, int rcReq)
+{
+    RT_NOREF2(pvUser1, rcReq);
+    RTSEMEVENT hEvent = (RTSEMEVENT)pvUser2;
+
+    RTSemEventSignal(hEvent);
+}
+
+
+VBOXDDU_DECL(int) VDInit(void)
+{
+    int rc = vdPluginInit();
+    LogRel(("VD: VDInit finished with %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDShutdown(void)
+{
+    return vdPluginTerm();
+}
+
+
+VBOXDDU_DECL(int) VDPluginLoadFromFilename(const char *pszFilename)
+{
+    if (!vdPluginIsInitialized())
+    {
+        int rc = VDInit();
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return vdPluginLoadFromFilename(pszFilename);
+}
+
+/**
+ * Load all plugins from a given path.
+ *
+ * @returns VBox statuse code.
+ * @param   pszPath         The path to load plugins from.
+ */
+VBOXDDU_DECL(int) VDPluginLoadFromPath(const char *pszPath)
+{
+    if (!vdPluginIsInitialized())
+    {
+        int rc = VDInit();
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return vdPluginLoadFromPath(pszPath);
+}
+
+
+VBOXDDU_DECL(int) VDPluginUnloadFromFilename(const char *pszFilename)
+{
+    if (!vdPluginIsInitialized())
+    {
+        int rc = VDInit();
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return vdPluginUnloadFromFilename(pszFilename);
+}
+
+
+VBOXDDU_DECL(int) VDPluginUnloadFromPath(const char *pszPath)
+{
+    if (!vdPluginIsInitialized())
+    {
+        int rc = VDInit();
+        if (RT_FAILURE(rc))
+            return rc;
+    }
+
+    return vdPluginUnloadFromPath(pszPath);
+}
+
+
+VBOXDDU_DECL(int) VDBackendInfo(unsigned cEntriesAlloc, PVDBACKENDINFO pEntries,
+                                unsigned *pcEntriesUsed)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
+    /* Check arguments. */
+    AssertMsgReturn(cEntriesAlloc, ("cEntriesAlloc=%u\n", cEntriesAlloc), VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pEntries, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcEntriesUsed, VERR_INVALID_POINTER);
+    if (!vdPluginIsInitialized())
+        VDInit();
+
+    uint32_t cBackends = vdGetImageBackendCount();
+    if (cEntriesAlloc < cBackends)
+    {
+        *pcEntriesUsed = cBackends;
+        return VERR_BUFFER_OVERFLOW;
+    }
+
+    for (unsigned i = 0; i < cBackends; i++)
+    {
+        PCVDIMAGEBACKEND pBackend;
+        rc = vdQueryImageBackend(i, &pBackend);
+        AssertRC(rc);
+
+        pEntries[i].pszBackend         = pBackend->pszBackendName;
+        pEntries[i].uBackendCaps       = pBackend->uBackendCaps;
+        pEntries[i].paFileExtensions   = pBackend->paFileExtensions;
+        pEntries[i].paConfigInfo       = pBackend->paConfigInfo;
+        pEntries[i].pfnComposeLocation = pBackend->pfnComposeLocation;
+        pEntries[i].pfnComposeName     = pBackend->pfnComposeName;
+    }
+
+    LogFlowFunc(("returns %Rrc *pcEntriesUsed=%u\n", rc, cBackends));
+    *pcEntriesUsed = cBackends;
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDBackendInfoOne(const char *pszBackend, PVDBACKENDINFO pEntry)
+{
+    LogFlowFunc(("pszBackend=%#p pEntry=%#p\n", pszBackend, pEntry));
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
+    if (!vdPluginIsInitialized())
+        VDInit();
+
+    PCVDIMAGEBACKEND pBackend;
+    int rc = vdFindImageBackend(pszBackend, &pBackend);
+    if (RT_SUCCESS(rc))
+    {
+        pEntry->pszBackend       = pBackend->pszBackendName;
+        pEntry->uBackendCaps     = pBackend->uBackendCaps;
+        pEntry->paFileExtensions = pBackend->paFileExtensions;
+        pEntry->paConfigInfo     = pBackend->paConfigInfo;
+    }
+
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDFilterInfo(unsigned cEntriesAlloc, PVDFILTERINFO pEntries,
+                               unsigned *pcEntriesUsed)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
+    /* Check arguments. */
+    AssertMsgReturn(cEntriesAlloc,
+                    ("cEntriesAlloc=%u\n", cEntriesAlloc),
+                    VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pEntries, VERR_INVALID_POINTER);
+    AssertPtrReturn(pcEntriesUsed, VERR_INVALID_POINTER);
+    if (!vdPluginIsInitialized())
+        VDInit();
+
+    uint32_t cBackends = vdGetFilterBackendCount();
+    if (cEntriesAlloc < cBackends)
+    {
+        *pcEntriesUsed = cBackends;
+        return VERR_BUFFER_OVERFLOW;
+    }
+
+    for (unsigned i = 0; i < cBackends; i++)
+    {
+        PCVDFILTERBACKEND pBackend;
+        rc = vdQueryFilterBackend(i, &pBackend);
+        pEntries[i].pszFilter    = pBackend->pszBackendName;
+        pEntries[i].paConfigInfo = pBackend->paConfigInfo;
+    }
+
+    LogFlowFunc(("returns %Rrc *pcEntriesUsed=%u\n", rc, cBackends));
+    *pcEntriesUsed = cBackends;
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDFilterInfoOne(const char *pszFilter, PVDFILTERINFO pEntry)
+{
+    LogFlowFunc(("pszFilter=%#p pEntry=%#p\n", pszFilter, pEntry));
+    /* Check arguments. */
+    AssertPtrReturn(pszFilter, VERR_INVALID_POINTER);
+    AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
+    if (!vdPluginIsInitialized())
+        VDInit();
+
+    PCVDFILTERBACKEND pBackend;
+    int rc = vdFindFilterBackend(pszFilter, &pBackend);
+    if (RT_SUCCESS(rc))
+    {
+        pEntry->pszFilter    = pBackend->pszBackendName;
+        pEntry->paConfigInfo = pBackend->paConfigInfo;
+    }
+
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCreate(PVDINTERFACE pVDIfsDisk, VDTYPE enmType, PVDISK *ppDisk)
+{
+    int rc = VINF_SUCCESS;
+    PVDISK pDisk = NULL;
+
+    LogFlowFunc(("pVDIfsDisk=%#p\n", pVDIfsDisk));
+    /* Check arguments. */
+    AssertPtrReturn(ppDisk, VERR_INVALID_POINTER);
+
+    do
+    {
+        pDisk = (PVDISK)RTMemAllocZ(sizeof(VDISK));
+        if (pDisk)
+        {
+            pDisk->u32Signature            = VDISK_SIGNATURE;
+            pDisk->enmType                 = enmType;
+            pDisk->cImages                 = 0;
+            pDisk->pBase                   = NULL;
+            pDisk->pLast                   = NULL;
+            pDisk->cbSize                  = 0;
+            pDisk->PCHSGeometry.cCylinders = 0;
+            pDisk->PCHSGeometry.cHeads     = 0;
+            pDisk->PCHSGeometry.cSectors   = 0;
+            pDisk->LCHSGeometry.cCylinders = 0;
+            pDisk->LCHSGeometry.cHeads     = 0;
+            pDisk->LCHSGeometry.cSectors   = 0;
+            pDisk->pVDIfsDisk              = pVDIfsDisk;
+            pDisk->pInterfaceError         = NULL;
+            pDisk->pInterfaceThreadSync    = NULL;
+            pDisk->pIoCtxLockOwner         = NULL;
+            pDisk->pIoCtxHead              = NULL;
+            pDisk->fLocked                 = false;
+            pDisk->hMemCacheIoCtx          = NIL_RTMEMCACHE;
+            pDisk->hMemCacheIoTask         = NIL_RTMEMCACHE;
+            RTListInit(&pDisk->ListFilterChainWrite);
+            RTListInit(&pDisk->ListFilterChainRead);
+
+            /* Create the I/O ctx cache */
+            rc = RTMemCacheCreate(&pDisk->hMemCacheIoCtx, sizeof(VDIOCTX), 0, UINT32_MAX,
+                                  NULL, NULL, NULL, 0);
+            if (RT_FAILURE(rc))
+                break;
+
+            /* Create the I/O task cache */
+            rc = RTMemCacheCreate(&pDisk->hMemCacheIoTask, sizeof(VDIOTASK), 0, UINT32_MAX,
+                                  NULL, NULL, NULL, 0);
+            if (RT_FAILURE(rc))
+                break;
+
+            pDisk->pInterfaceError      = VDIfErrorGet(pVDIfsDisk);
+            pDisk->pInterfaceThreadSync = VDIfThreadSyncGet(pVDIfsDisk);
+
+            *ppDisk = pDisk;
+        }
+        else
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+    } while (0);
+
+    if (   RT_FAILURE(rc)
+        && pDisk)
+    {
+        if (pDisk->hMemCacheIoCtx != NIL_RTMEMCACHE)
+            RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+        if (pDisk->hMemCacheIoTask != NIL_RTMEMCACHE)
+            RTMemCacheDestroy(pDisk->hMemCacheIoTask);
+    }
+
+    LogFlowFunc(("returns %Rrc (pDisk=%#p)\n", rc, pDisk));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDDestroy(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    do
+    {
+        /* sanity check */
+        AssertPtrBreak(pDisk);
+        AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+        Assert(!pDisk->fLocked);
+
+        rc = VDCloseAll(pDisk);
+        int rc2 = VDFilterRemoveAll(pDisk);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+
+        RTMemCacheDestroy(pDisk->hMemCacheIoCtx);
+        RTMemCacheDestroy(pDisk->hMemCacheIoTask);
+        RTMemFree(pDisk);
+    } while (0);
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetFormat(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                              const char *pszFilename, VDTYPE enmDesiredType,
+                              char **ppszFormat, VDTYPE *penmType)
+{
+    int rc = VERR_NOT_SUPPORTED;
+    VDINTERFACEIOINT VDIfIoInt;
+    VDINTERFACEIO    VDIfIoFallback;
+    PVDINTERFACEIO   pInterfaceIo;
+
+    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
+    /* Check arguments. */
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(ppszFormat, VERR_INVALID_POINTER);
+    AssertPtrReturn(penmType, VERR_INVALID_POINTER);
+    AssertReturn(enmDesiredType >= VDTYPE_INVALID && enmDesiredType <= VDTYPE_FLOPPY, VERR_INVALID_PARAMETER);
+
+    if (!vdPluginIsInitialized())
+        VDInit();
+
+    pInterfaceIo = VDIfIoGet(pVDIfsImage);
+    if (!pInterfaceIo)
+    {
+        /*
+         * Caller doesn't provide an I/O interface, create our own using the
+         * native file API.
+         */
+        vdIfIoFallbackCallbacksSetup(&VDIfIoFallback);
+        pInterfaceIo = &VDIfIoFallback;
+    }
+
+    /* Set up the internal I/O interface. */
+    AssertReturn(!VDIfIoIntGet(pVDIfsImage), VERR_INVALID_PARAMETER);
+    VDIfIoInt.pfnOpen                   = vdIOIntOpenLimited;
+    VDIfIoInt.pfnClose                  = vdIOIntCloseLimited;
+    VDIfIoInt.pfnDelete                 = vdIOIntDeleteLimited;
+    VDIfIoInt.pfnMove                   = vdIOIntMoveLimited;
+    VDIfIoInt.pfnGetFreeSpace           = vdIOIntGetFreeSpaceLimited;
+    VDIfIoInt.pfnGetModificationTime    = vdIOIntGetModificationTimeLimited;
+    VDIfIoInt.pfnGetSize                = vdIOIntGetSizeLimited;
+    VDIfIoInt.pfnSetSize                = vdIOIntSetSizeLimited;
+    VDIfIoInt.pfnReadUser               = vdIOIntReadUserLimited;
+    VDIfIoInt.pfnWriteUser              = vdIOIntWriteUserLimited;
+    VDIfIoInt.pfnReadMeta               = vdIOIntReadMetaLimited;
+    VDIfIoInt.pfnWriteMeta              = vdIOIntWriteMetaLimited;
+    VDIfIoInt.pfnFlush                  = vdIOIntFlushLimited;
+    rc = VDInterfaceAdd(&VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                        pInterfaceIo, sizeof(VDINTERFACEIOINT), &pVDIfsImage);
+    AssertRC(rc);
+
+    /** @todo r=bird: Would be better to do a scoring approach here, where the
+     * backend that scores the highest is choosen.  That way we don't have to depend
+     * on registration order and filename suffixes to figure out what RAW should
+     * handle and not.   Besides, the registration order won't cut it for plug-ins
+     * anyway, as they end up after the builtin ones.
+     */
+
+    /* Find the backend supporting this file format. */
+    for (unsigned i = 0; i < vdGetImageBackendCount(); i++)
+    {
+        PCVDIMAGEBACKEND pBackend;
+        rc = vdQueryImageBackend(i, &pBackend);
+        AssertRC(rc);
+
+        if (pBackend->pfnProbe)
+        {
+            rc = pBackend->pfnProbe(pszFilename, pVDIfsDisk, pVDIfsImage, enmDesiredType, penmType);
+            if (    RT_SUCCESS(rc)
+                /* The correct backend has been found, but there is a small
+                 * incompatibility so that the file cannot be used. Stop here
+                 * and signal success - the actual open will of course fail,
+                 * but that will create a really sensible error message. */
+
+                    /** @todo r=bird: this bit of code is _certifiably_ _insane_ as it allows
+                     *        simple stuff like VERR_EOF to pass thru.  I've just amended it with
+                     *        disallowing VERR_EOF too, but someone needs to pick up the courage to
+                     *        fix this stuff properly or at least update the docs!
+                     *        (Parallels returns VERR_EOF, btw.) */
+
+                ||  (   rc != VERR_VD_GEN_INVALID_HEADER
+                     && rc != VERR_VD_VDI_INVALID_HEADER
+                     && rc != VERR_VD_VMDK_INVALID_HEADER
+                     && rc != VERR_VD_ISCSI_INVALID_HEADER
+                     && rc != VERR_VD_VHD_INVALID_HEADER
+                     && rc != VERR_VD_RAW_INVALID_HEADER
+                     && rc != VERR_VD_RAW_SIZE_MODULO_512
+                     && rc != VERR_VD_RAW_SIZE_MODULO_2048
+                     && rc != VERR_VD_RAW_SIZE_OPTICAL_TOO_SMALL
+                     && rc != VERR_VD_RAW_SIZE_FLOPPY_TOO_BIG
+                     && rc != VERR_VD_PARALLELS_INVALID_HEADER
+                     && rc != VERR_VD_DMG_INVALID_HEADER
+                     && rc != VERR_EOF /* bird for viso */
+                        ))
+            {
+                /* Copy the name into the new string. */
+                char *pszFormat = RTStrDup(pBackend->pszBackendName);
+                if (!pszFormat)
+                {
+                    rc = VERR_NO_MEMORY;
+                    break;
+                }
+                *ppszFormat = pszFormat;
+                /* Do not consider the typical file access errors as success,
+                 * which allows the caller to deal with such issues. */
+                if (   rc != VERR_ACCESS_DENIED
+                    && rc != VERR_PATH_NOT_FOUND
+                    && rc != VERR_FILE_NOT_FOUND)
+                    rc = VINF_SUCCESS;
+                break;
+            }
+            rc = VERR_NOT_SUPPORTED;
+        }
+    }
+
+    /* Try the cache backends. */
+    if (rc == VERR_NOT_SUPPORTED)
+    {
+        for (unsigned i = 0; i < vdGetCacheBackendCount(); i++)
+        {
+            PCVDCACHEBACKEND pBackend;
+            rc = vdQueryCacheBackend(i, &pBackend);
+            AssertRC(rc);
+
+            if (pBackend->pfnProbe)
+            {
+                rc = pBackend->pfnProbe(pszFilename, pVDIfsDisk, pVDIfsImage);
+                if (    RT_SUCCESS(rc)
+                    ||  (rc != VERR_VD_GEN_INVALID_HEADER))
+                {
+                    /* Copy the name into the new string. */
+                    char *pszFormat = RTStrDup(pBackend->pszBackendName);
+                    if (!pszFormat)
+                    {
+                        rc = VERR_NO_MEMORY;
+                        break;
+                    }
+                    *ppszFormat = pszFormat;
+                    rc = VINF_SUCCESS;
+                    break;
+                }
+                rc = VERR_NOT_SUPPORTED;
+            }
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc *ppszFormat=\"%s\"\n", rc, *ppszFormat));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDOpen(PVDISK pDisk, const char *pszBackend,
+                         const char *pszFilename, unsigned uOpenFlags,
+                         PVDINTERFACE pVDIfsImage)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+    PVDIMAGE pImage = NULL;
+
+    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsImage=%#p\n",
+                 pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsImage));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_PARAMETER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertReturn(*pszBackend != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
+                    ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+    AssertMsgReturn(   !(uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)
+                    ||  (uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                    ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    do
+    {
+        /*
+         * Destroy the current discard state first which might still have pending blocks
+         * for the currently opened image which will be switched to readonly mode.
+         */
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+        rc = vdDiscardStateDestroy(pDisk);
+        if (RT_FAILURE(rc))
+            break;
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = false;
+
+        /* Set up image descriptor. */
+        pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
+        if (!pImage)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pImage->pszFilename = RTStrDup(pszFilename);
+        if (!pImage->pszFilename)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        pImage->cbImage     = VD_IMAGE_SIZE_UNINITIALIZED;
+        pImage->VDIo.pDisk  = pDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+
+        rc = vdFindImageBackend(pszBackend, &pImage->Backend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pImage->Backend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown backend name '%s'"), pszBackend);
+            break;
+        }
+
+        /*
+         * Fail if the backend can't do async I/O but the
+         * flag is set.
+         */
+        if (   !(pImage->Backend->uBackendCaps & VD_CAP_ASYNC)
+            && (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO))
+        {
+            rc = vdError(pDisk, VERR_NOT_SUPPORTED, RT_SRC_POS,
+                         N_("VD: Backend '%s' does not support async I/O"), pszBackend);
+            break;
+        }
+
+        /*
+         * Fail if the backend doesn't support the discard operation but the
+         * flag is set.
+         */
+        if (   !(pImage->Backend->uBackendCaps & VD_CAP_DISCARD)
+            && (uOpenFlags & VD_OPEN_FLAGS_DISCARD))
+        {
+            rc = vdError(pDisk, VERR_VD_DISCARD_NOT_SUPPORTED, RT_SRC_POS,
+                         N_("VD: Backend '%s' does not support discard"), pszBackend);
+            break;
+        }
+
+        /* Set up the I/O interface. */
+        pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
+        if (!pImage->VDIo.pInterfaceIo)
+        {
+            vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
+            rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
+                                pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
+            pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
+        }
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
+        AssertRC(rc);
+
+        pImage->uOpenFlags = uOpenFlags & (VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_DISCARD | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS);
+        pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
+        rc = pImage->Backend->pfnOpen(pImage->pszFilename,
+                                      uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS),
+                                      pDisk->pVDIfsDisk,
+                                      pImage->pVDIfsImage,
+                                      pDisk->enmType,
+                                      &pImage->pBackendData);
+        /*
+         * If the image is corrupted and there is a repair method try to repair it
+         * first if it was openend in read-write mode and open again afterwards.
+         */
+        if (   RT_UNLIKELY(rc == VERR_VD_IMAGE_CORRUPTED)
+            && !(uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            && pImage->Backend->pfnRepair)
+        {
+            rc = pImage->Backend->pfnRepair(pszFilename, pDisk->pVDIfsDisk, pImage->pVDIfsImage, 0 /* fFlags */);
+            if (RT_SUCCESS(rc))
+                rc = pImage->Backend->pfnOpen(pImage->pszFilename,
+                                              uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS),
+                                              pDisk->pVDIfsDisk,
+                                              pImage->pVDIfsImage,
+                                              pDisk->enmType,
+                                              &pImage->pBackendData);
+            else
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: error %Rrc repairing corrupted image file '%s'"), rc, pszFilename);
+                break;
+            }
+        }
+        else if (RT_UNLIKELY(rc == VERR_VD_IMAGE_CORRUPTED))
+        {
+            rc = vdError(pDisk, rc, RT_SRC_POS,
+                         N_("VD: Image file '%s' is corrupted and can't be opened"), pszFilename);
+            break;
+        }
+
+        /* If the open in read-write mode failed, retry in read-only mode. */
+        if (RT_FAILURE(rc))
+        {
+            if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                &&  (   rc == VERR_ACCESS_DENIED
+                     || rc == VERR_PERMISSION_DENIED
+                     || rc == VERR_WRITE_PROTECT
+                     || rc == VERR_SHARING_VIOLATION
+                     || rc == VERR_FILE_LOCK_FAILED))
+                rc = pImage->Backend->pfnOpen(pImage->pszFilename,
+                                                (uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS))
+                                               | VD_OPEN_FLAGS_READONLY,
+                                               pDisk->pVDIfsDisk,
+                                               pImage->pVDIfsImage,
+                                               pDisk->enmType,
+                                               &pImage->pBackendData);
+            if (RT_FAILURE(rc))
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: error %Rrc opening image file '%s'"), rc, pszFilename);
+                break;
+            }
+        }
+
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        pImage->VDIo.pBackendData = pImage->pBackendData;
+
+        /* Check image type. As the image itself has only partial knowledge
+         * whether it's a base image or not, this info is derived here. The
+         * base image can be fixed or normal, all others must be normal or
+         * diff images. Some image formats don't distinguish between normal
+         * and diff images, so this must be corrected here. */
+        unsigned uImageFlags;
+        uImageFlags = pImage->Backend->pfnGetImageFlags(pImage->pBackendData);
+        if (RT_FAILURE(rc))
+            uImageFlags = VD_IMAGE_FLAGS_NONE;
+        if (    RT_SUCCESS(rc)
+            &&  !(uOpenFlags & VD_OPEN_FLAGS_INFO))
+        {
+            if (    pDisk->cImages == 0
+                &&  (uImageFlags & VD_IMAGE_FLAGS_DIFF))
+            {
+                rc = VERR_VD_INVALID_TYPE;
+                break;
+            }
+            else if (pDisk->cImages != 0)
+            {
+                if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+                {
+                    rc = VERR_VD_INVALID_TYPE;
+                    break;
+                }
+                else
+                    uImageFlags |= VD_IMAGE_FLAGS_DIFF;
+            }
+        }
+
+        /* Ensure we always get correct diff information, even if the backend
+         * doesn't actually have a stored flag for this. It must not return
+         * bogus information for the parent UUID if it is not a diff image. */
+        RTUUID parentUuid;
+        RTUuidClear(&parentUuid);
+        rc2 = pImage->Backend->pfnGetParentUuid(pImage->pBackendData, &parentUuid);
+        if (RT_SUCCESS(rc2) && !RTUuidIsNull(&parentUuid))
+            uImageFlags |= VD_IMAGE_FLAGS_DIFF;
+
+        pImage->uImageFlags = uImageFlags;
+
+        /* Force sane optimization settings. It's not worth avoiding writes
+         * to fixed size images. The overhead would have almost no payback. */
+        if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+            pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
+
+        /** @todo optionally check UUIDs */
+
+        /* Cache disk information. */
+        pDisk->cbSize = vdImageGetSize(pImage);
+
+        /* Cache PCHS geometry. */
+        rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
+                                                  &pDisk->PCHSGeometry);
+        if (RT_FAILURE(rc2))
+        {
+            pDisk->PCHSGeometry.cCylinders = 0;
+            pDisk->PCHSGeometry.cHeads = 0;
+            pDisk->PCHSGeometry.cSectors = 0;
+        }
+        else
+        {
+            /* Make sure the PCHS geometry is properly clipped. */
+            pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
+            pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
+            pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
+        }
+
+        /* Cache LCHS geometry. */
+        rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
+                                                  &pDisk->LCHSGeometry);
+        if (RT_FAILURE(rc2))
+        {
+            pDisk->LCHSGeometry.cCylinders = 0;
+            pDisk->LCHSGeometry.cHeads = 0;
+            pDisk->LCHSGeometry.cSectors = 0;
+        }
+        else
+        {
+            /* Make sure the LCHS geometry is properly clipped. */
+            pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
+            pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
+        }
+
+        if (pDisk->cImages != 0)
+        {
+            /* Switch previous image to read-only mode. */
+            unsigned uOpenFlagsPrevImg;
+            uOpenFlagsPrevImg = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
+            if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
+            {
+                uOpenFlagsPrevImg |= VD_OPEN_FLAGS_READONLY;
+                rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pBackendData, uOpenFlagsPrevImg);
+            }
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Image successfully opened, make it the last image. */
+            vdAddImageToList(pDisk, pImage);
+            if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
+        }
+        else
+        {
+            /* Error detected, but image opened. Close image. */
+            rc2 = pImage->Backend->pfnClose(pImage->pBackendData, false);
+            AssertRC(rc2);
+            pImage->pBackendData = NULL;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pImage)
+        {
+            if (pImage->pszFilename)
+                RTStrFree(pImage->pszFilename);
+            RTMemFree(pImage);
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCacheOpen(PVDISK pDisk, const char *pszBackend,
+                              const char *pszFilename, unsigned uOpenFlags,
+                              PVDINTERFACE pVDIfsCache)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+    PVDCACHE pCache = NULL;
+
+    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsCache=%#p\n",
+                 pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsCache));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_PARAMETER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertReturn(*pszBackend != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0, ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    do
+    {
+        /* Set up image descriptor. */
+        pCache = (PVDCACHE)RTMemAllocZ(sizeof(VDCACHE));
+        if (!pCache)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pCache->pszFilename = RTStrDup(pszFilename);
+        if (!pCache->pszFilename)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        pCache->VDIo.pDisk  = pDisk;
+        pCache->pVDIfsCache = pVDIfsCache;
+
+        rc = vdFindCacheBackend(pszBackend, &pCache->Backend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pCache->Backend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown backend name '%s'"), pszBackend);
+            break;
+        }
+
+        /* Set up the I/O interface. */
+        pCache->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsCache);
+        if (!pCache->VDIo.pInterfaceIo)
+        {
+            vdIfIoFallbackCallbacksSetup(&pCache->VDIo.VDIfIo);
+            rc = VDInterfaceAdd(&pCache->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
+                                pDisk, sizeof(VDINTERFACEIO), &pVDIfsCache);
+            pCache->VDIo.pInterfaceIo = &pCache->VDIo.VDIfIo;
+        }
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsCache), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pCache->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pCache->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pCache->VDIo, sizeof(VDINTERFACEIOINT), &pCache->pVDIfsCache);
+        AssertRC(rc);
+
+        pCache->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
+        rc = pCache->Backend->pfnOpen(pCache->pszFilename,
+                                      uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
+                                      pDisk->pVDIfsDisk,
+                                      pCache->pVDIfsCache,
+                                      &pCache->pBackendData);
+        /* If the open in read-write mode failed, retry in read-only mode. */
+        if (RT_FAILURE(rc))
+        {
+            if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY)
+                &&  (   rc == VERR_ACCESS_DENIED
+                     || rc == VERR_PERMISSION_DENIED
+                     || rc == VERR_WRITE_PROTECT
+                     || rc == VERR_SHARING_VIOLATION
+                     || rc == VERR_FILE_LOCK_FAILED))
+                rc = pCache->Backend->pfnOpen(pCache->pszFilename,
+                                                (uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME)
+                                               | VD_OPEN_FLAGS_READONLY,
+                                               pDisk->pVDIfsDisk,
+                                               pCache->pVDIfsCache,
+                                               &pCache->pBackendData);
+            if (RT_FAILURE(rc))
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: error %Rrc opening image file '%s'"), rc, pszFilename);
+                break;
+            }
+        }
+
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        /*
+         * Check that the modification UUID of the cache and last image
+         * match. If not the image was modified in-between without the cache.
+         * The cache might contain stale data.
+         */
+        RTUUID UuidImage, UuidCache;
+
+        rc = pCache->Backend->pfnGetModificationUuid(pCache->pBackendData,
+                                                     &UuidCache);
+        if (RT_SUCCESS(rc))
+        {
+            rc = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
+                                                               &UuidImage);
+            if (RT_SUCCESS(rc))
+            {
+                if (RTUuidCompare(&UuidImage, &UuidCache))
+                    rc = VERR_VD_CACHE_NOT_UP_TO_DATE;
+            }
+        }
+
+        /*
+         * We assume that the user knows what he is doing if one of the images
+         * doesn't support the modification uuid.
+         */
+        if (rc == VERR_NOT_SUPPORTED)
+            rc = VINF_SUCCESS;
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Cache successfully opened, make it the current one. */
+            if (!pDisk->pCache)
+                pDisk->pCache = pCache;
+            else
+                rc = VERR_VD_CACHE_ALREADY_EXISTS;
+        }
+
+        if (RT_FAILURE(rc))
+        {
+            /* Error detected, but image opened. Close image. */
+            rc2 = pCache->Backend->pfnClose(pCache->pBackendData, false);
+            AssertRC(rc2);
+            pCache->pBackendData = NULL;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pCache)
+        {
+            if (pCache->pszFilename)
+                RTStrFree(pCache->pszFilename);
+            RTMemFree(pCache);
+        }
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDFilterAdd(PVDISK pDisk, const char *pszFilter, uint32_t fFlags,
+                              PVDINTERFACE pVDIfsFilter)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+    PVDFILTER pFilter = NULL;
+
+    LogFlowFunc(("pDisk=%#p pszFilter=\"%s\" pVDIfsFilter=%#p\n",
+                 pDisk, pszFilter, pVDIfsFilter));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_PARAMETER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszFilter, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilter != '\0', VERR_INVALID_PARAMETER);
+    AssertMsgReturn(!(fFlags & ~VD_FILTER_FLAGS_MASK), ("Invalid flags set (fFlags=%#x)\n", fFlags),
+                    VERR_INVALID_PARAMETER);
+
+    do
+    {
+        /* Set up image descriptor. */
+        pFilter = (PVDFILTER)RTMemAllocZ(sizeof(VDFILTER));
+        if (!pFilter)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdFindFilterBackend(pszFilter, &pFilter->pBackend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pFilter->pBackend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown filter backend name '%s'"), pszFilter);
+            break;
+        }
+
+        pFilter->VDIo.pDisk   = pDisk;
+        pFilter->pVDIfsFilter = pVDIfsFilter;
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsFilter), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pFilter->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pFilter->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pFilter->VDIo, sizeof(VDINTERFACEIOINT), &pFilter->pVDIfsFilter);
+        AssertRC(rc);
+
+        rc = pFilter->pBackend->pfnCreate(pDisk->pVDIfsDisk, fFlags & VD_FILTER_FLAGS_INFO,
+                                          pFilter->pVDIfsFilter, &pFilter->pvBackendData);
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        /* Add filter to chains. */
+        if (fFlags & VD_FILTER_FLAGS_WRITE)
+        {
+            RTListAppend(&pDisk->ListFilterChainWrite, &pFilter->ListNodeChainWrite);
+            vdFilterRetain(pFilter);
+        }
+
+        if (fFlags & VD_FILTER_FLAGS_READ)
+        {
+            RTListAppend(&pDisk->ListFilterChainRead, &pFilter->ListNodeChainRead);
+            vdFilterRetain(pFilter);
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pFilter)
+            RTMemFree(pFilter);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCreateBase(PVDISK pDisk, const char *pszBackend,
+                               const char *pszFilename, uint64_t cbSize,
+                               unsigned uImageFlags, const char *pszComment,
+                               PCVDGEOMETRY pPCHSGeometry,
+                               PCVDGEOMETRY pLCHSGeometry,
+                               PCRTUUID pUuid, unsigned uOpenFlags,
+                               PVDINTERFACE pVDIfsImage,
+                               PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
+    PVDIMAGE pImage = NULL;
+    RTUUID uuid;
+
+    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" PCHS=%u/%u/%u LCHS=%u/%u/%u Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
+                 pDisk, pszBackend, pszFilename, cbSize, uImageFlags, pszComment,
+                 pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads,
+                 pPCHSGeometry->cSectors, pLCHSGeometry->cCylinders,
+                 pLCHSGeometry->cHeads, pLCHSGeometry->cSectors, pUuid,
+                 uOpenFlags, pVDIfsImage, pVDIfsOperation));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsgReturn(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature),
+                    VERR_INVALID_MAGIC);
+
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertReturn(*pszBackend != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertMsgReturn(cbSize || (uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK), ("cbSize=%llu\n", cbSize),
+                    VERR_INVALID_PARAMETER);
+    if (cbSize % 512 && !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK))
+    {
+        rc = vdError(pDisk, VERR_VD_INVALID_SIZE, RT_SRC_POS,
+                     N_("VD: The given disk size %llu is not aligned on a sector boundary (512 bytes)"), cbSize);
+        LogFlowFunc(("returns %Rrc\n", rc));
+        return rc;
+    }
+    AssertMsgReturn(   ((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0)
+                    || ((uImageFlags & (VD_IMAGE_FLAGS_FIXED | VD_IMAGE_FLAGS_DIFF)) != VD_IMAGE_FLAGS_FIXED),
+                    ("uImageFlags=%#x\n", uImageFlags),
+                    VERR_INVALID_PARAMETER);
+    AssertMsgReturn(   !(uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)
+                    || !(uImageFlags & ~(VD_VMDK_IMAGE_FLAGS_RAWDISK | VD_IMAGE_FLAGS_FIXED)),
+                    ("uImageFlags=%#x\n", uImageFlags),
+                    VERR_INVALID_PARAMETER);
+    /* The PCHS geometry fields may be 0 to leave it for later. */
+    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_PARAMETER);
+    AssertMsgReturn(   pPCHSGeometry->cHeads <= 16
+                    && pPCHSGeometry->cSectors <= 63,
+                    ("PCHS=%u/%u/%u\n", pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors),
+                    VERR_INVALID_PARAMETER);
+    /* The LCHS geometry fields may be 0 to leave it to later autodetection. */
+    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
+    AssertMsgReturn(   pLCHSGeometry->cHeads <= 255
+                    && pLCHSGeometry->cSectors <= 63,
+                    ("LCHS=%u/%u/%u\n", pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors),
+                    VERR_INVALID_PARAMETER);
+    /* The UUID may be NULL. */
+    AssertPtrNullReturn(pUuid, VERR_INVALID_POINTER);
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0, ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    AssertPtrNullReturn(pVDIfsOperation, VERR_INVALID_PARAMETER);
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do
+    {
+        /* Check state. Needs a temporary read lock. Holding the write lock
+         * all the time would be blocking other activities for too long. */
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+        AssertMsgBreakStmt(pDisk->cImages == 0,
+                           ("Create base image cannot be done with other images open\n"),
+                           rc = VERR_VD_INVALID_STATE);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        /* Set up image descriptor. */
+        pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
+        if (!pImage)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pImage->pszFilename = RTStrDup(pszFilename);
+        if (!pImage->pszFilename)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pImage->cbImage     = VD_IMAGE_SIZE_UNINITIALIZED;
+        pImage->VDIo.pDisk  = pDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+
+        /* Set up the I/O interface. */
+        pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
+        if (!pImage->VDIo.pInterfaceIo)
+        {
+            vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
+            rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
+                                pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
+            pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
+        }
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
+        AssertRC(rc);
+
+        rc = vdFindImageBackend(pszBackend, &pImage->Backend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pImage->Backend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown backend name '%s'"), pszBackend);
+            break;
+        }
+        if (!(pImage->Backend->uBackendCaps & (  VD_CAP_CREATE_FIXED
+                                               | VD_CAP_CREATE_DYNAMIC)))
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: backend '%s' cannot create base images"), pszBackend);
+            break;
+        }
+        if (   (   (uImageFlags & VD_VMDK_IMAGE_FLAGS_SPLIT_2G)
+                && !(pImage->Backend->uBackendCaps & VD_CAP_CREATE_SPLIT_2G))
+            || (   (uImageFlags & (  VD_VMDK_IMAGE_FLAGS_STREAM_OPTIMIZED
+                                   | VD_VMDK_IMAGE_FLAGS_RAWDISK))
+                && RTStrICmp(pszBackend, "VMDK")))
+        {
+            rc =  vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                          N_("VD: backend '%s' does not support the selected image variant"), pszBackend);
+            break;
+        }
+
+        /* Create UUID if the caller didn't specify one. */
+        if (!pUuid)
+        {
+            rc = RTUuidCreate(&uuid);
+            if (RT_FAILURE(rc))
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: cannot generate UUID for image '%s'"),
+                             pszFilename);
+                break;
+            }
+            pUuid = &uuid;
+        }
+
+        pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
+        uImageFlags &= ~VD_IMAGE_FLAGS_DIFF;
+        pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
+        rc = pImage->Backend->pfnCreate(pImage->pszFilename, cbSize,
+                                        uImageFlags, pszComment, pPCHSGeometry,
+                                        pLCHSGeometry, pUuid,
+                                        uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
+                                        0, 99,
+                                        pDisk->pVDIfsDisk,
+                                        pImage->pVDIfsImage,
+                                        pVDIfsOperation,
+                                        pDisk->enmType,
+                                        &pImage->pBackendData);
+
+        if (RT_SUCCESS(rc))
+        {
+            pImage->VDIo.pBackendData = pImage->pBackendData;
+            pImage->uImageFlags = uImageFlags;
+
+            /* Force sane optimization settings. It's not worth avoiding writes
+             * to fixed size images. The overhead would have almost no payback. */
+            if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
+                pImage->uOpenFlags |= VD_OPEN_FLAGS_HONOR_SAME;
+
+            /* Lock disk for writing, as we modify pDisk information below. */
+            rc2 = vdThreadStartWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = true;
+
+            /** @todo optionally check UUIDs */
+
+            /* Re-check state, as the lock wasn't held and another image
+             * creation call could have been done by another thread. */
+            AssertMsgStmt(pDisk->cImages == 0,
+                          ("Create base image cannot be done with other images open\n"),
+                          rc = VERR_VD_INVALID_STATE);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Cache disk information. */
+            pDisk->cbSize = vdImageGetSize(pImage);
+
+            /* Cache PCHS geometry. */
+            rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
+                                                      &pDisk->PCHSGeometry);
+            if (RT_FAILURE(rc2))
+            {
+                pDisk->PCHSGeometry.cCylinders = 0;
+                pDisk->PCHSGeometry.cHeads = 0;
+                pDisk->PCHSGeometry.cSectors = 0;
+            }
+            else
+            {
+                /* Make sure the CHS geometry is properly clipped. */
+                pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
+                pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
+                pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
+            }
+
+            /* Cache LCHS geometry. */
+            rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
+                                                      &pDisk->LCHSGeometry);
+            if (RT_FAILURE(rc2))
+            {
+                pDisk->LCHSGeometry.cCylinders = 0;
+                pDisk->LCHSGeometry.cHeads = 0;
+                pDisk->LCHSGeometry.cSectors = 0;
+            }
+            else
+            {
+                /* Make sure the CHS geometry is properly clipped. */
+                pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
+                pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
+            }
+
+            /* Image successfully opened, make it the last image. */
+            vdAddImageToList(pDisk, pImage);
+            if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
+        }
+        else
+        {
+            /* Error detected, image may or may not be opened. Close and delete
+             * image if it was opened. */
+            if (pImage->pBackendData)
+            {
+                rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
+                AssertRC(rc2);
+                pImage->pBackendData = NULL;
+            }
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pImage)
+        {
+            if (pImage->pszFilename)
+                RTStrFree(pImage->pszFilename);
+            RTMemFree(pImage);
+        }
+    }
+
+    if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
+        pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCreateDiff(PVDISK pDisk, const char *pszBackend,
+                               const char *pszFilename, unsigned uImageFlags,
+                               const char *pszComment, PCRTUUID pUuid,
+                               PCRTUUID pParentUuid, unsigned uOpenFlags,
+                               PVDINTERFACE pVDIfsImage,
+                               PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
+    PVDIMAGE pImage = NULL;
+    RTUUID uuid;
+
+    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
+                 pDisk, pszBackend, pszFilename, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsImage, pVDIfsOperation));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_PARAMETER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertReturn(*pszBackend != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertMsgReturn((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0, ("uImageFlags=%#x\n", uImageFlags),
+                    VERR_INVALID_PARAMETER);
+    /* The UUID may be NULL. */
+    AssertPtrNullReturn(pUuid, VERR_INVALID_POINTER);
+    /* The parent UUID may be NULL. */
+    AssertPtrNullReturn(pParentUuid, VERR_INVALID_POINTER);
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0, ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+    do
+    {
+        /* Check state. Needs a temporary read lock. Holding the write lock
+         * all the time would be blocking other activities for too long. */
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+        AssertMsgBreakStmt(pDisk->cImages != 0,
+                           ("Create diff image cannot be done without other images open\n"),
+                           rc = VERR_VD_INVALID_STATE);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        /*
+         * Destroy the current discard state first which might still have pending blocks
+         * for the currently opened image which will be switched to readonly mode.
+         */
+        /* Lock disk for writing, as we modify pDisk information below. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+        rc = vdDiscardStateDestroy(pDisk);
+        if (RT_FAILURE(rc))
+            break;
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = false;
+
+        /* Set up image descriptor. */
+        pImage = (PVDIMAGE)RTMemAllocZ(sizeof(VDIMAGE));
+        if (!pImage)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pImage->pszFilename = RTStrDup(pszFilename);
+        if (!pImage->pszFilename)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdFindImageBackend(pszBackend, &pImage->Backend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pImage->Backend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown backend name '%s'"), pszBackend);
+            break;
+        }
+        if (   !(pImage->Backend->uBackendCaps & VD_CAP_DIFF)
+            || !(pImage->Backend->uBackendCaps & (  VD_CAP_CREATE_FIXED
+                                                  | VD_CAP_CREATE_DYNAMIC)))
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: backend '%s' cannot create diff images"), pszBackend);
+            break;
+        }
+
+        pImage->cbImage     = VD_IMAGE_SIZE_UNINITIALIZED;
+        pImage->VDIo.pDisk  = pDisk;
+        pImage->pVDIfsImage = pVDIfsImage;
+
+        /* Set up the I/O interface. */
+        pImage->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsImage);
+        if (!pImage->VDIo.pInterfaceIo)
+        {
+            vdIfIoFallbackCallbacksSetup(&pImage->VDIo.VDIfIo);
+            rc = VDInterfaceAdd(&pImage->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
+                                pDisk, sizeof(VDINTERFACEIO), &pVDIfsImage);
+            pImage->VDIo.pInterfaceIo = &pImage->VDIo.VDIfIo;
+        }
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsImage), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pImage->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pImage->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pImage->VDIo, sizeof(VDINTERFACEIOINT), &pImage->pVDIfsImage);
+        AssertRC(rc);
+
+        /* Create UUID if the caller didn't specify one. */
+        if (!pUuid)
+        {
+            rc = RTUuidCreate(&uuid);
+            if (RT_FAILURE(rc))
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: cannot generate UUID for image '%s'"),
+                             pszFilename);
+                break;
+            }
+            pUuid = &uuid;
+        }
+
+        pImage->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
+        pImage->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
+        uImageFlags |= VD_IMAGE_FLAGS_DIFF;
+        rc = pImage->Backend->pfnCreate(pImage->pszFilename, pDisk->cbSize,
+                                        uImageFlags | VD_IMAGE_FLAGS_DIFF,
+                                        pszComment, &pDisk->PCHSGeometry,
+                                        &pDisk->LCHSGeometry, pUuid,
+                                        uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
+                                        0, 99,
+                                        pDisk->pVDIfsDisk,
+                                        pImage->pVDIfsImage,
+                                        pVDIfsOperation,
+                                        pDisk->enmType,
+                                        &pImage->pBackendData);
+
+        if (RT_SUCCESS(rc))
+        {
+            pImage->VDIo.pBackendData = pImage->pBackendData;
+            pImage->uImageFlags = uImageFlags;
+
+            /* Lock disk for writing, as we modify pDisk information below. */
+            rc2 = vdThreadStartWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = true;
+
+            /* Switch previous image to read-only mode. */
+            unsigned uOpenFlagsPrevImg;
+            uOpenFlagsPrevImg = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
+            if (!(uOpenFlagsPrevImg & VD_OPEN_FLAGS_READONLY))
+            {
+                uOpenFlagsPrevImg |= VD_OPEN_FLAGS_READONLY;
+                rc = pDisk->pLast->Backend->pfnSetOpenFlags(pDisk->pLast->pBackendData, uOpenFlagsPrevImg);
+            }
+
+            /** @todo optionally check UUIDs */
+
+            /* Re-check state, as the lock wasn't held and another image
+             * creation call could have been done by another thread. */
+            AssertMsgStmt(pDisk->cImages != 0,
+                          ("Create diff image cannot be done without other images open\n"),
+                          rc = VERR_VD_INVALID_STATE);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            RTUUID Uuid;
+            RTTIMESPEC ts;
+
+            if (pParentUuid && !RTUuidIsNull(pParentUuid))
+            {
+                Uuid = *pParentUuid;
+                pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
+            }
+            else
+            {
+                rc2 = pDisk->pLast->Backend->pfnGetUuid(pDisk->pLast->pBackendData,
+                                                        &Uuid);
+                if (RT_SUCCESS(rc2))
+                    pImage->Backend->pfnSetParentUuid(pImage->pBackendData, &Uuid);
+            }
+            rc2 = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
+                                                                &Uuid);
+            if (RT_SUCCESS(rc2))
+                pImage->Backend->pfnSetParentModificationUuid(pImage->pBackendData,
+                                                              &Uuid);
+            if (pDisk->pLast->Backend->pfnGetTimestamp)
+                rc2 = pDisk->pLast->Backend->pfnGetTimestamp(pDisk->pLast->pBackendData,
+                                                             &ts);
+            else
+                rc2 = VERR_NOT_IMPLEMENTED;
+            if (RT_SUCCESS(rc2) && pImage->Backend->pfnSetParentTimestamp)
+                pImage->Backend->pfnSetParentTimestamp(pImage->pBackendData, &ts);
+
+            if (pImage->Backend->pfnSetParentFilename)
+                rc2 = pImage->Backend->pfnSetParentFilename(pImage->pBackendData, pDisk->pLast->pszFilename);
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Image successfully opened, make it the last image. */
+            vdAddImageToList(pDisk, pImage);
+            if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
+                pDisk->uModified = VD_IMAGE_MODIFIED_FIRST;
+        }
+        else
+        {
+            /* Error detected, but image opened. Close and delete image. */
+            rc2 = pImage->Backend->pfnClose(pImage->pBackendData, true);
+            AssertRC(rc2);
+            pImage->pBackendData = NULL;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pImage)
+        {
+            if (pImage->pszFilename)
+                RTStrFree(pImage->pszFilename);
+            RTMemFree(pImage);
+        }
+    }
+
+    if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
+        pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCreateCache(PVDISK pDisk, const char *pszBackend,
+                                const char *pszFilename, uint64_t cbSize,
+                                unsigned uImageFlags, const char *pszComment,
+                                PCRTUUID pUuid, unsigned uOpenFlags,
+                                PVDINTERFACE pVDIfsCache, PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
+    PVDCACHE pCache = NULL;
+    RTUUID uuid;
+
+    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x pVDIfsImage=%#p pVDIfsOperation=%#p\n",
+                 pDisk, pszBackend, pszFilename, cbSize, uImageFlags, pszComment, pUuid, uOpenFlags, pVDIfsCache, pVDIfsOperation));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertReturn(*pszBackend, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertReturn(cbSize > 0, VERR_INVALID_PARAMETER);
+    AssertMsgReturn((uImageFlags & ~VD_IMAGE_FLAGS_MASK) == 0, ("uImageFlags=%#x\n", uImageFlags),
+                    VERR_INVALID_PARAMETER);
+    /* The UUID may be NULL. */
+    AssertPtrNullReturn(pUuid, VERR_INVALID_POINTER);
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0, ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do
+    {
+        /* Check state. Needs a temporary read lock. Holding the write lock
+         * all the time would be blocking other activities for too long. */
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+        AssertMsgBreakStmt(!pDisk->pCache,
+                           ("Create cache image cannot be done with a cache already attached\n"),
+                           rc = VERR_VD_CACHE_ALREADY_EXISTS);
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        /* Set up image descriptor. */
+        pCache = (PVDCACHE)RTMemAllocZ(sizeof(VDCACHE));
+        if (!pCache)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+        pCache->pszFilename = RTStrDup(pszFilename);
+        if (!pCache->pszFilename)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdFindCacheBackend(pszBackend, &pCache->Backend);
+        if (RT_FAILURE(rc))
+            break;
+        if (!pCache->Backend)
+        {
+            rc = vdError(pDisk, VERR_INVALID_PARAMETER, RT_SRC_POS,
+                         N_("VD: unknown backend name '%s'"), pszBackend);
+            break;
+        }
+
+        pCache->VDIo.pDisk        = pDisk;
+        pCache->pVDIfsCache       = pVDIfsCache;
+
+        /* Set up the I/O interface. */
+        pCache->VDIo.pInterfaceIo = VDIfIoGet(pVDIfsCache);
+        if (!pCache->VDIo.pInterfaceIo)
+        {
+            vdIfIoFallbackCallbacksSetup(&pCache->VDIo.VDIfIo);
+            rc = VDInterfaceAdd(&pCache->VDIo.VDIfIo.Core, "VD_IO", VDINTERFACETYPE_IO,
+                                pDisk, sizeof(VDINTERFACEIO), &pVDIfsCache);
+            pCache->VDIo.pInterfaceIo = &pCache->VDIo.VDIfIo;
+        }
+
+        /* Set up the internal I/O interface. */
+        AssertBreakStmt(!VDIfIoIntGet(pVDIfsCache), rc = VERR_INVALID_PARAMETER);
+        vdIfIoIntCallbacksSetup(&pCache->VDIo.VDIfIoInt);
+        rc = VDInterfaceAdd(&pCache->VDIo.VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                            &pCache->VDIo, sizeof(VDINTERFACEIOINT), &pCache->pVDIfsCache);
+        AssertRC(rc);
+
+        /* Create UUID if the caller didn't specify one. */
+        if (!pUuid)
+        {
+            rc = RTUuidCreate(&uuid);
+            if (RT_FAILURE(rc))
+            {
+                rc = vdError(pDisk, rc, RT_SRC_POS,
+                             N_("VD: cannot generate UUID for image '%s'"),
+                             pszFilename);
+                break;
+            }
+            pUuid = &uuid;
+        }
+
+        pCache->uOpenFlags = uOpenFlags & VD_OPEN_FLAGS_HONOR_SAME;
+        pCache->VDIo.fIgnoreFlush = (uOpenFlags & VD_OPEN_FLAGS_IGNORE_FLUSH) != 0;
+        rc = pCache->Backend->pfnCreate(pCache->pszFilename, cbSize,
+                                        uImageFlags,
+                                        pszComment, pUuid,
+                                        uOpenFlags & ~VD_OPEN_FLAGS_HONOR_SAME,
+                                        0, 99,
+                                        pDisk->pVDIfsDisk,
+                                        pCache->pVDIfsCache,
+                                        pVDIfsOperation,
+                                        &pCache->pBackendData);
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Lock disk for writing, as we modify pDisk information below. */
+            rc2 = vdThreadStartWrite(pDisk);
+            AssertRC(rc2);
+            fLockWrite = true;
+
+            pCache->VDIo.pBackendData = pCache->pBackendData;
+
+            /* Re-check state, as the lock wasn't held and another image
+             * creation call could have been done by another thread. */
+            AssertMsgStmt(!pDisk->pCache,
+                          ("Create cache image cannot be done with another cache open\n"),
+                          rc = VERR_VD_CACHE_ALREADY_EXISTS);
+        }
+
+        if (   RT_SUCCESS(rc)
+            && pDisk->pLast)
+        {
+            RTUUID UuidModification;
+
+            /* Set same modification Uuid as the last image. */
+            rc = pDisk->pLast->Backend->pfnGetModificationUuid(pDisk->pLast->pBackendData,
+                                                               &UuidModification);
+            if (RT_SUCCESS(rc))
+            {
+                rc = pCache->Backend->pfnSetModificationUuid(pCache->pBackendData,
+                                                             &UuidModification);
+            }
+
+            if (rc == VERR_NOT_SUPPORTED)
+                rc = VINF_SUCCESS;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            /* Cache successfully created. */
+            pDisk->pCache = pCache;
+        }
+        else
+        {
+            /* Error detected, but image opened. Close and delete image. */
+            rc2 = pCache->Backend->pfnClose(pCache->pBackendData, true);
+            AssertRC(rc2);
+            pCache->pBackendData = NULL;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_FAILURE(rc))
+    {
+        if (pCache)
+        {
+            if (pCache->pszFilename)
+                RTStrFree(pCache->pszFilename);
+            RTMemFree(pCache);
+        }
+    }
+
+    if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
+        pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDMerge(PVDISK pDisk, unsigned nImageFrom,
+                          unsigned nImageTo, PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false, fLockRead = false;
+    void *pvBuf = NULL;
+
+    LogFlowFunc(("pDisk=%#p nImageFrom=%u nImageTo=%u pVDIfsOperation=%#p\n",
+                 pDisk, nImageFrom, nImageTo, pVDIfsOperation));
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        /* For simplicity reasons lock for writing as the image reopen below
+         * might need it. After all the reopen is usually needed. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+        PVDIMAGE pImageFrom = vdGetImageByNumber(pDisk, nImageFrom);
+        PVDIMAGE pImageTo = vdGetImageByNumber(pDisk, nImageTo);
+        if (!pImageFrom || !pImageTo)
+        {
+            rc = VERR_VD_IMAGE_NOT_FOUND;
+            break;
+        }
+        AssertBreakStmt(pImageFrom != pImageTo, rc = VERR_INVALID_PARAMETER);
+
+        /* Make sure destination image is writable. */
+        unsigned uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
+        if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
+        {
+            /*
+             * Clear skip consistency checks because the image is made writable now and
+             * skipping consistency checks is only possible for readonly images.
+             */
+            uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
+            rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
+                                                    uOpenFlags);
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        /* Get size of destination image. */
+        uint64_t cbSize = vdImageGetSize(pImageTo);
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = false;
+
+        /* Allocate tmp buffer. */
+        pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
+        if (!pvBuf)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        /* Merging is done directly on the images itself. This potentially
+         * causes trouble if the disk is full in the middle of operation. */
+        if (nImageFrom < nImageTo)
+        {
+            /* Merge parent state into child. This means writing all not
+             * allocated blocks in the destination image which are allocated in
+             * the images to be merged. */
+            uint64_t uOffset = 0;
+            uint64_t cbRemaining = cbSize;
+
+            do
+            {
+                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. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
+                rc = pImageTo->Backend->pfnRead(pImageTo->pBackendData,
+                                                uOffset, cbThisRead,
+                                                &IoCtx, &cbThisRead);
+                if (rc == VERR_VD_BLOCK_FREE)
+                {
+                    /* Search for image with allocated block. Do not attempt to
+                     * read more than the previous reads marked as valid.
+                     * Otherwise this would return stale data when different
+                     * block sizes are used for the images. */
+                    for (PVDIMAGE pCurrImage = pImageTo->pPrev;
+                         pCurrImage != NULL && pCurrImage != pImageFrom->pPrev && rc == VERR_VD_BLOCK_FREE;
+                         pCurrImage = pCurrImage->pPrev)
+                    {
+                        /*
+                         * Skip reading when offset exceeds image size which can happen when the target is
+                         * bigger than the source.
+                         */
+                        uint64_t cbImage = vdImageGetSize(pCurrImage);
+                        if (uOffset < cbImage)
+                        {
+                            cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
+                            rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                                              uOffset, cbThisRead,
+                                                              &IoCtx, &cbThisRead);
+                        }
+                        else
+                            rc = VERR_VD_BLOCK_FREE;
+                    }
+
+                    if (rc != VERR_VD_BLOCK_FREE)
+                    {
+                        if (RT_FAILURE(rc))
+                            break;
+                        /* Updating the cache is required because this might be a live merge. */
+                        rc = vdWriteHelperEx(pDisk, pImageTo, pImageFrom->pPrev,
+                                             uOffset, pvBuf, cbThisRead,
+                                             VDIOCTX_FLAGS_READ_UPDATE_CACHE, 0);
+                        if (RT_FAILURE(rc))
+                            break;
+                    }
+                    else
+                        rc = VINF_SUCCESS;
+                }
+                else if (RT_FAILURE(rc))
+                    break;
+
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+
+                uOffset += cbThisRead;
+                cbRemaining -= cbThisRead;
+
+                if (pIfProgress && pIfProgress->pfnProgress)
+                {
+                    /** @todo r=klaus: this can update the progress to the same
+                     * percentage over and over again if the image format makes
+                     * relatively small increments. */
+                    rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
+                                                  uOffset * 99 / cbSize);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+            } while (uOffset < cbSize);
+        }
+        else
+        {
+            /*
+             * We may need to update the parent uuid of the child coming after
+             * the last image to be merged. We have to reopen it read/write.
+             *
+             * This is done before we do the actual merge to prevent an
+             * inconsistent chain if the mode change fails for some reason.
+             */
+            if (pImageFrom->pNext)
+            {
+                PVDIMAGE pImageChild = pImageFrom->pNext;
+
+                /* Take the write lock. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
+                /* We need to open the image in read/write mode. */
+                uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
+
+                if (uOpenFlags  & VD_OPEN_FLAGS_READONLY)
+                {
+                    uOpenFlags  &= ~VD_OPEN_FLAGS_READONLY;
+                    rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
+                                                               uOpenFlags);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+            }
+
+            /* If the merge is from the last image we have to relay all writes
+             * to the merge destination as well, so that concurrent writes
+             * (in case of a live merge) are handled correctly. */
+            if (!pImageFrom->pNext)
+            {
+                /* Take the write lock. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
+                pDisk->pImageRelay = pImageTo;
+
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+            }
+
+            /* Merge child state into parent. This means writing all blocks
+             * which are allocated in the image up to the source image to the
+             * destination image. */
+            unsigned uProgressOld = 0;
+            uint64_t uOffset = 0;
+            uint64_t cbRemaining = cbSize;
+            do
+            {
+                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. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
+                /* Search for image with allocated block. Do not attempt to
+                 * read more than the previous reads marked as valid. Otherwise
+                 * this would return stale data when different block sizes are
+                 * used for the images. */
+                for (PVDIMAGE pCurrImage = pImageFrom;
+                     pCurrImage != NULL && pCurrImage != pImageTo && rc == VERR_VD_BLOCK_FREE;
+                     pCurrImage = pCurrImage->pPrev)
+                {
+                    /*
+                     * Skip reading when offset exceeds image size which can happen when the target is
+                     * bigger than the source.
+                     */
+                    uint64_t cbImage = vdImageGetSize(pCurrImage);
+                    if (uOffset < cbImage)
+                    {
+                        cbThisRead = RT_MIN(cbThisRead, cbImage - uOffset);
+                        rc = pCurrImage->Backend->pfnRead(pCurrImage->pBackendData,
+                                                          uOffset, cbThisRead,
+                                                          &IoCtx, &cbThisRead);
+                    }
+                    else
+                        rc = VERR_VD_BLOCK_FREE;
+                }
+
+                if (rc != VERR_VD_BLOCK_FREE)
+                {
+                    if (RT_FAILURE(rc))
+                        break;
+                    rc = vdWriteHelper(pDisk, pImageTo, uOffset, pvBuf,
+                                       cbThisRead, VDIOCTX_FLAGS_READ_UPDATE_CACHE);
+                    if (RT_FAILURE(rc))
+                        break;
+                }
+                else
+                    rc = VINF_SUCCESS;
+
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+
+                uOffset += cbThisRead;
+                cbRemaining -= cbThisRead;
+
+                unsigned uProgressNew = uOffset * 99 / cbSize;
+                if (uProgressNew != uProgressOld)
+                {
+                    uProgressOld = uProgressNew;
+
+                    if (pIfProgress && pIfProgress->pfnProgress)
+                    {
+                        rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
+                                                      uProgressOld);
+                        if (RT_FAILURE(rc))
+                            break;
+                    }
+                }
+
+            } while (uOffset < cbSize);
+
+            /* In case we set up a "write proxy" image above we must clear
+             * this again now to prevent stray writes. Failure or not. */
+            if (!pImageFrom->pNext)
+            {
+                /* Take the write lock. */
+                rc2 = vdThreadStartWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = true;
+
+                pDisk->pImageRelay = NULL;
+
+                rc2 = vdThreadFinishWrite(pDisk);
+                AssertRC(rc2);
+                fLockWrite = false;
+            }
+        }
+
+        /*
+         * Leave in case of an error to avoid corrupted data in the image chain
+         * (includes cancelling the operation by the user).
+         */
+        if (RT_FAILURE(rc))
+            break;
+
+        /* Need to hold the write lock while finishing the merge. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        /* Update parent UUID so that image chain is consistent.
+         * The two attempts work around the problem that some backends
+         * (e.g. iSCSI) do not support UUIDs, so we exploit the fact that
+         * so far there can only be one such image in the chain. */
+        /** @todo needs a better long-term solution, passing the UUID
+         * knowledge from the caller or some such */
+        RTUUID Uuid;
+        PVDIMAGE pImageChild = NULL;
+        if (nImageFrom < nImageTo)
+        {
+            if (pImageFrom->pPrev)
+            {
+                /* plan A: ask the parent itself for its UUID */
+                rc = pImageFrom->pPrev->Backend->pfnGetUuid(pImageFrom->pPrev->pBackendData,
+                                                            &Uuid);
+                if (RT_FAILURE(rc))
+                {
+                    /* plan B: ask the child of the parent for parent UUID */
+                    rc = pImageFrom->Backend->pfnGetParentUuid(pImageFrom->pBackendData,
+                                                               &Uuid);
+                }
+                AssertRC(rc);
+            }
+            else
+                RTUuidClear(&Uuid);
+            rc = pImageTo->Backend->pfnSetParentUuid(pImageTo->pBackendData,
+                                                     &Uuid);
+            AssertRC(rc);
+        }
+        else
+        {
+            /* Update the parent uuid of the child of the last merged image. */
+            if (pImageFrom->pNext)
+            {
+                /* plan A: ask the parent itself for its UUID */
+                rc = pImageTo->Backend->pfnGetUuid(pImageTo->pBackendData,
+                                                   &Uuid);
+                if (RT_FAILURE(rc))
+                {
+                    /* plan B: ask the child of the parent for parent UUID */
+                    rc = pImageTo->pNext->Backend->pfnGetParentUuid(pImageTo->pNext->pBackendData,
+                                                                    &Uuid);
+                }
+                AssertRC(rc);
+
+                rc = pImageFrom->Backend->pfnSetParentUuid(pImageFrom->pNext->pBackendData,
+                                                           &Uuid);
+                AssertRC(rc);
+
+                pImageChild = pImageFrom->pNext;
+            }
+        }
+
+        /* Delete the no longer needed images. */
+        PVDIMAGE pImg = pImageFrom, pTmp;
+        while (pImg != pImageTo)
+        {
+            if (nImageFrom < nImageTo)
+                pTmp = pImg->pNext;
+            else
+                pTmp = pImg->pPrev;
+            vdRemoveImageFromList(pDisk, pImg);
+            pImg->Backend->pfnClose(pImg->pBackendData, true);
+            RTStrFree(pImg->pszFilename);
+            RTMemFree(pImg);
+            pImg = pTmp;
+        }
+
+        /* Make sure destination image is back to read only if necessary. */
+        if (pImageTo != pDisk->pLast)
+        {
+            uOpenFlags = pImageTo->Backend->pfnGetOpenFlags(pImageTo->pBackendData);
+            uOpenFlags |= VD_OPEN_FLAGS_READONLY;
+            rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
+                                                    uOpenFlags);
+            if (RT_FAILURE(rc))
+                break;
+        }
+
+        /*
+         * Make sure the child is readonly
+         * for the child -> parent merge direction
+         * if necessary.
+        */
+        if (   nImageFrom > nImageTo
+            && pImageChild
+            && pImageChild != pDisk->pLast)
+        {
+            uOpenFlags = pImageChild->Backend->pfnGetOpenFlags(pImageChild->pBackendData);
+            uOpenFlags |= VD_OPEN_FLAGS_READONLY;
+            rc = pImageChild->Backend->pfnSetOpenFlags(pImageChild->pBackendData,
+                                                       uOpenFlags);
+            if (RT_FAILURE(rc))
+                break;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (pvBuf)
+        RTMemTmpFree(pvBuf);
+
+    if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
+        pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCopyEx(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
+                           const char *pszBackend, const char *pszFilename,
+                           bool fMoveByRename, uint64_t cbSize,
+                           unsigned nImageFromSame, unsigned nImageToSame,
+                           unsigned uImageFlags, PCRTUUID pDstUuid,
+                           unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
+                           PVDINTERFACE pDstVDIfsImage,
+                           PVDINTERFACE pDstVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockReadFrom = false, fLockWriteFrom = false, fLockWriteTo = false;
+    PVDIMAGE pImageTo = NULL;
+
+    LogFlowFunc(("pDiskFrom=%#p nImage=%u pDiskTo=%#p pszBackend=\"%s\" pszFilename=\"%s\" fMoveByRename=%d cbSize=%llu nImageFromSame=%u nImageToSame=%u uImageFlags=%#x pDstUuid=%#p uOpenFlags=%#x pVDIfsOperation=%#p pDstVDIfsImage=%#p pDstVDIfsOperation=%#p\n",
+                 pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename, cbSize, nImageFromSame, nImageToSame, uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation, pDstVDIfsImage, pDstVDIfsOperation));
+
+    /* Check arguments. */
+    AssertReturn(pDiskFrom, VERR_INVALID_POINTER);
+    AssertMsg(pDiskFrom->u32Signature == VDISK_SIGNATURE,
+              ("u32Signature=%08x\n", pDiskFrom->u32Signature));
+
+    PVDINTERFACEPROGRESS pIfProgress    = VDIfProgressGet(pVDIfsOperation);
+    PVDINTERFACEPROGRESS pDstIfProgress = VDIfProgressGet(pDstVDIfsOperation);
+
+    do {
+        rc2 = vdThreadStartRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = true;
+        PVDIMAGE pImageFrom = vdGetImageByNumber(pDiskFrom, nImage);
+        AssertPtrBreakStmt(pImageFrom, rc = VERR_VD_IMAGE_NOT_FOUND);
+        AssertPtrBreakStmt(pDiskTo, rc = VERR_INVALID_POINTER);
+        AssertMsg(pDiskTo->u32Signature == VDISK_SIGNATURE,
+                  ("u32Signature=%08x\n", pDiskTo->u32Signature));
+        AssertMsgBreakStmt(   (nImageFromSame < nImage || nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
+                           && (nImageToSame < pDiskTo->cImages || nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
+                           && (   (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN && nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
+                               || (nImageFromSame != VD_IMAGE_CONTENT_UNKNOWN && nImageToSame != VD_IMAGE_CONTENT_UNKNOWN)),
+                           ("nImageFromSame=%u nImageToSame=%u\n", nImageFromSame, nImageToSame),
+                           rc = VERR_INVALID_PARAMETER);
+
+        /* Move the image. */
+        if (pDiskFrom == pDiskTo)
+        {
+            /* Rename only works when backends are the same, are file based
+             * and the rename method is implemented. */
+            if (    fMoveByRename
+                &&  !RTStrICmp(pszBackend, pImageFrom->Backend->pszBackendName)
+                &&  pImageFrom->Backend->uBackendCaps & VD_CAP_FILE
+                &&  pImageFrom->Backend->pfnRename)
+            {
+                rc2 = vdThreadFinishRead(pDiskFrom);
+                AssertRC(rc2);
+                fLockReadFrom = false;
+
+                rc2 = vdThreadStartWrite(pDiskFrom);
+                AssertRC(rc2);
+                fLockWriteFrom = true;
+                rc = pImageFrom->Backend->pfnRename(pImageFrom->pBackendData, pszFilename ? pszFilename : pImageFrom->pszFilename);
+                break;
+            }
+
+            /** @todo Moving (including shrinking/growing) of the image is
+             * requested, but the rename attempt failed or it wasn't possible.
+             * Must now copy image to temp location. */
+            AssertReleaseMsgFailed(("VDCopy: moving by copy/delete not implemented\n"));
+        }
+
+        /* pszFilename is allowed to be NULL, as this indicates copy to the existing image. */
+        if (pszFilename)
+        {
+            AssertPtrBreakStmt(pszFilename, rc = VERR_INVALID_POINTER);
+            AssertBreakStmt(*pszFilename != '\0', rc = VERR_INVALID_PARAMETER);
+        }
+
+        uint64_t cbSizeFrom;
+        cbSizeFrom = vdImageGetSize(pImageFrom);
+        if (cbSizeFrom == 0)
+        {
+            rc = VERR_VD_VALUE_NOT_FOUND;
+            break;
+        }
+
+        VDGEOMETRY PCHSGeometryFrom = {0, 0, 0};
+        VDGEOMETRY LCHSGeometryFrom = {0, 0, 0};
+        pImageFrom->Backend->pfnGetPCHSGeometry(pImageFrom->pBackendData, &PCHSGeometryFrom);
+        pImageFrom->Backend->pfnGetLCHSGeometry(pImageFrom->pBackendData, &LCHSGeometryFrom);
+
+        RTUUID ImageUuid, ImageModificationUuid;
+        if (pDiskFrom != pDiskTo)
+        {
+            if (pDstUuid)
+                ImageUuid = *pDstUuid;
+            else
+                RTUuidCreate(&ImageUuid);
+        }
+        else
+        {
+            rc = pImageFrom->Backend->pfnGetUuid(pImageFrom->pBackendData, &ImageUuid);
+            if (RT_FAILURE(rc))
+                RTUuidCreate(&ImageUuid);
+        }
+        rc = pImageFrom->Backend->pfnGetModificationUuid(pImageFrom->pBackendData, &ImageModificationUuid);
+        if (RT_FAILURE(rc))
+            RTUuidClear(&ImageModificationUuid);
+
+        char szComment[1024];
+        rc = pImageFrom->Backend->pfnGetComment(pImageFrom->pBackendData, szComment, sizeof(szComment));
+        if (RT_FAILURE(rc))
+            szComment[0] = '\0';
+        else
+            szComment[sizeof(szComment) - 1] = '\0';
+
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+        fLockReadFrom = false;
+
+        rc2 = vdThreadStartRead(pDiskTo);
+        AssertRC(rc2);
+        unsigned cImagesTo = pDiskTo->cImages;
+        rc2 = vdThreadFinishRead(pDiskTo);
+        AssertRC(rc2);
+
+        if (pszFilename)
+        {
+            if (cbSize == 0)
+                cbSize = cbSizeFrom;
+
+            /* Create destination image with the properties of source image. */
+            /** @todo replace the VDCreateDiff/VDCreateBase calls by direct
+             * calls to the backend. Unifies the code and reduces the API
+             * dependencies. Would also make the synchronization explicit. */
+            if (cImagesTo > 0)
+            {
+                rc = VDCreateDiff(pDiskTo, pszBackend, pszFilename,
+                                  uImageFlags, szComment, &ImageUuid,
+                                  NULL /* pParentUuid */,
+                                  uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
+                                  pDstVDIfsImage, NULL);
+
+                rc2 = vdThreadStartWrite(pDiskTo);
+                AssertRC(rc2);
+                fLockWriteTo = true;
+            } else {
+                /** @todo hack to force creation of a fixed image for
+                 * the RAW backend, which can't handle anything else. */
+                if (!RTStrICmp(pszBackend, "RAW"))
+                    uImageFlags |= VD_IMAGE_FLAGS_FIXED;
+
+                vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
+                vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
+
+                rc = VDCreateBase(pDiskTo, pszBackend, pszFilename, cbSize,
+                                  uImageFlags, szComment,
+                                  &PCHSGeometryFrom, &LCHSGeometryFrom,
+                                  NULL, uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
+                                  pDstVDIfsImage, NULL);
+
+                rc2 = vdThreadStartWrite(pDiskTo);
+                AssertRC(rc2);
+                fLockWriteTo = true;
+
+                if (RT_SUCCESS(rc) && !RTUuidIsNull(&ImageUuid))
+                     pDiskTo->pLast->Backend->pfnSetUuid(pDiskTo->pLast->pBackendData, &ImageUuid);
+            }
+            if (RT_FAILURE(rc))
+                break;
+
+            pImageTo = pDiskTo->pLast;
+            AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+            cbSize = RT_MIN(cbSize, cbSizeFrom);
+        }
+        else
+        {
+            pImageTo = pDiskTo->pLast;
+            AssertPtrBreakStmt(pImageTo, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+            uint64_t cbSizeTo;
+            cbSizeTo = vdImageGetSize(pImageTo);
+            if (cbSizeTo == 0)
+            {
+                rc = VERR_VD_VALUE_NOT_FOUND;
+                break;
+            }
+
+            if (cbSize == 0)
+                cbSize = RT_MIN(cbSizeFrom, cbSizeTo);
+
+            vdFixupPCHSGeometry(&PCHSGeometryFrom, cbSize);
+            vdFixupLCHSGeometry(&LCHSGeometryFrom, cbSize);
+
+            /* Update the geometry in the destination image. */
+            pImageTo->Backend->pfnSetPCHSGeometry(pImageTo->pBackendData, &PCHSGeometryFrom);
+            pImageTo->Backend->pfnSetLCHSGeometry(pImageTo->pBackendData, &LCHSGeometryFrom);
+        }
+
+        rc2 = vdThreadFinishWrite(pDiskTo);
+        AssertRC(rc2);
+        fLockWriteTo = false;
+
+        /* Whether we can take the optimized copy path (false) or not.
+         * Don't optimize if the image existed or if it is a child image. */
+        bool fSuppressRedundantIo = (   !(pszFilename == NULL || cImagesTo > 0)
+                                     || (nImageToSame != VD_IMAGE_CONTENT_UNKNOWN));
+        unsigned cImagesFromReadBack, cImagesToReadBack;
+
+        if (nImageFromSame == VD_IMAGE_CONTENT_UNKNOWN)
+            cImagesFromReadBack = 0;
+        else
+        {
+            if (nImage == VD_LAST_IMAGE)
+                cImagesFromReadBack = pDiskFrom->cImages - nImageFromSame - 1;
+            else
+                cImagesFromReadBack = nImage - nImageFromSame;
+        }
+
+        if (nImageToSame == VD_IMAGE_CONTENT_UNKNOWN)
+            cImagesToReadBack = 0;
+        else
+            cImagesToReadBack = pDiskTo->cImages - nImageToSame - 1;
+
+        /* Copy the data. */
+        rc = vdCopyHelper(pDiskFrom, pImageFrom, pDiskTo, cbSize,
+                          cImagesFromReadBack, cImagesToReadBack,
+                          fSuppressRedundantIo, pIfProgress, pDstIfProgress);
+
+        if (RT_SUCCESS(rc))
+        {
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+
+            /* Only set modification UUID if it is non-null, since the source
+             * backend might not provide a valid modification UUID. */
+            if (!RTUuidIsNull(&ImageModificationUuid))
+                pImageTo->Backend->pfnSetModificationUuid(pImageTo->pBackendData, &ImageModificationUuid);
+
+            /* Set the requested open flags if they differ from the value
+             * required for creating the image and copying the contents. */
+            if (   pImageTo && pszFilename
+                && uOpenFlags != (uOpenFlags & ~VD_OPEN_FLAGS_READONLY))
+                rc = pImageTo->Backend->pfnSetOpenFlags(pImageTo->pBackendData,
+                                                        uOpenFlags);
+        }
+    } while (0);
+
+    if (RT_FAILURE(rc) && pImageTo && pszFilename)
+    {
+        /* Take the write lock only if it is not taken. Not worth making the
+         * above code even more complicated. */
+        if (RT_UNLIKELY(!fLockWriteTo))
+        {
+            rc2 = vdThreadStartWrite(pDiskTo);
+            AssertRC(rc2);
+            fLockWriteTo = true;
+        }
+        /* Error detected, but new image created. Remove image from list. */
+        vdRemoveImageFromList(pDiskTo, pImageTo);
+
+        /* Close and delete image. */
+        rc2 = pImageTo->Backend->pfnClose(pImageTo->pBackendData, true);
+        AssertRC(rc2);
+        pImageTo->pBackendData = NULL;
+
+        /* Free remaining resources. */
+        if (pImageTo->pszFilename)
+            RTStrFree(pImageTo->pszFilename);
+
+        RTMemFree(pImageTo);
+    }
+
+    if (RT_UNLIKELY(fLockWriteTo))
+    {
+        rc2 = vdThreadFinishWrite(pDiskTo);
+        AssertRC(rc2);
+    }
+    if (RT_UNLIKELY(fLockWriteFrom))
+    {
+        rc2 = vdThreadFinishWrite(pDiskFrom);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockReadFrom))
+    {
+        rc2 = vdThreadFinishRead(pDiskFrom);
+        AssertRC(rc2);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pIfProgress && pIfProgress->pfnProgress)
+            pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+        if (pDstIfProgress && pDstIfProgress->pfnProgress)
+            pDstIfProgress->pfnProgress(pDstIfProgress->Core.pvUser, 100);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCopy(PVDISK pDiskFrom, unsigned nImage, PVDISK pDiskTo,
+                         const char *pszBackend, const char *pszFilename,
+                         bool fMoveByRename, uint64_t cbSize,
+                         unsigned uImageFlags, PCRTUUID pDstUuid,
+                         unsigned uOpenFlags, PVDINTERFACE pVDIfsOperation,
+                         PVDINTERFACE pDstVDIfsImage,
+                         PVDINTERFACE pDstVDIfsOperation)
+{
+    return VDCopyEx(pDiskFrom, nImage, pDiskTo, pszBackend, pszFilename, fMoveByRename,
+                    cbSize, VD_IMAGE_CONTENT_UNKNOWN, VD_IMAGE_CONTENT_UNKNOWN,
+                    uImageFlags, pDstUuid, uOpenFlags, pVDIfsOperation,
+                    pDstVDIfsImage, pDstVDIfsOperation);
+}
+
+
+VBOXDDU_DECL(int) VDCompact(PVDISK pDisk, unsigned nImage,
+                            PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false, fLockWrite = false;
+    void *pvBuf = NULL;
+    void *pvTmp = NULL;
+
+    LogFlowFunc(("pDisk=%#p nImage=%u pVDIfsOperation=%#p\n",
+                 pDisk, nImage, pVDIfsOperation));
+    /* Check arguments. */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
+              ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do {
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
+        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+        /* If there is no compact callback for not file based backends then
+         * the backend doesn't need compaction. No need to make much fuss about
+         * this. For file based ones signal this as not yet supported. */
+        if (!pImage->Backend->pfnCompact)
+        {
+            if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
+                rc = VERR_NOT_SUPPORTED;
+            else
+                rc = VINF_SUCCESS;
+            break;
+        }
+
+        /* Insert interface for reading parent state into per-operation list,
+         * if there is a parent image. */
+        VDINTERFACEPARENTSTATE VDIfParent;
+        VDPARENTSTATEDESC ParentUser;
+        if (pImage->pPrev)
+        {
+            VDIfParent.pfnParentRead = vdParentRead;
+            ParentUser.pDisk = pDisk;
+            ParentUser.pImage = pImage->pPrev;
+            rc = VDInterfaceAdd(&VDIfParent.Core, "VDCompact_ParentState", VDINTERFACETYPE_PARENTSTATE,
+                                &ParentUser, sizeof(VDINTERFACEPARENTSTATE), &pVDIfsOperation);
+            AssertRC(rc);
+        }
+
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        rc = pImage->Backend->pfnCompact(pImage->pBackendData,
+                                         0, 99,
+                                         pDisk->pVDIfsDisk,
+                                         pImage->pVDIfsImage,
+                                         pVDIfsOperation);
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (pvBuf)
+        RTMemTmpFree(pvBuf);
+    if (pvTmp)
+        RTMemTmpFree(pvTmp);
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pIfProgress && pIfProgress->pfnProgress)
+            pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDResize(PVDISK pDisk, uint64_t cbSize,
+                           PCVDGEOMETRY pPCHSGeometry,
+                           PCVDGEOMETRY pLCHSGeometry,
+                           PVDINTERFACE pVDIfsOperation)
+{
+    /** @todo r=klaus resizing was designed to be part of VDCopy, so having a separate function is not desirable. */
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false, fLockWrite = false;
+
+    LogFlowFunc(("pDisk=%#p cbSize=%llu pVDIfsOperation=%#p\n",
+                 pDisk, cbSize, pVDIfsOperation));
+    /* Check arguments. */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
+              ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do {
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
+        /* Must have at least one image in the chain, will resize last. */
+        AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
+                           rc = VERR_NOT_SUPPORTED);
+
+        PVDIMAGE pImage = pDisk->pLast;
+
+        /* If there is no compact callback for not file based backends then
+         * the backend doesn't need compaction. No need to make much fuss about
+         * this. For file based ones signal this as not yet supported. */
+        if (!pImage->Backend->pfnResize)
+        {
+            if (pImage->Backend->uBackendCaps & VD_CAP_FILE)
+                rc = VERR_NOT_SUPPORTED;
+            else
+                rc = VINF_SUCCESS;
+            break;
+        }
+
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        VDGEOMETRY PCHSGeometryOld;
+        VDGEOMETRY LCHSGeometryOld;
+        PCVDGEOMETRY pPCHSGeometryNew;
+        PCVDGEOMETRY pLCHSGeometryNew;
+
+        if (pPCHSGeometry->cCylinders == 0)
+        {
+            /* Auto-detect marker, calculate new value ourself. */
+            rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData, &PCHSGeometryOld);
+            if (RT_SUCCESS(rc) && (PCHSGeometryOld.cCylinders != 0))
+                PCHSGeometryOld.cCylinders = RT_MIN(cbSize / 512 / PCHSGeometryOld.cHeads / PCHSGeometryOld.cSectors, 16383);
+            else if (rc == VERR_VD_GEOMETRY_NOT_SET)
+                rc = VINF_SUCCESS;
+
+            pPCHSGeometryNew = &PCHSGeometryOld;
+        }
+        else
+            pPCHSGeometryNew = pPCHSGeometry;
+
+        if (pLCHSGeometry->cCylinders == 0)
+        {
+            /* Auto-detect marker, calculate new value ourself. */
+            rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData, &LCHSGeometryOld);
+            if (RT_SUCCESS(rc) && (LCHSGeometryOld.cCylinders != 0))
+                LCHSGeometryOld.cCylinders = cbSize / 512 / LCHSGeometryOld.cHeads / LCHSGeometryOld.cSectors;
+            else if (rc == VERR_VD_GEOMETRY_NOT_SET)
+                rc = VINF_SUCCESS;
+
+            pLCHSGeometryNew = &LCHSGeometryOld;
+        }
+        else
+            pLCHSGeometryNew = pLCHSGeometry;
+
+        if (RT_SUCCESS(rc))
+            rc = pImage->Backend->pfnResize(pImage->pBackendData,
+                                            cbSize,
+                                            pPCHSGeometryNew,
+                                            pLCHSGeometryNew,
+                                            0, 99,
+                                            pDisk->pVDIfsDisk,
+                                            pImage->pVDIfsImage,
+                                            pVDIfsOperation);
+        /* Mark the image size as uninitialized so it gets recalculated the next time. */
+        if (RT_SUCCESS(rc))
+            pImage->cbImage = VD_IMAGE_SIZE_UNINITIALIZED;
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (RT_SUCCESS(rc))
+    {
+        if (pIfProgress && pIfProgress->pfnProgress)
+            pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+        pDisk->cbSize = cbSize;
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+VBOXDDU_DECL(int) VDPrepareWithFilters(PVDISK pDisk, PVDINTERFACE pVDIfsOperation)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false, fLockWrite = false;
+
+    LogFlowFunc(("pDisk=%#p pVDIfsOperation=%#p\n", pDisk, pVDIfsOperation));
+    /* Check arguments. */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE,
+              ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
+
+    do {
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
+        /* Must have at least one image in the chain. */
+        AssertMsgBreakStmt(pDisk->cImages >= 1, ("cImages=%u\n", pDisk->cImages),
+                           rc = VERR_VD_NOT_OPENED);
+
+        unsigned uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
+        AssertMsgBreakStmt(!(uOpenFlags & VD_OPEN_FLAGS_READONLY),
+                           ("Last image should be read write"),
+                           rc = VERR_VD_IMAGE_READ_ONLY);
+
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = false;
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        /*
+         * Open all images in the chain in read write mode first to avoid running
+         * into an error in the middle of the process.
+         */
+        PVDIMAGE pImage = pDisk->pBase;
+
+        while (pImage)
+        {
+            uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
+            if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
+            {
+                /*
+                 * Clear skip consistency checks because the image is made writable now and
+                 * skipping consistency checks is only possible for readonly images.
+                 */
+                uOpenFlags &= ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS);
+                rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
+                if (RT_FAILURE(rc))
+                    break;
+            }
+            pImage = pImage->pNext;
+        }
+
+        if (RT_SUCCESS(rc))
+        {
+            unsigned cImgCur = 0;
+            unsigned uPercentStart = 0;
+            unsigned uPercentSpan = 100 / pDisk->cImages - 1;
+
+            /* Allocate tmp buffer. */
+            void *pvBuf = RTMemTmpAlloc(VD_MERGE_BUFFER_SIZE);
+            if (!pvBuf)
+            {
+                rc = VERR_NO_MEMORY;
+                break;
+            }
+
+            pImage = pDisk->pBase;
+            pDisk->fLocked = true;
+
+            while (   pImage
+                   && RT_SUCCESS(rc))
+            {
+                /* Get size of image. */
+                uint64_t cbSize = vdImageGetSize(pImage);
+                uint64_t cbSizeFile = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
+                uint64_t cbFileWritten = 0;
+                uint64_t uOffset = 0;
+                uint64_t cbRemaining = cbSize;
+
+                do
+                {
+                    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);
+
+                    rc = pImage->Backend->pfnRead(pImage->pBackendData, uOffset,
+                                                  cbThisRead, &IoCtx, &cbThisRead);
+                    if (rc != VERR_VD_BLOCK_FREE)
+                    {
+                        if (RT_FAILURE(rc))
+                            break;
+
+                        /* Apply filter chains. */
+                        rc = vdFilterChainApplyRead(pDisk, uOffset, cbThisRead, &IoCtx);
+                        if (RT_FAILURE(rc))
+                            break;
+
+                        rc = vdFilterChainApplyWrite(pDisk, uOffset, cbThisRead, &IoCtx);
+                        if (RT_FAILURE(rc))
+                            break;
+
+                        RTSgBufReset(&SgBuf);
+                        size_t cbThisWrite = 0;
+                        size_t cbPreRead = 0;
+                        size_t cbPostRead = 0;
+                        rc = pImage->Backend->pfnWrite(pImage->pBackendData, uOffset,
+                                                       cbThisRead, &IoCtx, &cbThisWrite,
+                                                       &cbPreRead, &cbPostRead, 0);
+                        if (RT_FAILURE(rc))
+                            break;
+                        Assert(cbThisWrite == cbThisRead);
+                        cbFileWritten += cbThisWrite;
+                    }
+                    else
+                        rc = VINF_SUCCESS;
+
+                    uOffset += cbThisRead;
+                    cbRemaining -= cbThisRead;
+
+                    if (pIfProgress && pIfProgress->pfnProgress)
+                    {
+                        rc2 = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
+                                                       uPercentStart + cbFileWritten * uPercentSpan / cbSizeFile);
+                        AssertRC(rc2); /* Cancelling this operation without leaving an inconsistent state is not possible. */
+                    }
+                } while (uOffset < cbSize);
+
+                pImage = pImage->pNext;
+                cImgCur++;
+                uPercentStart += uPercentSpan;
+            }
+
+            pDisk->fLocked = false;
+            if (pvBuf)
+                RTMemTmpFree(pvBuf);
+        }
+
+        /* Change images except last one back to readonly. */
+        pImage = pDisk->pBase;
+        while (   pImage != pDisk->pLast
+               && pImage)
+        {
+            uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
+            uOpenFlags |= VD_OPEN_FLAGS_READONLY;
+            rc2 = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
+            if (RT_FAILURE(rc2))
+            {
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+                break;
+            }
+            pImage = pImage->pNext;
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+    else if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    if (   RT_SUCCESS(rc)
+        && pIfProgress
+        && pIfProgress->pfnProgress)
+        pIfProgress->pfnProgress(pIfProgress->Core.pvUser, 100);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDClose(PVDISK pDisk, bool fDelete)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+
+    LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        /* Not worth splitting this up into a read lock phase and write
+         * lock phase, as closing an image is a relatively fast operation
+         * dominated by the part which needs the write lock. */
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        PVDIMAGE pImage = pDisk->pLast;
+        if (!pImage)
+        {
+            rc = VERR_VD_NOT_OPENED;
+            break;
+        }
+
+        /* Destroy the current discard state first which might still have pending blocks. */
+        rc = vdDiscardStateDestroy(pDisk);
+        if (RT_FAILURE(rc))
+            break;
+
+        unsigned uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
+        /* Remove image from list of opened images. */
+        vdRemoveImageFromList(pDisk, pImage);
+        /* Close (and optionally delete) image. */
+        rc = pImage->Backend->pfnClose(pImage->pBackendData, fDelete);
+        /* Free remaining resources related to the image. */
+        RTStrFree(pImage->pszFilename);
+        RTMemFree(pImage);
+
+        pImage = pDisk->pLast;
+        if (!pImage)
+            break;
+
+        /* If disk was previously in read/write mode, make sure it will stay
+         * like this (if possible) after closing this image. Set the open flags
+         * accordingly. */
+        if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
+        {
+            uOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
+            uOpenFlags &= ~ VD_OPEN_FLAGS_READONLY;
+            rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData, uOpenFlags);
+        }
+
+        /* Cache disk information. */
+        pDisk->cbSize = vdImageGetSize(pImage);
+
+        /* Cache PCHS geometry. */
+        rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
+                                                 &pDisk->PCHSGeometry);
+        if (RT_FAILURE(rc2))
+        {
+            pDisk->PCHSGeometry.cCylinders = 0;
+            pDisk->PCHSGeometry.cHeads = 0;
+            pDisk->PCHSGeometry.cSectors = 0;
+        }
+        else
+        {
+            /* Make sure the PCHS geometry is properly clipped. */
+            pDisk->PCHSGeometry.cCylinders = RT_MIN(pDisk->PCHSGeometry.cCylinders, 16383);
+            pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 16);
+            pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
+        }
+
+        /* Cache LCHS geometry. */
+        rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
+                                                  &pDisk->LCHSGeometry);
+        if (RT_FAILURE(rc2))
+        {
+            pDisk->LCHSGeometry.cCylinders = 0;
+            pDisk->LCHSGeometry.cHeads = 0;
+            pDisk->LCHSGeometry.cSectors = 0;
+        }
+        else
+        {
+            /* Make sure the LCHS geometry is properly clipped. */
+            pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
+            pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
+        }
+    } while (0);
+
+    if (RT_UNLIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCacheClose(PVDISK pDisk, bool fDelete)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+    PVDCACHE pCache = NULL;
+
+    LogFlowFunc(("pDisk=%#p fDelete=%d\n", pDisk, fDelete));
+
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        AssertPtrBreakStmt(pDisk->pCache, rc = VERR_VD_CACHE_NOT_FOUND);
+
+        pCache = pDisk->pCache;
+        pDisk->pCache = NULL;
+
+        pCache->Backend->pfnClose(pCache->pBackendData, fDelete);
+        if (pCache->pszFilename)
+            RTStrFree(pCache->pszFilename);
+        RTMemFree(pCache);
+    } while (0);
+
+    if (RT_LIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+VBOXDDU_DECL(int) VDFilterRemove(PVDISK pDisk, uint32_t fFlags)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockWrite = false;
+    PVDFILTER pFilter = NULL;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    do
+    {
+        /* sanity check */
+        AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
+        AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+        AssertMsgBreakStmt(!(fFlags & ~VD_FILTER_FLAGS_MASK),
+                           ("Invalid flags set (fFlags=%#x)\n", fFlags),
+                           rc = VERR_INVALID_PARAMETER);
+
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+        fLockWrite = true;
+
+        if (fFlags & VD_FILTER_FLAGS_WRITE)
+        {
+            AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainWrite), rc = VERR_VD_NOT_OPENED);
+            pFilter = RTListGetLast(&pDisk->ListFilterChainWrite, VDFILTER, ListNodeChainWrite);
+            AssertPtr(pFilter);
+            RTListNodeRemove(&pFilter->ListNodeChainWrite);
+            vdFilterRelease(pFilter);
+        }
+
+        if (fFlags & VD_FILTER_FLAGS_READ)
+        {
+            AssertBreakStmt(!RTListIsEmpty(&pDisk->ListFilterChainRead), rc = VERR_VD_NOT_OPENED);
+            pFilter = RTListGetLast(&pDisk->ListFilterChainRead, VDFILTER, ListNodeChainRead);
+            AssertPtr(pFilter);
+            RTListNodeRemove(&pFilter->ListNodeChainRead);
+            vdFilterRelease(pFilter);
+        }
+    } while (0);
+
+    if (RT_LIKELY(fLockWrite))
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDCloseAll(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Lock the entire operation. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    PVDCACHE pCache = pDisk->pCache;
+    if (pCache)
+    {
+        rc2 = pCache->Backend->pfnClose(pCache->pBackendData, false);
+        if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+            rc = rc2;
+
+        if (pCache->pszFilename)
+            RTStrFree(pCache->pszFilename);
+        RTMemFree(pCache);
+    }
+
+    PVDIMAGE pImage = pDisk->pLast;
+    while (RT_VALID_PTR(pImage))
+    {
+        PVDIMAGE pPrev = pImage->pPrev;
+        /* Remove image from list of opened images. */
+        vdRemoveImageFromList(pDisk, pImage);
+        /* Close image. */
+        rc2 = pImage->Backend->pfnClose(pImage->pBackendData, false);
+        if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
+            rc = rc2;
+        /* Free remaining resources related to the image. */
+        RTStrFree(pImage->pszFilename);
+        RTMemFree(pImage);
+        pImage = pPrev;
+    }
+    Assert(!RT_VALID_PTR(pDisk->pLast));
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDFilterRemoveAll(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Lock the entire operation. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    PVDFILTER pFilter, pFilterNext;
+    RTListForEachSafe(&pDisk->ListFilterChainWrite, pFilter, pFilterNext, VDFILTER, ListNodeChainWrite)
+    {
+        RTListNodeRemove(&pFilter->ListNodeChainWrite);
+        vdFilterRelease(pFilter);
+    }
+
+    RTListForEachSafe(&pDisk->ListFilterChainRead, pFilter, pFilterNext, VDFILTER, ListNodeChainRead)
+    {
+        RTListNodeRemove(&pFilter->ListNodeChainRead);
+        vdFilterRelease(pFilter);
+    }
+    Assert(RTListIsEmpty(&pDisk->ListFilterChainRead));
+    Assert(RTListIsEmpty(&pDisk->ListFilterChainWrite));
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
+    return VINF_SUCCESS;
+}
+
+
+VBOXDDU_DECL(int) VDRead(PVDISK pDisk, uint64_t uOffset, void *pvBuf,
+                         size_t cbRead)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+    bool fLockRead = false;
+
+    LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbRead=%zu\n",
+                 pDisk, uOffset, pvBuf, cbRead));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
+    AssertReturn(cbRead > 0, VERR_INVALID_PARAMETER);
+
+    do
+    {
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+        fLockRead = true;
+
+        AssertMsgBreakStmt(   uOffset < pDisk->cbSize
+                           && cbRead <= pDisk->cbSize - uOffset,
+                           ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
+                            uOffset, cbRead, pDisk->cbSize),
+                           rc = VERR_INVALID_PARAMETER);
+
+        PVDIMAGE pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
+
+        if (uOffset + cbRead > pDisk->cbSize)
+        {
+            /* Floppy images might be smaller than the standard expected by
+               the floppy controller code.  So, we won't fail here. */
+            AssertMsgBreakStmt(pDisk->enmType == VDTYPE_FLOPPY,
+                               ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
+                                uOffset, cbRead, pDisk->cbSize),
+                               rc = VERR_EOF);
+            memset(pvBuf, 0xf6, cbRead); /* f6h = format.com filler byte */
+            if (uOffset >= pDisk->cbSize)
+                break;
+            cbRead = pDisk->cbSize - uOffset;
+        }
+
+        rc = vdReadHelper(pDisk, pImage, uOffset, pvBuf, cbRead,
+                          true /* fUpdateCache */);
+    } while (0);
+
+    if (RT_UNLIKELY(fLockRead))
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDWrite(PVDISK pDisk, uint64_t uOffset, const void *pvBuf,
+                          size_t cbWrite)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+
+    LogFlowFunc(("pDisk=%#p uOffset=%llu pvBuf=%p cbWrite=%zu\n",
+                 pDisk, uOffset, pvBuf, cbWrite));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
+    AssertReturn(cbWrite > 0, VERR_INVALID_PARAMETER);
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        AssertMsgBreakStmt(   uOffset < pDisk->cbSize
+                           && cbWrite <= pDisk->cbSize - uOffset,
+                           ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
+                            uOffset, cbWrite, pDisk->cbSize),
+                           rc = VERR_INVALID_PARAMETER);
+
+        PVDIMAGE pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
+
+        vdSetModifiedFlag(pDisk);
+        rc = vdWriteHelper(pDisk, pImage, uOffset, pvBuf, cbWrite,
+                           VDIOCTX_FLAGS_READ_UPDATE_CACHE);
+        if (RT_FAILURE(rc))
+            break;
+
+        /* If there is a merge (in the direction towards a parent) running
+         * concurrently then we have to also "relay" the write to this parent,
+         * as the merge position might be already past the position where
+         * this write is going. The "context" of the write can come from the
+         * natural chain, since merging either already did or will take care
+         * of the "other" content which is might be needed to fill the block
+         * to a full allocation size. The cache doesn't need to be touched
+         * as this write is covered by the previous one. */
+        if (RT_UNLIKELY(pDisk->pImageRelay))
+            rc = vdWriteHelper(pDisk, pDisk->pImageRelay, uOffset,
+                               pvBuf, cbWrite, VDIOCTX_FLAGS_DEFAULT);
+    } while (0);
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDFlush(PVDISK pDisk)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        PVDIMAGE pImage = pDisk->pLast;
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_NOT_OPENED);
+
+        VDIOCTX IoCtx;
+        RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
+
+        rc = RTSemEventCreate(&hEventComplete);
+        if (RT_FAILURE(rc))
+            break;
+
+        vdIoCtxInit(&IoCtx, pDisk, VDIOCTXTXDIR_FLUSH, 0, 0, pImage, NULL,
+                    NULL, vdFlushHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
+
+        IoCtx.Type.Root.pfnComplete = vdIoCtxSyncComplete;
+        IoCtx.Type.Root.pvUser1     = pDisk;
+        IoCtx.Type.Root.pvUser2     = hEventComplete;
+        rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
+
+        RTSemEventDestroy(hEventComplete);
+    } while (0);
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(unsigned) VDGetCount(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, 0);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    unsigned cImages = pDisk->cImages;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %u\n", cImages));
+    return cImages;
+}
+
+
+VBOXDDU_DECL(bool) VDIsReadOnly(PVDISK pDisk)
+{
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, true);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    bool fReadOnly = true;
+    PVDIMAGE pImage = pDisk->pLast;
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        unsigned uOpenFlags = pDisk->pLast->Backend->pfnGetOpenFlags(pDisk->pLast->pBackendData);
+        fReadOnly = !!(uOpenFlags & VD_OPEN_FLAGS_READONLY);
+    }
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %d\n", fReadOnly));
+    return fReadOnly;
+}
+
+
+VBOXDDU_DECL(uint32_t) VDGetSectorSize(PVDISK pDisk, unsigned nImage)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
+    /* sanity check */
+    AssertPtrReturn(pDisk, 0);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    uint64_t cbSector = 0;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        PCVDREGIONLIST pRegionList = NULL;
+        int rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
+        if (RT_SUCCESS(rc))
+        {
+            AssertMsg(pRegionList->cRegions == 1, ("%u\n", pRegionList->cRegions));
+            if (pRegionList->cRegions == 1)
+            {
+                cbSector = pRegionList->aRegions[0].cbBlock;
+
+                AssertPtr(pImage->Backend->pfnRegionListRelease);
+                pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
+            }
+        }
+    }
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %u\n", cbSector));
+    return cbSector;
+}
+
+
+VBOXDDU_DECL(uint64_t) VDGetSize(PVDISK pDisk, unsigned nImage)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
+    /* sanity check */
+    AssertPtrReturn(pDisk, 0);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    uint64_t cbSize;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        cbSize = vdImageGetSize(pImage);
+    else
+        cbSize = 0;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %llu (%#RX64)\n", cbSize, cbSize));
+    return cbSize;
+}
+
+
+VBOXDDU_DECL(uint64_t) VDGetFileSize(PVDISK pDisk, unsigned nImage)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u\n", pDisk, nImage));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, 0);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    uint64_t cbSize = 0;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        cbSize = pImage->Backend->pfnGetFileSize(pImage->pBackendData);
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %llu (%#RX64)\n", cbSize, cbSize));
+    return cbSize;
+}
+
+
+VBOXDDU_DECL(int) VDGetPCHSGeometry(PVDISK pDisk, unsigned nImage,
+                                    PVDGEOMETRY pPCHSGeometry)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p\n",
+                 pDisk, nImage, pPCHSGeometry));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        if (pImage == pDisk->pLast)
+        {
+            /* Use cached information if possible. */
+            if (pDisk->PCHSGeometry.cCylinders != 0)
+            {
+                *pPCHSGeometry = pDisk->PCHSGeometry;
+                rc = VINF_SUCCESS;
+            }
+            else
+                rc = VERR_VD_GEOMETRY_NOT_SET;
+        }
+        else
+            rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData, pPCHSGeometry);
+    }
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("%Rrc (PCHS=%u/%u/%u)\n", rc,
+                 pDisk->PCHSGeometry.cCylinders, pDisk->PCHSGeometry.cHeads,
+                 pDisk->PCHSGeometry.cSectors));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetPCHSGeometry(PVDISK pDisk, unsigned nImage,
+                                    PCVDGEOMETRY pPCHSGeometry)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+
+    LogFlowFunc(("pDisk=%#p nImage=%u pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
+                 pDisk, nImage, pPCHSGeometry, pPCHSGeometry->cCylinders,
+                 pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
+    AssertMsgReturn(   pPCHSGeometry->cHeads <= 16
+                    && pPCHSGeometry->cSectors <= 63,
+                    ("PCHS=%u/%u/%u\n", pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors),
+                    VERR_INVALID_PARAMETER);
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+        if (pImage == pDisk->pLast)
+        {
+            if (    pPCHSGeometry->cCylinders != pDisk->PCHSGeometry.cCylinders
+                ||  pPCHSGeometry->cHeads != pDisk->PCHSGeometry.cHeads
+                ||  pPCHSGeometry->cSectors != pDisk->PCHSGeometry.cSectors)
+            {
+                /* Only update geometry if it is changed. Avoids similar checks
+                 * in every backend. Most of the time the new geometry is set
+                 * to the previous values, so no need to go through the hassle
+                 * of updating an image which could be opened in read-only mode
+                 * right now. */
+                rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
+                                                         pPCHSGeometry);
+
+                /* Cache new geometry values in any case. */
+                rc2 = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
+                                                          &pDisk->PCHSGeometry);
+                if (RT_FAILURE(rc2))
+                {
+                    pDisk->PCHSGeometry.cCylinders = 0;
+                    pDisk->PCHSGeometry.cHeads = 0;
+                    pDisk->PCHSGeometry.cSectors = 0;
+                }
+                else
+                {
+                    /* Make sure the CHS geometry is properly clipped. */
+                    pDisk->PCHSGeometry.cHeads = RT_MIN(pDisk->PCHSGeometry.cHeads, 255);
+                    pDisk->PCHSGeometry.cSectors = RT_MIN(pDisk->PCHSGeometry.cSectors, 63);
+                }
+            }
+        }
+        else
+        {
+            VDGEOMETRY PCHS;
+            rc = pImage->Backend->pfnGetPCHSGeometry(pImage->pBackendData,
+                                                     &PCHS);
+            if (    RT_FAILURE(rc)
+                ||  pPCHSGeometry->cCylinders != PCHS.cCylinders
+                ||  pPCHSGeometry->cHeads != PCHS.cHeads
+                ||  pPCHSGeometry->cSectors != PCHS.cSectors)
+            {
+                /* Only update geometry if it is changed. Avoids similar checks
+                 * in every backend. Most of the time the new geometry is set
+                 * to the previous values, so no need to go through the hassle
+                 * of updating an image which could be opened in read-only mode
+                 * right now. */
+                rc = pImage->Backend->pfnSetPCHSGeometry(pImage->pBackendData,
+                                                         pPCHSGeometry);
+            }
+        }
+    } while (0);
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetLCHSGeometry(PVDISK pDisk, unsigned nImage,
+                                    PVDGEOMETRY pLCHSGeometry)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p\n",
+                 pDisk, nImage, pLCHSGeometry));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        if (pImage == pDisk->pLast)
+        {
+            /* Use cached information if possible. */
+            if (pDisk->LCHSGeometry.cCylinders != 0)
+                *pLCHSGeometry = pDisk->LCHSGeometry;
+            else
+                rc = VERR_VD_GEOMETRY_NOT_SET;
+        }
+        else
+            rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData, pLCHSGeometry);
+    }
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc((": %Rrc (LCHS=%u/%u/%u)\n", rc,
+                 pDisk->LCHSGeometry.cCylinders, pDisk->LCHSGeometry.cHeads,
+                 pDisk->LCHSGeometry.cSectors));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetLCHSGeometry(PVDISK pDisk, unsigned nImage,
+                                    PCVDGEOMETRY pLCHSGeometry)
+{
+    int rc = VINF_SUCCESS;
+    int rc2;
+
+    LogFlowFunc(("pDisk=%#p nImage=%u pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
+                 pDisk, nImage, pLCHSGeometry, pLCHSGeometry->cCylinders,
+                 pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
+    AssertMsgReturn(   pLCHSGeometry->cHeads <= 255
+                    && pLCHSGeometry->cSectors <= 63,
+                    ("LCHS=%u/%u/%u\n", pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors),
+                    VERR_INVALID_PARAMETER);
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+        AssertPtrBreakStmt(pImage, rc = VERR_VD_IMAGE_NOT_FOUND);
+
+        if (pImage == pDisk->pLast)
+        {
+            if (    pLCHSGeometry->cCylinders != pDisk->LCHSGeometry.cCylinders
+                ||  pLCHSGeometry->cHeads != pDisk->LCHSGeometry.cHeads
+                ||  pLCHSGeometry->cSectors != pDisk->LCHSGeometry.cSectors)
+            {
+                /* Only update geometry if it is changed. Avoids similar checks
+                 * in every backend. Most of the time the new geometry is set
+                 * to the previous values, so no need to go through the hassle
+                 * of updating an image which could be opened in read-only mode
+                 * right now. */
+                rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
+                                                         pLCHSGeometry);
+
+                /* Cache new geometry values in any case. */
+                rc2 = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
+                                                          &pDisk->LCHSGeometry);
+                if (RT_FAILURE(rc2))
+                {
+                    pDisk->LCHSGeometry.cCylinders = 0;
+                    pDisk->LCHSGeometry.cHeads = 0;
+                    pDisk->LCHSGeometry.cSectors = 0;
+                }
+                else
+                {
+                    /* Make sure the CHS geometry is properly clipped. */
+                    pDisk->LCHSGeometry.cHeads = RT_MIN(pDisk->LCHSGeometry.cHeads, 255);
+                    pDisk->LCHSGeometry.cSectors = RT_MIN(pDisk->LCHSGeometry.cSectors, 63);
+                }
+            }
+        }
+        else
+        {
+            VDGEOMETRY LCHS;
+            rc = pImage->Backend->pfnGetLCHSGeometry(pImage->pBackendData,
+                                                     &LCHS);
+            if (    RT_FAILURE(rc)
+                ||  pLCHSGeometry->cCylinders != LCHS.cCylinders
+                ||  pLCHSGeometry->cHeads != LCHS.cHeads
+                ||  pLCHSGeometry->cSectors != LCHS.cSectors)
+            {
+                /* Only update geometry if it is changed. Avoids similar checks
+                 * in every backend. Most of the time the new geometry is set
+                 * to the previous values, so no need to go through the hassle
+                 * of updating an image which could be opened in read-only mode
+                 * right now. */
+                rc = pImage->Backend->pfnSetLCHSGeometry(pImage->pBackendData,
+                                                         pLCHSGeometry);
+            }
+        }
+    } while (0);
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDQueryRegions(PVDISK pDisk, unsigned nImage, uint32_t fFlags,
+                                 PPVDREGIONLIST ppRegionList)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u fFlags=%#x ppRegionList=%#p\n",
+                 pDisk, nImage, fFlags, ppRegionList));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(ppRegionList, VERR_INVALID_POINTER);
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        PCVDREGIONLIST pRegionList = NULL;
+        rc = pImage->Backend->pfnQueryRegions(pImage->pBackendData, &pRegionList);
+        if (RT_SUCCESS(rc))
+        {
+            rc = vdRegionListConv(pRegionList, fFlags, ppRegionList);
+
+            AssertPtr(pImage->Backend->pfnRegionListRelease);
+            pImage->Backend->pfnRegionListRelease(pImage->pBackendData, pRegionList);
+        }
+    }
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc((": %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(void) VDRegionListFree(PVDREGIONLIST pRegionList)
+{
+    RTMemFree(pRegionList);
+}
+
+
+VBOXDDU_DECL(int) VDGetVersion(PVDISK pDisk, unsigned nImage,
+                               unsigned *puVersion)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u puVersion=%#p\n",
+                 pDisk, nImage, puVersion));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(puVersion, VERR_INVALID_POINTER);
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        *puVersion = pImage->Backend->pfnGetVersion(pImage->pBackendData);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc uVersion=%#x\n", rc, *puVersion));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDBackendInfoSingle(PVDISK pDisk, unsigned nImage,
+                                      PVDBACKENDINFO pBackendInfo)
+{
+    int rc = VINF_SUCCESS;
+
+    LogFlowFunc(("pDisk=%#p nImage=%u pBackendInfo=%#p\n",
+                 pDisk, nImage, pBackendInfo));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pBackendInfo, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+    {
+        pBackendInfo->pszBackend = pImage->Backend->pszBackendName;
+        pBackendInfo->uBackendCaps = pImage->Backend->uBackendCaps;
+        pBackendInfo->paFileExtensions = pImage->Backend->paFileExtensions;
+        pBackendInfo->paConfigInfo = pImage->Backend->paConfigInfo;
+    }
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetImageFlags(PVDISK pDisk, unsigned nImage,
+                                  unsigned *puImageFlags)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u puImageFlags=%#p\n",
+                 pDisk, nImage, puImageFlags));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(puImageFlags, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        *puImageFlags = pImage->uImageFlags;
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc uImageFlags=%#x\n", rc, *puImageFlags));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetOpenFlags(PVDISK pDisk, unsigned nImage,
+                                 unsigned *puOpenFlags)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u puOpenFlags=%#p\n",
+                 pDisk, nImage, puOpenFlags));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(puOpenFlags, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc = VINF_SUCCESS;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        *puOpenFlags = pImage->Backend->pfnGetOpenFlags(pImage->pBackendData);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc uOpenFlags=%#x\n", rc, *puOpenFlags));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetOpenFlags(PVDISK pDisk, unsigned nImage,
+                                 unsigned uOpenFlags)
+{
+    LogFlowFunc(("pDisk=%#p uOpenFlags=%#u\n", pDisk, uOpenFlags));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0, ("uOpenFlags=%#x\n", uOpenFlags),
+                    VERR_INVALID_PARAMETER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    /* Destroy any discard state because the image might be changed to readonly mode. */
+    int rc = vdDiscardStateDestroy(pDisk);
+    if (RT_SUCCESS(rc))
+    {
+        PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+        AssertPtr(pImage);
+        if (pImage)
+        {
+            rc = pImage->Backend->pfnSetOpenFlags(pImage->pBackendData,
+                                                  uOpenFlags & ~(VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_IGNORE_FLUSH
+                                                                 | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS));
+            if (RT_SUCCESS(rc))
+                pImage->uOpenFlags = uOpenFlags & (VD_OPEN_FLAGS_HONOR_SAME | VD_OPEN_FLAGS_DISCARD | VD_OPEN_FLAGS_IGNORE_FLUSH
+                                                   | VD_OPEN_FLAGS_INFORM_ABOUT_ZERO_BLOCKS);
+        }
+        else
+            rc = VERR_VD_IMAGE_NOT_FOUND;
+    }
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetFilename(PVDISK pDisk, unsigned nImage,
+                                char *pszFilename, unsigned cbFilename)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pszFilename=%#p cbFilename=%u\n",
+                 pDisk, nImage, pszFilename, cbFilename));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(cbFilename > 0, VERR_INVALID_PARAMETER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    int rc;
+    if (pImage)
+        rc = RTStrCopy(pszFilename, cbFilename, pImage->pszFilename);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc, pszFilename=\"%s\"\n", rc, pszFilename));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetComment(PVDISK pDisk, unsigned nImage,
+                               char *pszComment, unsigned cbComment)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p cbComment=%u\n",
+                 pDisk, nImage, pszComment, cbComment));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pszComment, VERR_INVALID_POINTER);
+    AssertReturn(cbComment > 0, VERR_INVALID_PARAMETER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnGetComment(pImage->pBackendData, pszComment, cbComment);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc, pszComment=\"%s\"\n", rc, pszComment));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetComment(PVDISK pDisk, unsigned nImage,
+                               const char *pszComment)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pszComment=%#p \"%s\"\n",
+                 pDisk, nImage, pszComment, pszComment));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrNullReturn(pszComment, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnSetComment(pImage->pBackendData, pszComment);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnGetUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
+                 pDisk, nImage, pUuid, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    RTUUID Uuid;
+    if (pUuid)
+        AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+    else
+    {
+        int rc = RTUuidCreate(&Uuid);
+        AssertRCReturn(rc, rc);
+        pUuid = &Uuid;
+    }
+
+    /* Do the job. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnSetUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetModificationUuid(PVDISK pDisk, unsigned nImage, PRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnGetModificationUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetModificationUuid(PVDISK pDisk, unsigned nImage, PCRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
+                 pDisk, nImage, pUuid, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    RTUUID Uuid;
+    if (pUuid)
+        AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+    else
+    {
+        int rc = RTUuidCreate(&Uuid);
+        AssertRCReturn(rc, rc);
+        pUuid = &Uuid;
+    }
+
+    /* Do the job. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    if (pImage)
+        rc = pImage->Backend->pfnSetModificationUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDGetParentUuid(PVDISK pDisk, unsigned nImage,
+                                  PRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p\n", pDisk, nImage, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+
+    /* Do the job. */
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnGetParentUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc, Uuid={%RTuuid}\n", rc, pUuid));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDSetParentUuid(PVDISK pDisk, unsigned nImage,
+                                  PCRTUUID pUuid)
+{
+    LogFlowFunc(("pDisk=%#p nImage=%u pUuid=%#p {%RTuuid}\n",
+                 pDisk, nImage, pUuid, pUuid));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    RTUUID Uuid;
+    if (pUuid)
+        AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
+    else
+    {
+        int rc = RTUuidCreate(&Uuid);
+        AssertRCReturn(rc, rc);
+        pUuid = &Uuid;
+    }
+
+    /* Do the job. */
+    int rc2 = vdThreadStartWrite(pDisk);
+    AssertRC(rc2);
+
+    int rc;
+    PVDIMAGE pImage = vdGetImageByNumber(pDisk, nImage);
+    AssertPtr(pImage);
+    if (pImage)
+        rc = pImage->Backend->pfnSetParentUuid(pImage->pBackendData, pUuid);
+    else
+        rc = VERR_VD_IMAGE_NOT_FOUND;
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(void) VDDumpImages(PVDISK pDisk)
+{
+    /* sanity check */
+    AssertPtrReturnVoid(pDisk);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    AssertPtrReturnVoid(pDisk->pInterfaceError);
+    if (!RT_VALID_PTR(pDisk->pInterfaceError->pfnMessage))
+        pDisk->pInterfaceError->pfnMessage = vdLogMessage;
+
+    int rc2 = vdThreadStartRead(pDisk);
+    AssertRC(rc2);
+
+    vdMessageWrapper(pDisk, "--- Dumping VD Disk, Images=%u\n", pDisk->cImages);
+    for (PVDIMAGE pImage = pDisk->pBase; pImage; pImage = pImage->pNext)
+    {
+        vdMessageWrapper(pDisk, "Dumping VD image \"%s\" (Backend=%s)\n",
+                         pImage->pszFilename, pImage->Backend->pszBackendName);
+        pImage->Backend->pfnDump(pImage->pBackendData);
+    }
+
+    rc2 = vdThreadFinishRead(pDisk);
+    AssertRC(rc2);
+}
+
+
+VBOXDDU_DECL(int) VDDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges)
+{
+    int rc;
+    int rc2;
+
+    LogFlowFunc(("pDisk=%#p paRanges=%#p cRanges=%u\n",
+                 pDisk, paRanges, cRanges));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertReturn(cRanges > 0, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(paRanges, VERR_INVALID_POINTER);
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        AssertMsgBreakStmt(pDisk->pLast->uOpenFlags & VD_OPEN_FLAGS_DISCARD,
+                           ("Discarding not supported\n"),
+                           rc = VERR_NOT_SUPPORTED);
+
+        VDIOCTX IoCtx;
+        RTSEMEVENT hEventComplete = NIL_RTSEMEVENT;
+
+        rc = RTSemEventCreate(&hEventComplete);
+        if (RT_FAILURE(rc))
+            break;
+
+        vdIoCtxDiscardInit(&IoCtx, pDisk, paRanges, cRanges,
+                           vdIoCtxSyncComplete, pDisk, hEventComplete, NULL,
+                           vdDiscardHelperAsync, VDIOCTX_FLAGS_SYNC | VDIOCTX_FLAGS_DONT_FREE);
+        rc = vdIoCtxProcessSync(&IoCtx, hEventComplete);
+
+        RTSemEventDestroy(hEventComplete);
+    } while (0);
+
+    rc2 = vdThreadFinishWrite(pDisk);
+    AssertRC(rc2);
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDAsyncRead(PVDISK pDisk, uint64_t uOffset, size_t cbRead,
+                              PCRTSGBUF pSgBuf,
+                              PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                              void *pvUser1, void *pvUser2)
+{
+    int rc = VERR_VD_BLOCK_FREE;
+    int rc2;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p uOffset=%llu pSgBuf=%#p cbRead=%zu pvUser1=%#p pvUser2=%#p\n",
+                 pDisk, uOffset, pSgBuf, cbRead, pvUser1, pvUser2));
+
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertReturn(cbRead > 0, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pSgBuf, VERR_INVALID_POINTER);
+
+    do
+    {
+        rc2 = vdThreadStartRead(pDisk);
+        AssertRC(rc2);
+
+        AssertMsgBreakStmt(   uOffset < pDisk->cbSize
+                           && cbRead <= pDisk->cbSize - uOffset,
+                           ("uOffset=%llu cbRead=%zu pDisk->cbSize=%llu\n",
+                            uOffset, cbRead, pDisk->cbSize),
+                           rc = VERR_INVALID_PARAMETER);
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_READ, uOffset,
+                                  cbRead, pDisk->pLast, pSgBuf,
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL, vdReadHelperAsync,
+                                  VDIOCTX_FLAGS_ZERO_FREE_BLOCKS);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdIoCtxProcessTryLockDefer(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 (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        rc2 = vdThreadFinishRead(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDAsyncWrite(PVDISK pDisk, uint64_t uOffset, size_t cbWrite,
+                               PCRTSGBUF pSgBuf,
+                               PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                               void *pvUser1, void *pvUser2)
+{
+    int rc;
+    int rc2;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p uOffset=%llu pSgBuf=%#p cbWrite=%zu pvUser1=%#p pvUser2=%#p\n",
+                 pDisk, uOffset, pSgBuf, cbWrite, pvUser1, pvUser2));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    /* Check arguments. */
+    AssertReturn(cbWrite > 0, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pSgBuf, VERR_INVALID_POINTER);
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        AssertMsgBreakStmt(   uOffset < pDisk->cbSize
+                           && cbWrite <= pDisk->cbSize - uOffset,
+                           ("uOffset=%llu cbWrite=%zu pDisk->cbSize=%llu\n",
+                            uOffset, cbWrite, pDisk->cbSize),
+                           rc = VERR_INVALID_PARAMETER);
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_WRITE, uOffset,
+                                  cbWrite, pDisk->pLast, pSgBuf,
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL, vdWriteHelperAsync,
+                                  VDIOCTX_FLAGS_DEFAULT);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdIoCtxProcessTryLockDefer(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 (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+VBOXDDU_DECL(int) VDAsyncFlush(PVDISK pDisk, PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                               void *pvUser1, void *pvUser2)
+{
+    int rc;
+    int rc2;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        pIoCtx = vdIoCtxRootAlloc(pDisk, VDIOCTXTXDIR_FLUSH, 0,
+                                  0, pDisk->pLast, NULL,
+                                  pfnComplete, pvUser1, pvUser2,
+                                  NULL, vdFlushHelperAsync,
+                                  VDIOCTX_FLAGS_DEFAULT);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdIoCtxProcessTryLockDefer(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 (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+VBOXDDU_DECL(int) VDAsyncDiscardRanges(PVDISK pDisk, PCRTRANGE paRanges, unsigned cRanges,
+                                       PFNVDASYNCTRANSFERCOMPLETE pfnComplete,
+                                       void *pvUser1, void *pvUser2)
+{
+    int rc;
+    int rc2;
+    PVDIOCTX pIoCtx = NULL;
+
+    LogFlowFunc(("pDisk=%#p\n", pDisk));
+    /* sanity check */
+    AssertPtrReturn(pDisk, VERR_INVALID_POINTER);
+    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
+
+    do
+    {
+        rc2 = vdThreadStartWrite(pDisk);
+        AssertRC(rc2);
+
+        AssertPtrBreakStmt(pDisk->pLast, rc = VERR_VD_NOT_OPENED);
+
+        pIoCtx = vdIoCtxDiscardAlloc(pDisk, paRanges, cRanges,
+                                     pfnComplete, pvUser1, pvUser2, NULL,
+                                     vdDiscardHelperAsync,
+                                     VDIOCTX_FLAGS_DEFAULT);
+        if (!pIoCtx)
+        {
+            rc = VERR_NO_MEMORY;
+            break;
+        }
+
+        rc = vdIoCtxProcessTryLockDefer(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 (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
+    {
+        rc2 = vdThreadFinishWrite(pDisk);
+        AssertRC(rc2);
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+VBOXDDU_DECL(int) VDRepair(PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
+                           const char *pszFilename, const char *pszBackend,
+                           uint32_t fFlags)
+{
+    int rc = VERR_NOT_SUPPORTED;
+    PCVDIMAGEBACKEND pBackend = NULL;
+    VDINTERFACEIOINT VDIfIoInt;
+    VDINTERFACEIO    VDIfIoFallback;
+    PVDINTERFACEIO   pInterfaceIo;
+
+    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
+    /* Check arguments. */
+    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
+    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
+    AssertMsgReturn((fFlags & ~VD_REPAIR_FLAGS_MASK) == 0, ("fFlags=%#x\n", fFlags),
+                    VERR_INVALID_PARAMETER);
+
+    pInterfaceIo = VDIfIoGet(pVDIfsImage);
+    if (!pInterfaceIo)
+    {
+        /*
+         * Caller doesn't provide an I/O interface, create our own using the
+         * native file API.
+         */
+        vdIfIoFallbackCallbacksSetup(&VDIfIoFallback);
+        pInterfaceIo = &VDIfIoFallback;
+    }
+
+    /* Set up the internal I/O interface. */
+    AssertReturn(!VDIfIoIntGet(pVDIfsImage), VERR_INVALID_PARAMETER);
+    VDIfIoInt.pfnOpen                   = vdIOIntOpenLimited;
+    VDIfIoInt.pfnClose                  = vdIOIntCloseLimited;
+    VDIfIoInt.pfnDelete                 = vdIOIntDeleteLimited;
+    VDIfIoInt.pfnMove                   = vdIOIntMoveLimited;
+    VDIfIoInt.pfnGetFreeSpace           = vdIOIntGetFreeSpaceLimited;
+    VDIfIoInt.pfnGetModificationTime    = vdIOIntGetModificationTimeLimited;
+    VDIfIoInt.pfnGetSize                = vdIOIntGetSizeLimited;
+    VDIfIoInt.pfnSetSize                = vdIOIntSetSizeLimited;
+    VDIfIoInt.pfnReadUser               = vdIOIntReadUserLimited;
+    VDIfIoInt.pfnWriteUser              = vdIOIntWriteUserLimited;
+    VDIfIoInt.pfnReadMeta               = vdIOIntReadMetaLimited;
+    VDIfIoInt.pfnWriteMeta              = vdIOIntWriteMetaLimited;
+    VDIfIoInt.pfnFlush                  = vdIOIntFlushLimited;
+    rc = VDInterfaceAdd(&VDIfIoInt.Core, "VD_IOINT", VDINTERFACETYPE_IOINT,
+                        pInterfaceIo, sizeof(VDINTERFACEIOINT), &pVDIfsImage);
+    AssertRC(rc);
+
+    rc = vdFindImageBackend(pszBackend, &pBackend);
+    if (RT_SUCCESS(rc))
+    {
+        if (pBackend->pfnRepair)
+            rc = pBackend->pfnRepair(pszFilename, pVDIfsDisk, pVDIfsImage, fFlags);
+        else
+            rc = VERR_VD_IMAGE_REPAIR_NOT_SUPPORTED;
+    }
+
+    LogFlowFunc(("returns %Rrc\n", rc));
+    return rc;
+}
+
+
+/*
+ * generic plugin functions
+ */
+
+/**
+ * @interface_method_impl{VDIMAGEBACKEND,pfnComposeLocation}
+ */
+DECLCALLBACK(int) genericFileComposeLocation(PVDINTERFACE pConfig, char **pszLocation)
+{
+    RT_NOREF1(pConfig);
+    *pszLocation = NULL;
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{VDIMAGEBACKEND,pfnComposeName}
+ */
+DECLCALLBACK(int) genericFileComposeName(PVDINTERFACE pConfig, char **pszName)
+{
+    RT_NOREF1(pConfig);
+    *pszName = NULL;
+    return VINF_SUCCESS;
+}
+