/* $Id: VCICache.cpp 33745 2010-11-03 18:31:53Z vboxsync $ */
/** @file
 * VCICacheCore - VirtualBox Cache Image, Core Code.
 */

/*
 * Copyright (C) 2006-2010 Oracle Corporation
 *
 * This file is part of VirtualBox Open Source Edition (OSE), as
 * available from http://www.virtualbox.org. This file is free software;
 * you can redistribute it and/or modify it under the terms of the GNU
 * General Public License (GPL) as published by the Free Software
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 */

/*******************************************************************************
*   Header Files                                                               *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_VD_RAW /** @todo logging group */
#include <VBox/vd-cache-plugin.h>
#include <VBox/err.h>

#include <VBox/log.h>
#include <iprt/assert.h>
#include <iprt/alloc.h>
#include <iprt/file.h>
#include <iprt/asm.h>

/*******************************************************************************
* On disk data structures                                                      *
*******************************************************************************/

/** @note All structures which are written to the disk are written in camel case
 * and packed. */

/** Block size used internally, because we cache sectors the smallest unit we
 * have to care about is 512 bytes. */
#define VCI_BLOCK_SIZE             512

/** Convert block number/size to byte offset/size. */
#define VCI_BLOCK2BYTE(u)          ((uint64_t)(u) << 9)

/** Convert byte offset/size to block number/size. */
#define VCI_BYTE2BLOCK(u)          ((u) >> 9)

/**
 * The VCI header - at the beginning of the file.
 *
 * All entries a stored in little endian order.
 */
#pragma pack(1)
typedef struct VciHdr
{
    /** The signature to identify a cache image. */
    uint32_t    u32Signature;
    /** Version of the layout of metadata in the cache. */
    uint32_t    u32Version;
    /** Maximum size of the cache file in blocks.
     *  This includes all metadata. */
    uint64_t    cBlocksCache;
    /** Flag indicating whether the cache was closed cleanly. */
    uint8_t     fUncleanShutdown;
    /** Cache type. */
    uint32_t    u32CacheType;
    /** Offset of the B+-Tree root in the image in blocks. */
    uint64_t    offTreeRoot;
    /** Offset of the block allocation bitmap in blocks. */
    uint64_t    offBlkMap;
    /** Size of the block allocation bitmap in blocks. */
    uint32_t    cBlkMap;
    /** UUID of the image. */
    RTUUID      uuidImage;
    /** Modification UUID for the cache. */
    RTUUID      uuidModification;
    /** Reserved for future use. */
    uint8_t     abReserved[951];
} VciHdr, *PVciHdr;
#pragma pack()
AssertCompileSize(VciHdr, 2 * VCI_BLOCK_SIZE);

/** VCI signature to identify a valid image. */
#define VCI_HDR_SIGNATURE          UINT32_C(0x00494356) /* \0ICV */
/** Current version we support. */
#define VCI_HDR_VERSION            UINT32_C(0x00000001)

/** Value for an unclean cache shutdown. */
#define VCI_HDR_UNCLEAN_SHUTDOWN   UINT8_C(0x01)
/** Value for a clean cache shutdown. */
#define VCI_HDR_CLEAN_SHUTDOWN     UINT8_C(0x00)

/** Cache type: Dynamic image growing to the maximum value. */
#define VCI_HDR_CACHE_TYPE_DYNAMIC UINT32_C(0x00000001)
/** Cache type: Fixed image, space is preallocated. */
#define VCI_HDR_CACHE_TYPE_FIXED   UINT32_C(0x00000002)

/**
 * On disk representation of an extent describing a range of cached data.
 *
 * All entries a stored in little endian order.
 */
#pragma pack(1)
typedef struct VciCacheExtent
{
    /** Block address of the previous extent in the LRU list. */
    uint64_t    u64ExtentPrev;
    /** Block address of the next extent in the LRU list. */
    uint64_t    u64ExtentNext;
    /** Flags (for compression, encryption etc.) - currently unused and should be always 0. */
    uint8_t     u8Flags;
    /** Reserved */
    uint8_t     u8Reserved;
    /** First block of cached data the extent represents. */
    uint64_t    u64BlockOffset;
    /** Number of blocks the extent represents. */
    uint32_t    u32Blocks;
    /** First block in the image where the data is stored. */
    uint64_t    u64BlockAddr;
} VciCacheExtent, *PVciCacheExtent;
#pragma pack()
AssertCompileSize(VciCacheExtent, 38);

/**
 * On disk representation of an internal node.
 *
 * All entries a stored in little endian order.
 */
#pragma pack(1)
typedef struct VciTreeNodeInternal
{
    /** First block of cached data the internal node represents. */
    uint64_t    u64BlockOffset;
    /** Number of blocks the internal node represents. */
    uint32_t    u32Blocks;
    /** Block address in the image where the next node in the tree is stored. */
    uint64_t    u64ChildAddr;
} VciTreeNodeInternal, *PVciTreeNodeInternal;
#pragma pack()
AssertCompileSize(VciTreeNodeInternal, 20);

/**
 * On-disk representation of a node in the B+-Tree.
 *
 * All entries a stored in little endian order.
 */
#pragma pack(1)
typedef struct VciTreeNode
{
    /** Type of the node (root, internal, leaf). */
    uint8_t     u8Type;
    /** Data in the node. */
    uint8_t     au8Data[4095];
} VciTreeNode, *PVciTreeNode;
#pragma pack()
AssertCompileSize(VciTreeNode, 8 * VCI_BLOCK_SIZE);

/** Node type: Internal node containing links to other nodes (VciTreeNodeInternal). */
#define VCI_TREE_NODE_TYPE_INTERNAL UINT8_C(0x01)
/** Node type: Leaf of the tree (VciCacheExtent). */
#define VCI_TREE_NODE_TYPE_LEAF     UINT8_C(0x02)

/** Number of cache extents described by one node. */
#define VCI_TREE_EXTENTS_PER_NODE        ((sizeof(VciTreeNode)-1) / sizeof(VciCacheExtent))
/** Number of internal nodes managed by one tree node. */
#define VCI_TREE_INTERNAL_NODES_PER_NODE ((sizeof(VciTreeNode)-1) / sizeof(VciTreeNodeInternal))

/**
 * VCI block bitmap header.
 *
 * All entries a stored in little endian order.
 */
#pragma pack(1)
typedef struct VciBlkMap
{
    /** Magic of the block bitmap. */
    uint32_t     u32Magic;
    /** Version of the block bitmap. */
    uint32_t     u32Version;
    /** Number of blocks this block map manages. */
    uint64_t     cBlocks;
    /** Number of free blocks. */
    uint64_t     cBlocksFree;
    /** Number of blocks allocated for metadata. */
    uint64_t     cBlocksAllocMeta;
    /** Number of blocks allocated for actual cached data. */
    uint64_t     cBlocksAllocData;
    /** Reserved for future use. */
    uint8_t      au8Reserved[472];
} VciBlkMap, *PVciBlkMap;
#pragma pack()
AssertCompileSize(VciBlkMap, VCI_BLOCK_SIZE);

/** The magic which identifies a block map. */
#define VCI_BLKMAP_MAGIC   UINT32_C(0x4b4c4256) /* KLBV */
/** Current version. */
#define VCI_BLKMAP_VERSION UINT32_C(0x00000001)

/** Block bitmap entry */
typedef uint8_t VciBlkMapEnt;

/*******************************************************************************
*   Constants And Macros, Structures and Typedefs                              *
*******************************************************************************/

/**
 * Block range descriptor.
 */
typedef struct VCIBLKRANGEDESC
{
    /** Previous entry in the list. */
    struct VCIBLKRANGEDESC    *pPrev;
    /** Next entry in the list. */
    struct VCIBLKRANGEDESC    *pNext;
    /** Start address of the range. */
    uint64_t                   offAddrStart;
    /** Number of blocks in the range. */
    uint64_t                   cBlocks;
    /** Flag whether the range is free or allocated. */
    bool                       fFree;
} VCIBLKRANGEDESC, *PVCIBLKRANGEDESC;

/**
 * Block map for the cache image - in memory structure.
 */
typedef struct VCIBLKMAP
{
    /** Number of blocks the map manages. */
    uint64_t     cBlocks;
    /** Number of blocks allocated for metadata. */
    uint64_t     cBlocksAllocMeta;
    /** Number of blocks allocated for actual cached data. */
    uint64_t     cBlocksAllocData;
    /** Number of free blocks. */
    uint64_t     cBlocksFree;

    /** Pointer to the head of the block range list. */
    PVCIBLKRANGEDESC pRangesHead;
    /** Pointer to the tail of the block range list. */
    PVCIBLKRANGEDESC pRangesTail;

} VCIBLKMAP;
/** Pointer to a block map. */
typedef VCIBLKMAP *PVCIBLKMAP;

/**
 * B+-Tree node header.
 */
typedef struct VCITREENODE
{
    /** Type of the node (VCI_TREE_NODE_TYPE_*). */
    uint8_t             u8Type;
    /** Block address where the node is stored. */
    uint64_t            u64BlockAddr;
    /** Pointer to the parent. */
    struct VCITREENODE *pParent;
} VCITREENODE, *PVCITREENODE;

/**
 * B+-Tree node pointer.
 */
typedef struct VCITREENODEPTR
{
    /** Flag whether the node is in memory or still on the disk. */
    bool         fInMemory;
    /** Type dependent data. */
    union
    {
        /** Pointer to a in memory node. */
        PVCITREENODE pNode;
        /** Start block address of the node. */
        uint64_t     offAddrBlockNode;
    } u;
} VCITREENODEPTR, *PVCITREENODEPTR;

/**
 * Internal node.
 */
typedef struct VCINODEINTERNAL
{
    /** First block of cached data the internal node represents. */
    uint64_t       u64BlockOffset;
    /** Number of blocks the internal node represents. */
    uint32_t       u32Blocks;
    /** Pointer to the child node. */
    VCITREENODEPTR PtrChild;
} VCINODEINTERNAL, *PVCINODEINTERNAL;

/**
 * A in memory internal B+-tree node.
 */
typedef struct VCITREENODEINT
{
    /** Node core. */
    VCITREENODE     Core;
    /** Number of used nodes. */
    unsigned        cUsedNodes;
    /** Array of internal nodes. */
    VCINODEINTERNAL aIntNodes[VCI_TREE_INTERNAL_NODES_PER_NODE];
} VCITREENODEINT, *PVCITREENODEINT;

/**
 * A in memory cache extent.
 */
typedef struct VCICACHEEXTENT
{
    /** First block of cached data the extent represents. */
    uint64_t    u64BlockOffset;
    /** Number of blocks the extent represents. */
    uint32_t    u32Blocks;
    /** First block in the image where the data is stored. */
    uint64_t    u64BlockAddr;
} VCICACHEEXTENT, *PVCICACHEEXTENT;

/**
 * A in memory leaf B+-tree node.
 */
typedef struct VCITREENODELEAF
{
    /** Node core. */
    VCITREENODE    Core;
    /** Number of used nodes. */
    unsigned       cUsedNodes;
    /** The extents in the node. */
    VCICACHEEXTENT aExtents[VCI_TREE_EXTENTS_PER_NODE];
} VCITREENODELEAF, *PVCITREENODELEAF;

/**
 * VCI image data structure.
 */
typedef struct VCICACHE
{
    /** Image name. */
    const char       *pszFilename;
    /** Storage handle. */
    PVDIOSTORAGE      pStorage;
    /** I/O interface. */
    PVDINTERFACE      pInterfaceIO;
    /** Async I/O interface callbacks. */
    PVDINTERFACEIOINT pInterfaceIOCallbacks;

    /** Pointer to the per-disk VD interface list. */
    PVDINTERFACE      pVDIfsDisk;
    /** Pointer to the per-image VD interface list. */
    PVDINTERFACE      pVDIfsImage;

    /** Error callback. */
    PVDINTERFACE      pInterfaceError;
    /** Opaque data for error callback. */
    PVDINTERFACEERROR pInterfaceErrorCallbacks;

    /** Open flags passed by VBoxHD layer. */
    unsigned          uOpenFlags;
    /** Image flags defined during creation or determined during open. */
    unsigned          uImageFlags;
    /** Total size of the image. */
    uint64_t          cbSize;

    /** Offset of the B+-Tree in the image in bytes. */
    uint64_t          offTreeRoot;
    /** Pointer to the root node of the B+-Tree. */
    PVCITREENODE      pRoot;
    /** Offset to the block allocation bitmap in bytes. */
    uint64_t          offBlksBitmap;
    /** Block map. */
    PVCIBLKMAP        pBlkMap;
} VCICACHE, *PVCICACHE;

/** No block free in bitmap error code. */
#define VERR_VCI_NO_BLOCKS_FREE (-65536)

/*******************************************************************************
*   Static Variables                                                           *
*******************************************************************************/

/** NULL-terminated array of supported file extensions. */
static const char *const s_apszVciFileExtensions[] =
{
    "vci",
    NULL
};

/*******************************************************************************
*   Internal Functions                                                         *
*******************************************************************************/

/**
 * Internal: signal an error to the frontend.
 */
DECLINLINE(int) vciError(PVCICACHE pCache, int rc, RT_SRC_POS_DECL,
                         const char *pszFormat, ...)
{
    va_list va;
    va_start(va, pszFormat);
    if (pCache->pInterfaceError)
        pCache->pInterfaceErrorCallbacks->pfnError(pCache->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS,
                                                   pszFormat, va);
    va_end(va);
    return rc;
}

/**
 * Internal: signal an informational message to the frontend.
 */
DECLINLINE(int) vciMessage(PVCICACHE pCache, const char *pszFormat, ...)
{
    int rc = VINF_SUCCESS;
    va_list va;
    va_start(va, pszFormat);
    if (pCache->pInterfaceError)
        rc = pCache->pInterfaceErrorCallbacks->pfnMessage(pCache->pInterfaceError->pvUser,
                                                          pszFormat, va);
    va_end(va);
    return rc;
}


DECLINLINE(int) vciFileOpen(PVCICACHE pCache, const char *pszFilename,
                            uint32_t fOpen)
{
    return pCache->pInterfaceIOCallbacks->pfnOpen(pCache->pInterfaceIO->pvUser,
                                                  pszFilename, fOpen,
                                                  &pCache->pStorage);
}

DECLINLINE(int) vciFileClose(PVCICACHE pCache)
{
    return pCache->pInterfaceIOCallbacks->pfnClose(pCache->pInterfaceIO->pvUser,
                                                   pCache->pStorage);
}

DECLINLINE(int) vciFileDelete(PVCICACHE pCache, const char *pszFilename)
{
    return pCache->pInterfaceIOCallbacks->pfnDelete(pCache->pInterfaceIO->pvUser,
                                                    pszFilename);
}

DECLINLINE(int) vciFileMove(PVCICACHE pCache, const char *pszSrc,
                            const char *pszDst, unsigned fMove)
{
    return pCache->pInterfaceIOCallbacks->pfnMove(pCache->pInterfaceIO->pvUser,
                                                  pszSrc, pszDst, fMove);
}

DECLINLINE(int) vciFileGetFreeSpace(PVCICACHE pCache, const char *pszFilename,
                                    int64_t *pcbFree)
{
    return pCache->pInterfaceIOCallbacks->pfnGetFreeSpace(pCache->pInterfaceIO->pvUser,
                                                          pszFilename, pcbFree);
}

DECLINLINE(int) vciFileGetSize(PVCICACHE pCache, uint64_t *pcbSize)
{
    return pCache->pInterfaceIOCallbacks->pfnGetSize(pCache->pInterfaceIO->pvUser,
                                                     pCache->pStorage, pcbSize);
}

DECLINLINE(int) vciFileSetSize(PVCICACHE pCache, uint64_t cbSize)
{
    return pCache->pInterfaceIOCallbacks->pfnSetSize(pCache->pInterfaceIO->pvUser,
                                                     pCache->pStorage, cbSize);
}

DECLINLINE(int) vciFileWriteSync(PVCICACHE pCache, uint64_t uOffset,
                                 const void *pvBuffer, size_t cbBuffer)
{
    return pCache->pInterfaceIOCallbacks->pfnWriteSync(pCache->pInterfaceIO->pvUser,
                                                       pCache->pStorage, VCI_BLOCK2BYTE(uOffset),
                                                       pvBuffer, VCI_BLOCK2BYTE(cbBuffer), NULL);
}

DECLINLINE(int) vciFileReadSync(PVCICACHE pCache, uint64_t uOffset,
                                void *pvBuffer, size_t cbBuffer)
{
    return pCache->pInterfaceIOCallbacks->pfnReadSync(pCache->pInterfaceIO->pvUser,
                                                      pCache->pStorage, VCI_BLOCK2BYTE(uOffset),
                                                      pvBuffer, VCI_BLOCK2BYTE(cbBuffer), NULL);
}

DECLINLINE(int) vciFileFlushSync(PVCICACHE pCache)
{
    return pCache->pInterfaceIOCallbacks->pfnFlushSync(pCache->pInterfaceIO->pvUser,
                                                       pCache->pStorage);
}

DECLINLINE(int) vciFileReadUserAsync(PVCICACHE pCache, uint64_t uOffset,
                                     PVDIOCTX pIoCtx, size_t cbRead)
{
    return pCache->pInterfaceIOCallbacks->pfnReadUserAsync(pCache->pInterfaceIO->pvUser,
                                                           pCache->pStorage,
                                                           uOffset, pIoCtx,
                                                           cbRead);
}

DECLINLINE(int) vciFileWriteUserAsync(PVCICACHE pCache, uint64_t uOffset,
                                      PVDIOCTX pIoCtx, size_t cbWrite,
                                      PFNVDXFERCOMPLETED pfnComplete,
                                      void *pvCompleteUser)
{
    return pCache->pInterfaceIOCallbacks->pfnWriteUserAsync(pCache->pInterfaceIO->pvUser,
                                                            pCache->pStorage,
                                                            uOffset, pIoCtx,
                                                            cbWrite,
                                                            pfnComplete,
                                                            pvCompleteUser);
}

DECLINLINE(int) vciFileFlushAsync(PVCICACHE pCache, PVDIOCTX pIoCtx,
                                  PFNVDXFERCOMPLETED pfnComplete,
                                  void *pvCompleteUser)
{
    return pCache->pInterfaceIOCallbacks->pfnFlushAsync(pCache->pInterfaceIO->pvUser,
                                                        pCache->pStorage,
                                                        pIoCtx, pfnComplete,
                                                        pvCompleteUser);
}

/**
 * Internal. Flush image data to disk.
 */
static int vciFlushImage(PVCICACHE pCache)
{
    int rc = VINF_SUCCESS;

    if (   pCache->pStorage
        && !(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
        rc = vciFileFlushSync(pCache);

    return rc;
}

/**
 * Internal. Free all allocated space for representing an image except pCache,
 * and optionally delete the image from disk.
 */
static int vciFreeImage(PVCICACHE pCache, bool fDelete)
{
    int rc = VINF_SUCCESS;

    /* Freeing a never allocated image (e.g. because the open failed) is
     * not signalled as an error. After all nothing bad happens. */
    if (pCache)
    {
        if (pCache->pStorage)
        {
            /* No point updating the file that is deleted anyway. */
            if (!fDelete)
                vciFlushImage(pCache);

            vciFileClose(pCache);
            pCache->pStorage = NULL;
        }

        if (fDelete && pCache->pszFilename)
            vciFileDelete(pCache, pCache->pszFilename);
    }

    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/**
 * Creates a new block map which can manage the given number of blocks.
 *
 * The size of the bitmap is aligned to the VCI block size.
 *
 * @returns VBox status code.
 * @param   cBlocks      The number of blocks the bitmap can manage.
 * @param   ppBlkMap     Where to store the pointer to the block bitmap.
 * @param   pcbBlkMap    Where to store the size of the block bitmap in blocks
 *                       needed on the disk.
 */
static int vciBlkMapCreate(uint64_t cBlocks, PVCIBLKMAP *ppBlkMap, uint32_t *pcBlkMap)
{
    int rc = VINF_SUCCESS;
    uint32_t cbBlkMap = RT_ALIGN_Z(cBlocks / sizeof(VciBlkMapEnt) / 8, VCI_BLOCK_SIZE);
    PVCIBLKMAP pBlkMap = (PVCIBLKMAP)RTMemAllocZ(sizeof(VCIBLKMAP));
    PVCIBLKRANGEDESC pFree   = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));

    LogFlowFunc(("cBlocks=%u ppBlkMap=%#p pcBlkMap=%#p\n", cBlocks, ppBlkMap, pcBlkMap));

    if (pBlkMap && pFree)
    {
        pBlkMap->cBlocks          = cBlocks;
        pBlkMap->cBlocksAllocMeta = 0;
        pBlkMap->cBlocksAllocData = 0;
        pBlkMap->cBlocksFree      = cBlocks;

        pFree->pPrev = NULL;
        pFree->pNext = NULL;
        pFree->offAddrStart = 0;
        pFree->cBlocks      = cBlocks;
        pFree->fFree        = true;

        pBlkMap->pRangesHead = pFree;
        pBlkMap->pRangesTail = pFree;

        Assert(!((cbBlkMap + sizeof(VciBlkMap)) % VCI_BLOCK_SIZE));
        *ppBlkMap = pBlkMap;
        *pcBlkMap = VCI_BYTE2BLOCK(cbBlkMap + sizeof(VciBlkMap));
    }
    else
    {
        if (pBlkMap)
            RTMemFree(pBlkMap);
        if (pFree)
            RTMemFree(pFree);

        rc = VERR_NO_MEMORY;
    }

    LogFlowFunc(("returns rc=%Rrc cBlkMap=%u\n", rc, *pcBlkMap));
    return rc;
}

/**
 * Frees a block map.
 *
 * @returns nothing.
 * @param   pBlkMap         The block bitmap to destroy.
 */
static void vciBlkMapDestroy(PVCIBLKMAP pBlkMap)
{
    LogFlowFunc(("pBlkMap=%#p\n", pBlkMap));

    PVCIBLKRANGEDESC pRangeCur = pBlkMap->pRangesHead;

    while (pRangeCur)
    {
        PVCIBLKRANGEDESC pTmp = pRangeCur;

        RTMemFree(pTmp);

        pRangeCur = pRangeCur->pNext;
    }

    RTMemFree(pBlkMap);

    LogFlowFunc(("returns\n"));
}

/**
 * Loads the block map from the specified medium and creates all necessary
 * in memory structures to manage used and free blocks.
 *
 * @returns VBox status code.
 * @param   pStorage        Storage handle to read the block bitmap from.
 * @param   offBlkMap       Start of the block bitmap in blocks.
 * @param   cBlkMap         Size of the block bitmap on the disk in blocks.
 * @param   ppBlkMap        Where to store the block bitmap on success.
 */
static int vciBlkMapLoad(PVCICACHE pStorage, uint64_t offBlkMap, uint32_t cBlkMap, PVCIBLKMAP *ppBlkMap)
{
    int rc = VINF_SUCCESS;
    VciBlkMap BlkMap;

    LogFlowFunc(("pStorage=%#p offBlkMap=%llu cBlkMap=%u ppBlkMap=%#p\n",
                 pStorage, offBlkMap, cBlkMap, ppBlkMap));

    if (cBlkMap >= VCI_BYTE2BLOCK(sizeof(VciBlkMap)))
    {
        cBlkMap -= VCI_BYTE2BLOCK(sizeof(VciBlkMap));

        rc = vciFileReadSync(pStorage, offBlkMap, &BlkMap, VCI_BYTE2BLOCK(sizeof(VciBlkMap)));
        if (RT_SUCCESS(rc))
        {
            offBlkMap += VCI_BYTE2BLOCK(sizeof(VciBlkMap));

            BlkMap.u32Magic         = RT_LE2H_U32(BlkMap.u32Magic);
            BlkMap.u32Version       = RT_LE2H_U32(BlkMap.u32Version);
            BlkMap.cBlocks          = RT_LE2H_U32(BlkMap.cBlocks);
            BlkMap.cBlocksFree      = RT_LE2H_U32(BlkMap.cBlocksFree);
            BlkMap.cBlocksAllocMeta = RT_LE2H_U32(BlkMap.cBlocksAllocMeta);
            BlkMap.cBlocksAllocData = RT_LE2H_U32(BlkMap.cBlocksAllocData);

            if (   BlkMap.u32Magic == VCI_BLKMAP_MAGIC
                && BlkMap.u32Version == VCI_BLKMAP_VERSION
                && BlkMap.cBlocks == BlkMap.cBlocksFree + BlkMap.cBlocksAllocMeta + BlkMap.cBlocksAllocData
                && VCI_BYTE2BLOCK(BlkMap.cBlocks / 8) == cBlkMap)
            {
                PVCIBLKMAP pBlkMap = (PVCIBLKMAP)RTMemAllocZ(sizeof(VCIBLKMAP));
                if (pBlkMap)
                {
                    pBlkMap->cBlocks          = BlkMap.cBlocks;
                    pBlkMap->cBlocksFree      = BlkMap.cBlocksFree;
                    pBlkMap->cBlocksAllocMeta = BlkMap.cBlocksAllocMeta;
                    pBlkMap->cBlocksAllocData = BlkMap.cBlocksAllocData;

                    /* Load the bitmap and construct the range list. */
                    uint32_t cBlocksFree = 0;
                    uint32_t cBlocksAllocated = 0;
                    PVCIBLKRANGEDESC pRangeCur = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));

                    if (pRangeCur)
                    {
						uint32_t sizeof_abBitmapBuffer = 16 * _1K;
                        uint8_t *abBitmapBuffer;
                        uint32_t cBlocksRead = 0;
                        uint64_t cBlocksLeft = VCI_BYTE2BLOCK(pBlkMap->cBlocks / 8);

						abBitmapBuffer = (uint8_t *)RTMemAllocZ(sizeof_abBitmapBuffer);
						if (!abBitmapBuffer)
						{
							rc = VERR_NO_MEMORY;
						}
						else
						{
							cBlocksRead = RT_MIN(VCI_BYTE2BLOCK(sizeof_abBitmapBuffer), cBlocksLeft);
							rc = vciFileReadSync(pStorage, offBlkMap, abBitmapBuffer,
												 cBlocksRead);
						}

                        if (RT_SUCCESS(rc))
                        {
                            pRangeCur->fFree        = !(abBitmapBuffer[0] & 0x01);
                            pRangeCur->offAddrStart = 0;
                            pRangeCur->cBlocks      = 0;
                            pRangeCur->pNext        = NULL;
                            pRangeCur->pPrev        = NULL;
                            pBlkMap->pRangesHead = pRangeCur;
                            pBlkMap->pRangesTail = pRangeCur;
                        }

                        while (   RT_SUCCESS(rc)
                               && cBlocksLeft)
                        {
                            int iBit = 0;
                            uint32_t cBits = VCI_BLOCK2BYTE(cBlocksRead) * 8;
                            uint32_t iBitPrev = 0xffffffff;

                            while (cBits)
                            {
                                if (pRangeCur->fFree)
                                {
                                    /* Check for the first set bit. */
                                    iBit = ASMBitNextSet(abBitmapBuffer, cBits, iBitPrev);
                                }
                                else
                                {
                                    /* Check for the first free bit. */
                                    iBit = ASMBitNextClear(abBitmapBuffer, cBits, iBitPrev);
                                }

                                if (iBit == -1)
                                {
                                    /* No change. */
                                    pRangeCur->cBlocks += cBits;
                                    cBits = 0;
                                }
                                else
                                {
                                    Assert((uint32_t)iBit < cBits);
                                    pRangeCur->cBlocks += iBit;

                                    /* Create a new range descriptor. */
                                    PVCIBLKRANGEDESC pRangeNew = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));
                                    if (!pRangeNew)
                                    {
                                        rc = VERR_NO_MEMORY;
                                        break;
                                    }

                                    pRangeNew->fFree = !pRangeCur->fFree;
                                    pRangeNew->offAddrStart = pRangeCur->offAddrStart + pRangeCur->cBlocks;
                                    pRangeNew->cBlocks = 0;
                                    pRangeNew->pPrev = pRangeCur;
                                    pRangeCur->pNext = pRangeNew;
                                    pBlkMap->pRangesTail = pRangeNew;
                                    pRangeCur = pRangeNew;
                                    cBits -= iBit;
                                    iBitPrev = iBit;
                                }
                            }

                            cBlocksLeft -= cBlocksRead;
                            offBlkMap   += cBlocksRead;

                            if (   RT_SUCCESS(rc)
                                && cBlocksLeft)
                            {
                                /* Read next chunk. */
                                cBlocksRead = RT_MIN(VCI_BYTE2BLOCK(sizeof_abBitmapBuffer), cBlocksLeft);
                                rc = vciFileReadSync(pStorage, offBlkMap, abBitmapBuffer, cBlocksRead);
                            }
                        }
						if (abBitmapBuffer)
							RTMemFree(abBitmapBuffer);
                    }
                    else
                        rc = VERR_NO_MEMORY;

                    if (RT_SUCCESS(rc))
                    {
                        *ppBlkMap = pBlkMap;
                        LogFlowFunc(("return success\n"));
                        return VINF_SUCCESS;
                    }
                    else
                        RTMemFree(pBlkMap);
                }
                else
                    rc = VERR_NO_MEMORY;
            }
            else
                rc = VERR_VD_GEN_INVALID_HEADER;
        }
        else if (RT_SUCCESS(rc))
            rc = VERR_VD_GEN_INVALID_HEADER;
    }
    else
        rc = VERR_VD_GEN_INVALID_HEADER;

    LogFlowFunc(("returns rc=%Rrc\n", rc));
    return rc;
}

/**
 * Saves the block map in the cache image. All necessary on disk structures
 * are written.
 *
 * @returns VBox status code.
 * @param   pBlkMap         The block bitmap to save.
 * @param   pStorage        Where the block bitmap should be written to.
 * @param   offBlkMap       Start of the block bitmap in blocks.
 * @param   cBlkMap         Size of the block bitmap on the disk in blocks.
 */
static int vciBlkMapSave(PVCIBLKMAP pBlkMap, PVCICACHE pStorage, uint64_t offBlkMap, uint32_t cBlkMap)
{
    int rc = VINF_SUCCESS;
    VciBlkMap BlkMap;

    LogFlowFunc(("pBlkMap=%#p pStorage=%#p offBlkMap=%llu cBlkMap=%u\n",
                 pBlkMap, pStorage, offBlkMap, cBlkMap));

    /* Make sure the number of blocks allocated for us match our expectations. */
    if (VCI_BYTE2BLOCK(pBlkMap->cBlocks / 8) + VCI_BYTE2BLOCK(sizeof(VciBlkMap)) == cBlkMap)
    {
        /* Setup the header */
        memset(&BlkMap, 0, sizeof(VciBlkMap));

        BlkMap.u32Magic         = RT_H2LE_U32(VCI_BLKMAP_MAGIC);
        BlkMap.u32Version       = RT_H2LE_U32(VCI_BLKMAP_VERSION);
        BlkMap.cBlocks          = RT_H2LE_U32(pBlkMap->cBlocks);
        BlkMap.cBlocksFree      = RT_H2LE_U32(pBlkMap->cBlocksFree);
        BlkMap.cBlocksAllocMeta = RT_H2LE_U32(pBlkMap->cBlocksAllocMeta);
        BlkMap.cBlocksAllocData = RT_H2LE_U32(pBlkMap->cBlocksAllocData);

        rc = vciFileWriteSync(pStorage, offBlkMap, &BlkMap, VCI_BYTE2BLOCK(sizeof(VciBlkMap)));
        if (RT_SUCCESS(rc))
        {
			uint32_t sizeof_abBitmapBuffer = 16*_1K;
            uint8_t *abBitmapBuffer;
            unsigned iBit = 0;
            PVCIBLKRANGEDESC pCur = pBlkMap->pRangesHead;

			abBitmapBuffer = (uint8_t *)RTMemAllocZ(sizeof_abBitmapBuffer);
			if (!abBitmapBuffer)
			{
				rc = VERR_NO_MEMORY;
			}
			else
			{
				offBlkMap += VCI_BYTE2BLOCK(sizeof(VciBlkMap));

				/* Write the descriptor ranges. */
				while (pCur)
				{
					uint64_t cBlocks = pCur->cBlocks;

					while (cBlocks)
					{
						uint64_t cBlocksMax = RT_MIN(cBlocks, sizeof_abBitmapBuffer * 8 - iBit);

						if (pCur->fFree)
							ASMBitClearRange(abBitmapBuffer, iBit, iBit + cBlocksMax);
						else
							ASMBitSetRange(abBitmapBuffer, iBit, iBit + cBlocksMax);

						iBit    += cBlocksMax;
						cBlocks -= cBlocksMax;

						if (iBit == sizeof_abBitmapBuffer * 8)
						{
							/* Buffer is full, write to file and reset. */
							rc = vciFileWriteSync(pStorage, offBlkMap, abBitmapBuffer, VCI_BYTE2BLOCK(sizeof_abBitmapBuffer));
							if (RT_FAILURE(rc))
								break;

							offBlkMap += VCI_BYTE2BLOCK(sizeof_abBitmapBuffer);
							iBit = 0;
						}
					}

					pCur = pCur->pNext;
				}
			}

            Assert(iBit % 8 == 0);

            if (RT_SUCCESS(rc) && iBit)
                rc = vciFileWriteSync(pStorage, offBlkMap, abBitmapBuffer, VCI_BYTE2BLOCK(iBit / 8));

			if (abBitmapBuffer)
				RTMemFree(abBitmapBuffer);
        }
    }
    else
        rc = VERR_INTERNAL_ERROR; /* @todo Better error code. */

    LogFlowFunc(("returns rc=%Rrc\n", rc));
    return rc;
}

/**
 * Finds the range block describing the given block address.
 *
 * @returns Pointer to the block range descriptor or NULL if none could be found.
 * @param   pBlkMap         The block bitmap to search on.
 * @param   offBlockAddr    The block address to search for.
 */
static PVCIBLKRANGEDESC vciBlkMapFindByBlock(PVCIBLKMAP pBlkMap, uint64_t offBlockAddr)
{
    PVCIBLKRANGEDESC pBlk = pBlkMap->pRangesHead;

    while (   pBlk
           && pBlk->offAddrStart < offBlockAddr)
        pBlk = pBlk->pNext;

    return pBlk;
}

/**
 * Allocates the given number of blocks in the bitmap and returns the start block address.
 *
 * @returns VBox status code.
 * @param   pBlkMap          The block bitmap to allocate the blocks from.
 * @param   cBlocks          How many blocks to allocate.
 * @param   poffBlockAddr    Where to store the start address of the allocated region.
 */
static int vciBlkMapAllocate(PVCIBLKMAP pBlkMap, uint32_t cBlocks, uint64_t *poffBlockAddr)
{
    PVCIBLKRANGEDESC pBestFit = NULL;
    PVCIBLKRANGEDESC pCur = NULL;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pBlkMap=%#p cBlocks=%u poffBlockAddr=%#p\n",
                 pBlkMap, cBlocks, poffBlockAddr));

    pCur = pBlkMap->pRangesHead;

    while (pCur)
    {
        if (   pCur->fFree
            && pCur->cBlocks >= cBlocks)
        {
            if (   !pBestFit
                || pCur->cBlocks < pBestFit->cBlocks)
            {
                pBestFit = pCur;
                /* Stop searching if the size is matching exactly. */
                if (pBestFit->cBlocks == cBlocks)
                    break;
            }
        }
        pCur = pCur->pNext;
    }

    Assert(!pBestFit || pBestFit->fFree);

    if (pBestFit)
    {
        pBestFit->fFree = false;

        if (pBestFit->cBlocks > cBlocks)
        {
            /* Create a new free block. */
            PVCIBLKRANGEDESC pFree = (PVCIBLKRANGEDESC)RTMemAllocZ(sizeof(VCIBLKRANGEDESC));

            if (pFree)
            {
                pFree->fFree = true;
                pFree->cBlocks = pBestFit->cBlocks - cBlocks;
                pBestFit->cBlocks -= pFree->cBlocks;
                pFree->offAddrStart = pBestFit->offAddrStart + cBlocks;

                /* Link into the list. */
                pFree->pNext = pBestFit->pNext;
                pBestFit->pNext = pFree;
                pFree->pPrev    = pBestFit;
                if (!pFree->pNext)
                    pBlkMap->pRangesTail = pFree;

                *poffBlockAddr = pBestFit->offAddrStart;
            }
            else
            {
                rc = VERR_NO_MEMORY;
                pBestFit->fFree = true;
            }
        }
    }
    else
        rc = VERR_VCI_NO_BLOCKS_FREE;

    LogFlowFunc(("returns rc=%Rrc offBlockAddr=%llu\n", rc, *poffBlockAddr));
    return rc;
}

/**
 * Try to extend the space of an already allocated block.
 *
 * @returns VBox status code.
 * @param   pBlkMap          The block bitmap to allocate the blocks from.
 * @param   cBlocksNew       How many blocks the extended block should have.
 * @param   offBlockAddrOld  The start address of the block to reallocate.
 * @param   poffBlockAddr    Where to store the start address of the allocated region.
 */
static int vciBlkMapRealloc(PVCIBLKMAP pBlkMap, uint32_t cBlocksNew, uint64_t offBlockAddrOld,
                            uint64_t *poffBlockAddr)
{
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pBlkMap=%#p cBlocksNew=%u offBlockAddrOld=%llu poffBlockAddr=%#p\n",
                 pBlkMap, cBlocksNew, offBlockAddrOld, poffBlockAddr));

    AssertMsgFailed(("Implement\n"));

    LogFlowFunc(("returns rc=%Rrc offBlockAddr=%llu\n", rc, *poffBlockAddr));
    return rc;
}

/**
 * Frees a range of blocks.
 *
 * @returns nothing.
 * @param   pBlkMap          The block bitmap.
 * @param   offBlockAddr     Address of the first block to free.
 * @param   cBlocks          How many blocks to free.
 */
static void vciBlkMapFree(PVCIBLKMAP pBlkMap, uint64_t offBlockAddr, uint32_t cBlocks)
{
    PVCIBLKRANGEDESC pBlk;

    LogFlowFunc(("pBlkMap=%#p offBlockAddr=%llu cBlocks=%u\n",
                 pBlkMap, offBlockAddr, cBlocks));

    while (cBlocks)
    {
        pBlk = vciBlkMapFindByBlock(pBlkMap, offBlockAddr);
        AssertPtr(pBlk);

        /* Easy case, the whole block is freed. */
        if (   pBlk->offAddrStart == offBlockAddr
            && pBlk->cBlocks <= cBlocks)
        {
            pBlk->fFree = true;
            cBlocks      -= pBlk->cBlocks;
            offBlockAddr += pBlk->cBlocks;

            /* Check if it is possible to merge free blocks. */
            if (   pBlk->pPrev
                && pBlk->pPrev->fFree)
            {
                PVCIBLKRANGEDESC pBlkPrev = pBlk->pPrev;

                Assert(pBlkPrev->offAddrStart + pBlkPrev->cBlocks == pBlk->offAddrStart);
                pBlkPrev->cBlocks += pBlk->cBlocks;
                pBlkPrev->pNext = pBlk->pNext;
                if (pBlk->pNext)
                    pBlk->pNext->pPrev = pBlkPrev;
                else
                    pBlkMap->pRangesTail = pBlkPrev;

                RTMemFree(pBlk);
                pBlk = pBlkPrev;
            }

            /* Now the one to the right. */
            if (   pBlk->pNext
                && pBlk->pNext->fFree)
            {
                PVCIBLKRANGEDESC pBlkNext = pBlk->pNext;

                Assert(pBlk->offAddrStart + pBlk->cBlocks == pBlkNext->offAddrStart);
                pBlk->cBlocks += pBlkNext->cBlocks;
                pBlk->pNext = pBlkNext->pNext;
                if (pBlkNext->pNext)
                    pBlkNext->pNext->pPrev = pBlk;
                else
                    pBlkMap->pRangesTail = pBlk;

                RTMemFree(pBlkNext);
            }
        }
        else
        {
            /* The block is intersecting. */
            AssertMsgFailed(("TODO\n"));
        }
    }

    LogFlowFunc(("returns\n"));
}

/**
 * Converts a tree node from the image to the in memory structure.
 *
 * @returns Pointer to the in memory tree node.
 * @param   offBlockAddrNode    Block address of the node.
 * @param   pNodeImage          Pointer to the image representation of the node.
 */
static PVCITREENODE vciTreeNodeImage2Host(uint64_t offBlockAddrNode, PVciTreeNode pNodeImage)
{
    PVCITREENODE pNode = NULL;

    if (pNodeImage->u8Type == VCI_TREE_NODE_TYPE_LEAF)
    {
        PVCITREENODELEAF pLeaf = (PVCITREENODELEAF)RTMemAllocZ(sizeof(VCITREENODELEAF));

        if (pLeaf)
        {
            PVciCacheExtent pExtent = (PVciCacheExtent)&pNodeImage->au8Data[0];

            pLeaf->Core.u8Type = VCI_TREE_NODE_TYPE_LEAF;

            for (unsigned idx = 0; idx < RT_ELEMENTS(pLeaf->aExtents); idx++)
            {
                pLeaf->aExtents[idx].u64BlockOffset = RT_LE2H_U64(pExtent->u64BlockOffset);
                pLeaf->aExtents[idx].u32Blocks      = RT_LE2H_U32(pExtent->u32Blocks);
                pLeaf->aExtents[idx].u64BlockAddr   = RT_LE2H_U64(pExtent->u64BlockAddr);
                pExtent++;

                if (   pLeaf->aExtents[idx].u32Blocks
                    && pLeaf->aExtents[idx].u64BlockAddr)
                    pLeaf->cUsedNodes++;
            }

            pNode = &pLeaf->Core;
        }
    }
    else if (pNodeImage->u8Type == VCI_TREE_NODE_TYPE_INTERNAL)
    {
        PVCITREENODEINT pInt = (PVCITREENODEINT)RTMemAllocZ(sizeof(VCITREENODEINT));

        if (pInt)
        {
            PVciTreeNodeInternal pIntImage = (PVciTreeNodeInternal)&pNodeImage->au8Data[0];

            pInt->Core.u8Type = VCI_TREE_NODE_TYPE_INTERNAL;

            for (unsigned idx = 0; idx < RT_ELEMENTS(pInt->aIntNodes); idx++)
            {
                pInt->aIntNodes[idx].u64BlockOffset              = RT_LE2H_U64(pIntImage->u64BlockOffset);
                pInt->aIntNodes[idx].u32Blocks                   = RT_LE2H_U32(pIntImage->u32Blocks);
                pInt->aIntNodes[idx].PtrChild.fInMemory          = false;
                pInt->aIntNodes[idx].PtrChild.u.offAddrBlockNode = RT_LE2H_U64(pIntImage->u64ChildAddr);
                pIntImage++;

                if (   pInt->aIntNodes[idx].u32Blocks
                    && pInt->aIntNodes[idx].PtrChild.u.offAddrBlockNode)
                    pInt->cUsedNodes++;
            }

            pNode = &pInt->Core;
        }
    }
    else
        AssertMsgFailed(("Invalid node type %d\n", pNodeImage->u8Type));

    if (pNode)
        pNode->u64BlockAddr = offBlockAddrNode;

    return pNode;
}

/**
 * Looks up the cache extent for the given virtual block address.
 *
 * @returns Pointer to the cache extent or NULL if none could be found.
 * @param   pCache         The cache image instance.
 * @param   offBlockOffset The block offset to search for.
 */
static PVCICACHEEXTENT vciCacheExtentLookup(PVCICACHE pCache, uint64_t offBlockOffset)
{
    int rc = VINF_SUCCESS;
    PVCICACHEEXTENT pExtent = NULL;
    PVCITREENODE pNodeCur = pCache->pRoot;

    while (   RT_SUCCESS(rc)
           && pNodeCur
           && pNodeCur->u8Type != VCI_TREE_NODE_TYPE_LEAF)
    {
        PVCITREENODEINT pNodeInt = (PVCITREENODEINT)pNodeCur;

        Assert(pNodeCur->u8Type == VCI_TREE_NODE_TYPE_INTERNAL);

        /* Search for the correct internal node. */
        unsigned idxMin = 0;
        unsigned idxMax = pNodeInt->cUsedNodes;
        unsigned idxCur = pNodeInt->cUsedNodes / 2;

        while (idxMin < idxMax)
        {
            PVCINODEINTERNAL pInt = &pNodeInt->aIntNodes[idxCur];

            /* Determine the search direction. */
            if (offBlockOffset < pInt->u64BlockOffset)
            {
                /* Search left from the current extent. */
                idxMax = idxCur;
            }
            else if (offBlockOffset >= pInt->u64BlockOffset + pInt->u32Blocks)
            {
                /* Search right from the current extent. */
                idxMin = idxCur;
            }
            else
            {
                /* The block lies in the node, stop searching. */
                if (pInt->PtrChild.fInMemory)
                    pNodeCur = pInt->PtrChild.u.pNode;
                else
                {
                    PVCITREENODE pNodeNew;
                    VciTreeNode NodeTree;

                    /* Read from disk and add to the tree. */
                    rc = vciFileReadSync(pCache, VCI_BLOCK2BYTE(pInt->PtrChild.u.offAddrBlockNode),
                                         &NodeTree, sizeof(NodeTree));
                    AssertRC(rc);

                    pNodeNew = vciTreeNodeImage2Host(pInt->PtrChild.u.offAddrBlockNode, &NodeTree);
                    if (pNodeNew)
                    {
                        /* Link to the parent. */
                        pInt->PtrChild.fInMemory = true;
                        pInt->PtrChild.u.pNode = pNodeNew;
                        pNodeNew->pParent = pNodeCur;
                        pNodeCur = pNodeNew;
                    }
                    else
                        rc = VERR_NO_MEMORY;
                }
                break;
            }

            idxCur = idxMin + (idxMax - idxMin) / 2;
        }
    }

    if (   RT_SUCCESS(rc)
        && pNodeCur)
    {
        PVCITREENODELEAF pLeaf = (PVCITREENODELEAF)pNodeCur;
        Assert(pNodeCur->u8Type == VCI_TREE_NODE_TYPE_LEAF);

        /* Search the range. */
        unsigned idxMin = 0;
        unsigned idxMax = pLeaf->cUsedNodes;
        unsigned idxCur = pLeaf->cUsedNodes / 2;

        while (idxMin < idxMax)
        {
            PVCICACHEEXTENT pExtentCur = &pLeaf->aExtents[idxCur];

            /* Determine the search direction. */
            if (offBlockOffset < pExtentCur->u64BlockOffset)
            {
                /* Search left from the current extent. */
                idxMax = idxCur;
            }
            else if (offBlockOffset >= pExtentCur->u64BlockOffset + pExtentCur->u32Blocks)
            {
                /* Search right from the current extent. */
                idxMin = idxCur;
            }
            else
            {
                /* We found the extent, stop searching. */
                pExtent = pExtentCur;
                break;
            }

            idxCur = idxMin + (idxMax - idxMin) / 2;
        }
    }

    return pExtent;
}

/**
 * Internal: Open an image, constructing all necessary data structures.
 */
static int vciOpenImage(PVCICACHE pCache, unsigned uOpenFlags)
{
    VciHdr Hdr;
    uint64_t cbFile;
    int rc;

    pCache->uOpenFlags = uOpenFlags;

    pCache->pInterfaceError = VDInterfaceGet(pCache->pVDIfsDisk, VDINTERFACETYPE_ERROR);
    if (pCache->pInterfaceError)
        pCache->pInterfaceErrorCallbacks = VDGetInterfaceError(pCache->pInterfaceError);

    /* Get I/O interface. */
    pCache->pInterfaceIO = VDInterfaceGet(pCache->pVDIfsImage, VDINTERFACETYPE_IOINT);
    AssertPtrReturn(pCache->pInterfaceIO, VERR_INVALID_PARAMETER);
    pCache->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pCache->pInterfaceIO);
    AssertPtrReturn(pCache->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);

    /*
     * Open the image.
     */
    rc = vciFileOpen(pCache, pCache->pszFilename,
                     VDOpenFlagsToFileOpenFlags(uOpenFlags,
                                                false /* fCreate */));
    if (RT_FAILURE(rc))
    {
        /* Do NOT signal an appropriate error here, as the VD layer has the
         * choice of retrying the open if it failed. */
        goto out;
    }

    rc = vciFileGetSize(pCache, &cbFile);
    if (RT_FAILURE(rc) || cbFile < sizeof(VciHdr))
    {
        rc = VERR_VD_GEN_INVALID_HEADER;
        goto out;
    }

    rc = vciFileReadSync(pCache, 0, &Hdr, VCI_BYTE2BLOCK(sizeof(Hdr)));
    if (RT_FAILURE(rc))
    {
        rc = VERR_VD_GEN_INVALID_HEADER;
        goto out;
    }

    Hdr.u32Signature = RT_LE2H_U32(Hdr.u32Signature);
    Hdr.u32Version   = RT_LE2H_U32(Hdr.u32Version);
    Hdr.cBlocksCache = RT_LE2H_U64(Hdr.cBlocksCache);
    Hdr.u32CacheType = RT_LE2H_U32(Hdr.u32CacheType);
    Hdr.offTreeRoot  = RT_LE2H_U64(Hdr.offTreeRoot);
    Hdr.offBlkMap    = RT_LE2H_U64(Hdr.offBlkMap);
    Hdr.cBlkMap      = RT_LE2H_U64(Hdr.cBlkMap);

    if (   Hdr.u32Signature == VCI_HDR_SIGNATURE
        && Hdr.u32Version == VCI_HDR_VERSION)
    {
        pCache->offTreeRoot   = Hdr.offTreeRoot;
        pCache->offBlksBitmap = Hdr.offBlkMap;

        /* Load the block map. */
        rc = vciBlkMapLoad(pCache, pCache->offBlksBitmap, Hdr.cBlkMap, &pCache->pBlkMap);
        if (RT_SUCCESS(rc))
        {
            /* Load the first tree node. */
            VciTreeNode RootNode;

            rc = vciFileReadSync(pCache, pCache->offTreeRoot, &RootNode, VCI_BYTE2BLOCK(sizeof(VciTreeNode)));
            if (RT_SUCCESS(rc))
            {
                pCache->pRoot = vciTreeNodeImage2Host(pCache->offTreeRoot, &RootNode);
                if (!pCache->pRoot)
                    rc = VERR_NO_MEMORY;
            }
        }
    }
    else
        rc = VERR_VD_GEN_INVALID_HEADER;

out:
    if (RT_FAILURE(rc))
        vciFreeImage(pCache, false);
    return rc;
}

/**
 * Internal: Create a vci image.
 */
static int vciCreateImage(PVCICACHE pCache, uint64_t cbSize,
                          unsigned uImageFlags, const char *pszComment,
                          unsigned uOpenFlags, PFNVDPROGRESS pfnProgress,
                          void *pvUser, unsigned uPercentStart,
                          unsigned uPercentSpan)
{
    VciHdr Hdr;
    VciTreeNode NodeRoot;
    int rc;
    uint64_t cBlocks = cbSize / VCI_BLOCK_SIZE; /* Size of the cache in blocks. */

    if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
    {
        rc = vciError(pCache, VERR_VD_RAW_INVALID_TYPE, RT_SRC_POS, N_("VCI: cannot create diff image '%s'"), pCache->pszFilename);
        return rc;
    }

    pCache->uImageFlags = uImageFlags;

    pCache->uOpenFlags = uOpenFlags & ~VD_OPEN_FLAGS_READONLY;

    pCache->pInterfaceError = VDInterfaceGet(pCache->pVDIfsDisk, VDINTERFACETYPE_ERROR);
    if (pCache->pInterfaceError)
        pCache->pInterfaceErrorCallbacks = VDGetInterfaceError(pCache->pInterfaceError);

    pCache->pInterfaceIO = VDInterfaceGet(pCache->pVDIfsImage, VDINTERFACETYPE_IOINT);
    AssertPtrReturn(pCache->pInterfaceIO, VERR_INVALID_PARAMETER);
    pCache->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pCache->pInterfaceIO);
    AssertPtrReturn(pCache->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);

    do
    {
        /* Create image file. */
        rc = vciFileOpen(pCache, pCache->pszFilename,
                         VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
                                                    true /* fCreate */));
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot create image '%s'"), pCache->pszFilename);
            break;
        }

        /* Allocate block bitmap. */
        uint32_t cBlkMap = 0;
        rc = vciBlkMapCreate(cBlocks, &pCache->pBlkMap, &cBlkMap);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot create block bitmap '%s'"), pCache->pszFilename);
            break;
        }

        /*
         * Allocate space for the header in the block bitmap.
         * Because the block map is empty the header has to start at block 0
         */
        uint64_t offHdr = 0;
        rc = vciBlkMapAllocate(pCache->pBlkMap, VCI_BYTE2BLOCK(sizeof(VciHdr)), &offHdr);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot allocate space for header in block bitmap '%s'"), pCache->pszFilename);
            break;
        }

        Assert(offHdr == 0);

        /*
         * Allocate space for the block map itself.
         */
        uint64_t offBlkMap = 0;
        rc = vciBlkMapAllocate(pCache->pBlkMap, cBlkMap, &offBlkMap);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot allocate space for block map in block map '%s'"), pCache->pszFilename);
            break;
        }

        /*
         * Allocate space for the tree root node.
         */
        uint64_t offTreeRoot = 0;
        rc = vciBlkMapAllocate(pCache->pBlkMap, VCI_BYTE2BLOCK(sizeof(VciTreeNode)), &offTreeRoot);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot allocate space for block map in block map '%s'"), pCache->pszFilename);
            break;
        }

        /*
         * Allocate the in memory root node.
         */
        pCache->pRoot = (PVCITREENODE)RTMemAllocZ(sizeof(VCITREENODELEAF));
        if (!pCache->pRoot)
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot allocate B+-Tree root pointer '%s'"), pCache->pszFilename);
            break;
        }

        pCache->pRoot->u8Type = VCI_TREE_NODE_TYPE_LEAF;
        /* Rest remains 0 as the tree is still empty. */

        /*
         * Now that we are here we have all the basic structures and know where to place them in the image.
         * It's time to write it now.
         */

        /* Setup the header. */
        memset(&Hdr, 0, sizeof(VciHdr));
        Hdr.u32Signature     = RT_H2LE_U32(VCI_HDR_SIGNATURE);
        Hdr.u32Version       = RT_H2LE_U32(VCI_HDR_VERSION);
        Hdr.cBlocksCache     = RT_H2LE_U64(cBlocks);
        Hdr.fUncleanShutdown = VCI_HDR_UNCLEAN_SHUTDOWN;
        Hdr.u32CacheType     = uImageFlags & VD_IMAGE_FLAGS_FIXED
                               ? RT_H2LE_U32(VCI_HDR_CACHE_TYPE_FIXED)
                               : RT_H2LE_U32(VCI_HDR_CACHE_TYPE_DYNAMIC);
        Hdr.offTreeRoot      = RT_H2LE_U64(offTreeRoot);
        Hdr.offBlkMap        = RT_H2LE_U64(offBlkMap);
        Hdr.cBlkMap          = RT_H2LE_U64(cBlkMap);

        rc = vciFileWriteSync(pCache, offHdr, &Hdr, VCI_BYTE2BLOCK(sizeof(VciHdr)));
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot write header '%s'"), pCache->pszFilename);
            break;
        }

        rc = vciBlkMapSave(pCache->pBlkMap, pCache, offBlkMap, cBlkMap);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot write block map '%s'"), pCache->pszFilename);
            break;
        }

        /* Setup the root tree. */
        memset(&NodeRoot, 0, sizeof(VciTreeNode));
        NodeRoot.u8Type = RT_H2LE_U32(VCI_TREE_NODE_TYPE_LEAF);

        rc = vciFileWriteSync(pCache, offTreeRoot, &NodeRoot, VCI_BYTE2BLOCK(sizeof(VciTreeNode)));
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot write root node '%s'"), pCache->pszFilename);
            break;
        }

        rc = vciFlushImage(pCache);
        if (RT_FAILURE(rc))
        {
            rc = vciError(pCache, rc, RT_SRC_POS, N_("VCI: cannot flush '%s'"), pCache->pszFilename);
            break;
        }

        pCache->cbSize = cbSize;

    } while (0);

    if (RT_SUCCESS(rc) && pfnProgress)
        pfnProgress(pvUser, uPercentStart + uPercentSpan);

    if (RT_FAILURE(rc))
        vciFreeImage(pCache, rc != VERR_ALREADY_EXISTS);
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnProbe */
static int vciProbe(const char *pszFilename, PVDINTERFACE pVDIfsCache,
                    PVDINTERFACE pVDIfsImage)
{
    VciHdr Hdr;
    PVDIOSTORAGE pStorage;
    uint64_t cbFile;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));

    /* Get I/O interface. */
    PVDINTERFACE pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT);
    AssertPtrReturn(pInterfaceIO, VERR_INVALID_PARAMETER);
    PVDINTERFACEIOINT pInterfaceIOCallbacks = VDGetInterfaceIOInt(pInterfaceIO);
    AssertPtrReturn(pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);

    rc = pInterfaceIOCallbacks->pfnOpen(pInterfaceIO->pvUser, pszFilename,
                                        VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
                                                                   false /* fCreate */),
                                        &pStorage);
    if (RT_FAILURE(rc))
        goto out;

    rc = pInterfaceIOCallbacks->pfnGetSize(pInterfaceIO->pvUser, pStorage, &cbFile);
    if (RT_FAILURE(rc) || cbFile < sizeof(VciHdr))
    {
        pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
        rc = VERR_VD_GEN_INVALID_HEADER;
        goto out;
    }

    rc = pInterfaceIOCallbacks->pfnReadSync(pInterfaceIO->pvUser, pStorage, 0, &Hdr, sizeof(Hdr), NULL);
    if (RT_FAILURE(rc))
    {
        pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
        rc = VERR_VD_GEN_INVALID_HEADER;
        goto out;
    }

    Hdr.u32Signature = RT_LE2H_U32(Hdr.u32Signature);
    Hdr.u32Version   = RT_LE2H_U32(Hdr.u32Version);
    Hdr.cBlocksCache = RT_LE2H_U64(Hdr.cBlocksCache);
    Hdr.u32CacheType = RT_LE2H_U32(Hdr.u32CacheType);
    Hdr.offTreeRoot  = RT_LE2H_U64(Hdr.offTreeRoot);
    Hdr.offBlkMap    = RT_LE2H_U64(Hdr.offBlkMap);
    Hdr.cBlkMap      = RT_LE2H_U64(Hdr.cBlkMap);

    if (   Hdr.u32Signature == VCI_HDR_SIGNATURE
        && Hdr.u32Version == VCI_HDR_VERSION)
        rc = VINF_SUCCESS;
    else
        rc = VERR_VD_GEN_INVALID_HEADER;

    pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);

out:
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnOpen */
static int vciOpen(const char *pszFilename, unsigned uOpenFlags,
                   PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
                   void **ppBackendData)
{
    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
    int rc;
    PVCICACHE pCache;

    /* Check open flags. All valid flags are supported. */
    if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
    {
        rc = VERR_INVALID_PARAMETER;
        goto out;
    }

    /* Check remaining arguments. */
    if (   !VALID_PTR(pszFilename)
        || !*pszFilename)
    {
        rc = VERR_INVALID_PARAMETER;
        goto out;
    }


    pCache = (PVCICACHE)RTMemAllocZ(sizeof(VCICACHE));
    if (!pCache)
    {
        rc = VERR_NO_MEMORY;
        goto out;
    }
    pCache->pszFilename = pszFilename;
    pCache->pStorage = NULL;
    pCache->pVDIfsDisk = pVDIfsDisk;
    pCache->pVDIfsImage = pVDIfsImage;

    rc = vciOpenImage(pCache, uOpenFlags);
    if (RT_SUCCESS(rc))
        *ppBackendData = pCache;
    else
        RTMemFree(pCache);

out:
    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnCreate */
static int vciCreate(const char *pszFilename, uint64_t cbSize,
                     unsigned uImageFlags, const char *pszComment,
                     PCRTUUID pUuid, unsigned uOpenFlags,
                     unsigned uPercentStart, unsigned uPercentSpan,
                     PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
                     PVDINTERFACE pVDIfsOperation, void **ppBackendData)
{
    LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p ppBackendData=%#p",
                 pszFilename, cbSize, uImageFlags, pszComment, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
    int rc;
    PVCICACHE pCache;

    PFNVDPROGRESS pfnProgress = NULL;
    void *pvUser = NULL;
    PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
                                              VDINTERFACETYPE_PROGRESS);
    PVDINTERFACEPROGRESS pCbProgress = NULL;
    if (pIfProgress)
    {
        pCbProgress = VDGetInterfaceProgress(pIfProgress);
        if (pCbProgress)
            pfnProgress = pCbProgress->pfnProgress;
        pvUser = pIfProgress->pvUser;
    }

    /* Check open flags. All valid flags are supported. */
    if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
    {
        rc = VERR_INVALID_PARAMETER;
        goto out;
    }

    /* Check remaining arguments. */
    if (   !VALID_PTR(pszFilename)
        || !*pszFilename)
    {
        rc = VERR_INVALID_PARAMETER;
        goto out;
    }

    pCache = (PVCICACHE)RTMemAllocZ(sizeof(VCICACHE));
    if (!pCache)
    {
        rc = VERR_NO_MEMORY;
        goto out;
    }
    pCache->pszFilename = pszFilename;
    pCache->pStorage = NULL;
    pCache->pVDIfsDisk = pVDIfsDisk;
    pCache->pVDIfsImage = pVDIfsImage;

    rc = vciCreateImage(pCache, cbSize, uImageFlags, pszComment, uOpenFlags,
                        pfnProgress, pvUser, uPercentStart, uPercentSpan);
    if (RT_SUCCESS(rc))
    {
        /* So far the image is opened in read/write mode. Make sure the
         * image is opened in read-only mode if the caller requested that. */
        if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
        {
            vciFreeImage(pCache, false);
            rc = vciOpenImage(pCache, uOpenFlags);
            if (RT_FAILURE(rc))
            {
                RTMemFree(pCache);
                goto out;
            }
        }
        *ppBackendData = pCache;
    }
    else
        RTMemFree(pCache);

out:
    LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnClose */
static int vciClose(void *pBackendData, bool fDelete)
{
    LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    rc = vciFreeImage(pCache, fDelete);
    RTMemFree(pCache);

    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnRead */
static int vciRead(void *pBackendData, uint64_t uOffset, void *pvBuf,
                   size_t cbToRead, size_t *pcbActuallyRead)
{
    LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc = VINF_SUCCESS;
    PVCICACHEEXTENT pExtent;

    AssertPtr(pCache);
    Assert(uOffset % 512 == 0);
    Assert(cbToRead % 512 == 0);


    pExtent = vciCacheExtentLookup(pCache, VCI_BYTE2BLOCK(uOffset));
    if (pExtent)
    {
        uint64_t offRead = uOffset - VCI_BLOCK2BYTE(pExtent->u64BlockOffset);
        cbToRead = RT_MIN(cbToRead, VCI_BLOCK2BYTE(pExtent->u32Blocks) - offRead);

        rc = vciFileReadSync(pCache, VCI_BLOCK2BYTE(pExtent->u64BlockAddr) + offRead,
                             pvBuf, cbToRead);
    }
    else
    {
        /** @todo Best fit to check whether we have cached data later and set
         * pcbActuallyRead accordingly. */
        rc = VERR_VD_BLOCK_FREE;
    }

    if (pcbActuallyRead)
        *pcbActuallyRead = cbToRead;

out:
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnWrite */
static int vciWrite(void *pBackendData, uint64_t uOffset, const void *pvBuf,
                    size_t cbToWrite, size_t *pcbWriteProcess)
{
    LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p\n",
                 pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc = VINF_SUCCESS;

    AssertPtr(pCache);
    Assert(uOffset % 512 == 0);
    Assert(cbToWrite % 512 == 0);

    *pcbWriteProcess = cbToWrite; /** @todo: Implement. */
out:
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnFlush */
static int vciFlush(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc = VINF_SUCCESS;

    rc = vciFlushImage(pCache);
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnGetVersion */
static unsigned vciGetVersion(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;

    AssertPtr(pCache);

    if (pCache)
        return 1;
    else
        return 0;
}

/** @copydoc VDCACHEBACKEND::pfnGetSize */
static uint64_t vciGetSize(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    uint64_t cb = 0;

    AssertPtr(pCache);

    if (pCache && pCache->pStorage)
        cb = pCache->cbSize;

    LogFlowFunc(("returns %llu\n", cb));
    return cb;
}

/** @copydoc VDCACHEBACKEND::pfnGetFileSize */
static uint64_t vciGetFileSize(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    uint64_t cb = 0;

    AssertPtr(pCache);

    if (pCache)
    {
        uint64_t cbFile;
        if (pCache->pStorage)
        {
            int rc = vciFileGetSize(pCache, &cbFile);
            if (RT_SUCCESS(rc))
                cb = cbFile;
        }
    }

    LogFlowFunc(("returns %lld\n", cb));
    return cb;
}

/** @copydoc VDCACHEBACKEND::pfnGetImageFlags */
static unsigned vciGetImageFlags(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    unsigned uImageFlags;

    AssertPtr(pCache);

    if (pCache)
        uImageFlags = pCache->uImageFlags;
    else
        uImageFlags = 0;

    LogFlowFunc(("returns %#x\n", uImageFlags));
    return uImageFlags;
}

/** @copydoc VDCACHEBACKEND::pfnGetOpenFlags */
static unsigned vciGetOpenFlags(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    unsigned uOpenFlags;

    AssertPtr(pCache);

    if (pCache)
        uOpenFlags = pCache->uOpenFlags;
    else
        uOpenFlags = 0;

    LogFlowFunc(("returns %#x\n", uOpenFlags));
    return uOpenFlags;
}

/** @copydoc VDCACHEBACKEND::pfnSetOpenFlags */
static int vciSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
{
    LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    /* Image must be opened and the new flags must be valid. Just readonly and
     * info flags are supported. */
    if (!pCache || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO)))
    {
        rc = VERR_INVALID_PARAMETER;
        goto out;
    }

    /* Implement this operation via reopening the image. */
    rc = vciFreeImage(pCache, false);
    if (RT_FAILURE(rc))
        goto out;
    rc = vciOpenImage(pCache, uOpenFlags);

out:
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnGetComment */
static int vciGetComment(void *pBackendData, char *pszComment,
                          size_t cbComment)
{
    LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    AssertPtr(pCache);

    if (pCache)
        rc = VERR_NOT_SUPPORTED;
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnSetComment */
static int vciSetComment(void *pBackendData, const char *pszComment)
{
    LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    AssertPtr(pCache);

    if (pCache)
    {
        if (pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY)
            rc = VERR_VD_IMAGE_READ_ONLY;
        else
            rc = VERR_NOT_SUPPORTED;
    }
    else
        rc = VERR_VD_NOT_OPENED;

out:
    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnGetUuid */
static int vciGetUuid(void *pBackendData, PRTUUID pUuid)
{
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    AssertPtr(pCache);

    if (pCache)
        rc = VERR_NOT_SUPPORTED;
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnSetUuid */
static int vciSetUuid(void *pBackendData, PCRTUUID pUuid)
{
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    LogFlowFunc(("%RTuuid\n", pUuid));
    AssertPtr(pCache);

    if (pCache)
    {
        if (!(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
            rc = VERR_NOT_SUPPORTED;
        else
            rc = VERR_VD_IMAGE_READ_ONLY;
    }
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnGetModificationUuid */
static int vciGetModificationUuid(void *pBackendData, PRTUUID pUuid)
{
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    AssertPtr(pCache);

    if (pCache)
        rc = VERR_NOT_SUPPORTED;
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnSetModificationUuid */
static int vciSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
{
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVCICACHE pCache = (PVCICACHE)pBackendData;
    int rc;

    AssertPtr(pCache);

    if (pCache)
    {
        if (!(pCache->uOpenFlags & VD_OPEN_FLAGS_READONLY))
            rc = VERR_NOT_SUPPORTED;
        else
            rc = VERR_VD_IMAGE_READ_ONLY;
    }
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc\n", rc));
    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnDump */
static void vciDump(void *pBackendData)
{
    NOREF(pBackendData);
}

/** @copydoc VDCACHEBACKEND::pfnAsyncRead */
static int vciAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbRead,
                        PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
{
    int rc = VERR_NOT_SUPPORTED;
    PVCICACHE pCache = (PVCICACHE)pBackendData;

    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnAsyncWrite */
static int vciAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbWrite,
                         PVDIOCTX pIoCtx, size_t *pcbWriteProcess)
{
    int rc = VERR_NOT_SUPPORTED;
    PVCICACHE pCache = (PVCICACHE)pBackendData;

    return rc;
}

/** @copydoc VDCACHEBACKEND::pfnAsyncFlush */
static int vciAsyncFlush(void *pBackendData, PVDIOCTX pIoCtx)
{
    int rc = VERR_NOT_SUPPORTED;
    PVCICACHE pCache = (PVCICACHE)pBackendData;

    return rc;
}


VDCACHEBACKEND g_VciCacheBackend =
{
    /* pszBackendName */
    "vci",
    /* cbSize */
    sizeof(VDCACHEBACKEND),
    /* uBackendCaps */
    VD_CAP_CREATE_FIXED | VD_CAP_CREATE_DYNAMIC | VD_CAP_FILE | VD_CAP_VFS,
    /* papszFileExtensions */
    s_apszVciFileExtensions,
    /* paConfigInfo */
    NULL,
    /* hPlugin */
    NIL_RTLDRMOD,
    /* pfnProbe */
    vciProbe,
    /* pfnOpen */
    vciOpen,
    /* pfnCreate */
    vciCreate,
    /* pfnClose */
    vciClose,
    /* pfnRead */
    vciRead,
    /* pfnWrite */
    vciWrite,
    /* pfnFlush */
    vciFlush,
    /* pfnGetVersion */
    vciGetVersion,
    /* pfnGetSize */
    vciGetSize,
    /* pfnGetFileSize */
    vciGetFileSize,
    /* pfnGetImageFlags */
    vciGetImageFlags,
    /* pfnGetOpenFlags */
    vciGetOpenFlags,
    /* pfnSetOpenFlags */
    vciSetOpenFlags,
    /* pfnGetComment */
    vciGetComment,
    /* pfnSetComment */
    vciSetComment,
    /* pfnGetUuid */
    vciGetUuid,
    /* pfnSetUuid */
    vciSetUuid,
    /* pfnGetModificationUuid */
    vciGetModificationUuid,
    /* pfnSetModificationUuid */
    vciSetModificationUuid,
    /* pfnDump */
    vciDump,
    /* pfnAsyncRead */
    vciAsyncRead,
    /* pfnAsyncWrite */
    vciAsyncWrite,
    /* pfnAsyncFlush */
    vciAsyncFlush,
    /* pfnComposeLocation */
    NULL,
    /* pfnComposeName */
    NULL
};

