/* $Id: VHDX.cpp 63567 2016-08-16 14:06:54Z vboxsync $ */
/** @file
 * VHDX - VHDX Disk image, Core Code.
 */

/*
 * Copyright (C) 2012-2016 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_VHDX
#include <VBox/vd-plugin.h>
#include <VBox/err.h>

#include <VBox/log.h>
#include <iprt/asm.h>
#include <iprt/assert.h>
#include <iprt/alloc.h>
#include <iprt/path.h>
#include <iprt/uuid.h>
#include <iprt/crc.h>

#include "VDBackends.h"


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

/**
 * VHDX file type identifier.
 */
#pragma pack(1)
typedef struct VhdxFileIdentifier
{
    /** Signature. */
    uint64_t    u64Signature;
    /** Creator ID - UTF-16 string (not neccessarily null terminated). */
    uint16_t    awszCreator[256];
} VhdxFileIdentifier;
#pragma pack()
/** Pointer to an on disk VHDX file type identifier. */
typedef VhdxFileIdentifier *PVhdxFileIdentifier;

/** VHDX file type identifier signature ("vhdxfile"). */
#define VHDX_FILE_IDENTIFIER_SIGNATURE UINT64_C(0x656c696678646876)
/** Start offset of the VHDX file type identifier. */
#define VHDX_FILE_IDENTIFIER_OFFSET    UINT64_C(0)

/**
 * VHDX header.
 */
#pragma pack(1)
typedef struct VhdxHeader
{
    /** Signature. */
    uint32_t    u32Signature;
    /** Checksum. */
    uint32_t    u32Checksum;
    /** Sequence number. */
    uint64_t    u64SequenceNumber;
    /** File write UUID. */
    RTUUID      UuidFileWrite;
    /** Data write UUID. */
    RTUUID      UuidDataWrite;
    /** Log UUID. */
    RTUUID      UuidLog;
    /** Version of the log format. */
    uint16_t    u16LogVersion;
    /** VHDX format version.. */
    uint16_t    u16Version;
    /** Length of the log region. */
    uint32_t    u32LogLength;
    /** Start offset of the log offset in the file. */
    uint64_t    u64LogOffset;
    /** Reserved bytes. */
    uint8_t     u8Reserved[4016];
} VhdxHeader;
#pragma pack()
/** Pointer to an on disk VHDX header. */
typedef VhdxHeader *PVhdxHeader;

/** VHDX header signature ("head"). */
#define VHDX_HEADER_SIGNATURE    UINT32_C(0x64616568)
/** Start offset of the first VHDX header. */
#define VHDX_HEADER1_OFFSET      _64K
/** Start offset of the second VHDX header. */
#define VHDX_HEADER2_OFFSET      _128K
/** Current Log format version. */
#define VHDX_HEADER_LOG_VERSION  UINT16_C(0)
/** Current VHDX format version. */
#define VHDX_HEADER_VHDX_VERSION UINT16_C(1)

/**
 * VHDX region table header
 */
#pragma pack(1)
typedef struct VhdxRegionTblHdr
{
    /** Signature. */
    uint32_t    u32Signature;
    /** Checksum. */
    uint32_t    u32Checksum;
    /** Number of region table entries following this header. */
    uint32_t    u32EntryCount;
    /** Reserved. */
    uint32_t    u32Reserved;
} VhdxRegionTblHdr;
#pragma pack()
/** Pointer to an on disk VHDX region table header. */
typedef VhdxRegionTblHdr *PVhdxRegionTblHdr;

/** VHDX region table header signature. */
#define VHDX_REGION_TBL_HDR_SIGNATURE       UINT32_C(0x69676572)
/** Maximum number of entries which can follow. */
#define VHDX_REGION_TBL_HDR_ENTRY_COUNT_MAX UINT32_C(2047)
/** Offset where the region table is stored (192 KB). */
#define VHDX_REGION_TBL_HDR_OFFSET          UINT64_C(196608)
/** Maximum size of the region table. */
#define VHDX_REGION_TBL_SIZE_MAX            _64K

/**
 * VHDX region table entry.
 */
#pragma pack(1)
typedef struct VhdxRegionTblEntry
{
    /** Object UUID. */
    RTUUID      UuidObject;
    /** File offset of the region. */
    uint64_t    u64FileOffset;
    /** Length of the region in bytes. */
    uint32_t    u32Length;
    /** Flags for this object. */
    uint32_t    u32Flags;
} VhdxRegionTblEntry;
#pragma pack()
/** Pointer to an on disk VHDX region table entry. */
typedef struct VhdxRegionTblEntry *PVhdxRegionTblEntry;

/** Flag whether this region is required. */
#define VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED RT_BIT_32(0)
/** UUID for the BAT region. */
#define VHDX_REGION_TBL_ENTRY_UUID_BAT          "2dc27766-f623-4200-9d64-115e9bfd4a08"
/** UUID for the metadata region. */
#define VHDX_REGION_TBL_ENTRY_UUID_METADATA     "8b7ca206-4790-4b9a-b8fe-575f050f886e"

/**
 * VHDX Log entry header.
 */
#pragma pack(1)
typedef struct VhdxLogEntryHdr
{
    /** Signature. */
    uint32_t    u32Signature;
    /** Checksum. */
    uint32_t    u32Checksum;
    /** Total length of the entry in bytes. */
    uint32_t    u32EntryLength;
    /** Tail of the log entries. */
    uint32_t    u32Tail;
    /** Sequence number. */
    uint64_t    u64SequenceNumber;
    /** Number of descriptors in this log entry. */
    uint32_t    u32DescriptorCount;
    /** Reserved. */
    uint32_t    u32Reserved;
    /** Log UUID. */
    RTUUID      UuidLog;
    /** VHDX file size in bytes while the log entry was written. */
    uint64_t    u64FlushedFileOffset;
    /** File size in bytes all allocated file structures fit into when the
     * log entry was written. */
    uint64_t    u64LastFileOffset;
} VhdxLogEntryHdr;
#pragma pack()
/** Pointer to an on disk VHDX log entry header. */
typedef struct VhdxLogEntryHdr *PVhdxLogEntryHdr;

/** VHDX log entry signature ("loge"). */
#define VHDX_LOG_ENTRY_HEADER_SIGNATURE UINT32_C(0x65676f6c)

/**
 * VHDX log zero descriptor.
 */
#pragma pack(1)
typedef struct VhdxLogZeroDesc
{
    /** Signature of this descriptor. */
    uint32_t    u32ZeroSignature;
    /** Reserved. */
    uint32_t    u32Reserved;
    /** Length of the section to zero. */
    uint64_t    u64ZeroLength;
    /** File offset to write zeros to. */
    uint64_t    u64FileOffset;
    /** Sequence number (must macht the field in the log entry header). */
    uint64_t    u64SequenceNumber;
} VhdxLogZeroDesc;
#pragma pack()
/** Pointer to an on disk VHDX log zero descriptor. */
typedef struct VhdxLogZeroDesc *PVhdxLogZeroDesc;

/** Signature of a VHDX log zero descriptor ("zero"). */
#define VHDX_LOG_ZERO_DESC_SIGNATURE UINT32_C(0x6f72657a)

/**
 * VHDX log data descriptor.
 */
#pragma pack(1)
typedef struct VhdxLogDataDesc
{
    /** Signature of this descriptor. */
    uint32_t    u32DataSignature;
    /** Trailing 4 bytes removed from the update. */
    uint32_t    u32TrailingBytes;
    /** Leading 8 bytes removed from the update. */
    uint64_t    u64LeadingBytes;
    /** File offset to write zeros to. */
    uint64_t    u64FileOffset;
    /** Sequence number (must macht the field in the log entry header). */
    uint64_t    u64SequenceNumber;
} VhdxLogDataDesc;
#pragma pack()
/** Pointer to an on disk VHDX log data descriptor. */
typedef struct VhdxLogDataDesc *PVhdxLogDataDesc;

/** Signature of a VHDX log data descriptor ("desc"). */
#define VHDX_LOG_DATA_DESC_SIGNATURE UINT32_C(0x63736564)

/**
 * VHDX log data sector.
 */
#pragma pack(1)
typedef struct VhdxLogDataSector
{
    /** Signature of the data sector. */
    uint32_t    u32DataSignature;
    /** 4 most significant bytes of the sequence number. */
    uint32_t    u32SequenceHigh;
    /** Raw data associated with the update. */
    uint8_t     u8Data[4084];
    /** 4 least significant bytes of the sequence number. */
    uint32_t    u32SequenceLow;
} VhdxLogDataSector;
#pragma pack()
/** Pointer to an on disk VHDX log data sector. */
typedef VhdxLogDataSector *PVhdxLogDataSector;

/** Signature of a VHDX log data sector ("data"). */
#define VHDX_LOG_DATA_SECTOR_SIGNATURE UINT32_C(0x61746164)

/**
 * VHDX BAT entry.
 */
#pragma pack(1)
typedef struct VhdxBatEntry
{
    /** The BAT entry, contains state and offset. */
    uint64_t    u64BatEntry;
} VhdxBatEntry;
#pragma pack()
typedef VhdxBatEntry *PVhdxBatEntry;

/** Return the BAT state from a given entry. */
#define VHDX_BAT_ENTRY_GET_STATE(bat) ((bat) & UINT64_C(0x7))
/** Get the FileOffsetMB field from a given BAT entry. */
#define VHDX_BAT_ENTRY_GET_FILE_OFFSET_MB(bat) (((bat) & UINT64_C(0xfffffffffff00000)) >> 20)
/** Get a byte offset from the BAT entry. */
#define VHDX_BAT_ENTRY_GET_FILE_OFFSET(bat) (VHDX_BAT_ENTRY_GET_FILE_OFFSET_MB(bat) * (uint64_t)_1M)

/** Block not present and the data is undefined. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_NOT_PRESENT       (0)
/** Data in this block is undefined. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNDEFINED         (1)
/** Data in this block contains zeros. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_ZERO              (2)
/** Block was unmapped by the application or system and data is either zero or
 * the data before the block was unmapped. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNMAPPED          (3)
/** Block data is in the file pointed to by the FileOffsetMB field. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_FULLY_PRESENT     (6)
/** Block is partially present, use sector bitmap to get present sectors. */
#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT (7)

/** The sector bitmap block is undefined and not allocated in the file. */
#define VHDX_BAT_ENTRY_SB_BLOCK_NOT_PRESENT            (0)
/** The sector bitmap block is defined at the file location. */
#define VHDX_BAT_ENTRY_SB_BLOCK_PRESENT                (6)

/**
 * VHDX Metadata tabl header.
 */
#pragma pack(1)
typedef struct VhdxMetadataTblHdr
{
    /** Signature. */
    uint64_t    u64Signature;
    /** Reserved. */
    uint16_t    u16Reserved;
    /** Number of entries in the table. */
    uint16_t    u16EntryCount;
    /** Reserved */
    uint32_t    u32Reserved2[5];
} VhdxMetadataTblHdr;
#pragma pack()
/** Pointer to an on disk metadata table header. */
typedef VhdxMetadataTblHdr *PVhdxMetadataTblHdr;

/** Signature of a VHDX metadata table header ("metadata"). */
#define VHDX_METADATA_TBL_HDR_SIGNATURE       UINT64_C(0x617461646174656d)
/** Maximum number of entries the metadata table can have. */
#define VHDX_METADATA_TBL_HDR_ENTRY_COUNT_MAX UINT16_C(2047)

/**
 * VHDX Metadata table entry.
 */
#pragma pack(1)
typedef struct VhdxMetadataTblEntry
{
    /** Item UUID. */
    RTUUID      UuidItem;
    /** Offset of the metadata item. */
    uint32_t    u32Offset;
    /** Length of the metadata item. */
    uint32_t    u32Length;
    /** Flags for the metadata item. */
    uint32_t    u32Flags;
    /** Reserved. */
    uint32_t    u32Reserved;
} VhdxMetadataTblEntry;
#pragma pack()
/** Pointer to an on disk metadata table entry. */
typedef VhdxMetadataTblEntry *PVhdxMetadataTblEntry;

/** FLag whether the metadata item is system or user metadata. */
#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_USER     RT_BIT_32(0)
/** FLag whether the metadata item is file or virtual disk metadata. */
#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_VDISK    RT_BIT_32(1)
/** FLag whether the backend must understand the metadata item to load the image. */
#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED RT_BIT_32(2)

/** File parameters item UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_FILE_PARAMS    "caa16737-fa36-4d43-b3b6-33f0aa44e76b"
/** Virtual disk size item UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_VDISK_SIZE     "2fa54224-cd1b-4876-b211-5dbed83bf4b8"
/** Page 83 UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_PAGE83_DATA    "beca12ab-b2e6-4523-93ef-c309e000c746"
/** Logical sector size UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_LOG_SECT_SIZE  "8141bf1d-a96f-4709-ba47-f233a8faab5f"
/** Physical sector size UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_PHYS_SECT_SIZE "cda348c7-445d-4471-9cc9-e9885251c556"
/** Parent locator UUID. */
#define VHDX_METADATA_TBL_ENTRY_ITEM_PARENT_LOCATOR "a8d35f2d-b30b-454d-abf7-d3d84834ab0c"

/**
 * VHDX File parameters metadata item.
 */
#pragma pack(1)
typedef struct VhdxFileParameters
{
    /** Block size. */
    uint32_t    u32BlockSize;
    /** Flags. */
    uint32_t    u32Flags;
} VhdxFileParameters;
#pragma pack()
/** Pointer to an on disk VHDX file parameters metadata item. */
typedef struct VhdxFileParameters *PVhdxFileParameters;

/** Flag whether to leave blocks allocated in the file or if it is possible to unmap them. */
#define VHDX_FILE_PARAMETERS_FLAGS_LEAVE_BLOCKS_ALLOCATED RT_BIT_32(0)
/** Flag whether this file has a parent VHDX file. */
#define VHDX_FILE_PARAMETERS_FLAGS_HAS_PARENT             RT_BIT_32(1)

/**
 * VHDX virtual disk size metadata item.
 */
#pragma pack(1)
typedef struct VhdxVDiskSize
{
    /** Virtual disk size. */
    uint64_t    u64VDiskSize;
} VhdxVDiskSize;
#pragma pack()
/** Pointer to an on disk VHDX virtual disk size metadata item. */
typedef struct VhdxVDiskSize *PVhdxVDiskSize;

/**
 * VHDX page 83 data metadata item.
 */
#pragma pack(1)
typedef struct VhdxPage83Data
{
    /** UUID for the SCSI device. */
    RTUUID      UuidPage83Data;
} VhdxPage83Data;
#pragma pack()
/** Pointer to an on disk VHDX vpage 83 data metadata item. */
typedef struct VhdxPage83Data *PVhdxPage83Data;

/**
 * VHDX virtual disk logical sector size.
 */
#pragma pack(1)
typedef struct VhdxVDiskLogicalSectorSize
{
    /** Logical sector size. */
    uint32_t    u32LogicalSectorSize;
} VhdxVDiskLogicalSectorSize;
#pragma pack()
/** Pointer to an on disk VHDX virtual disk logical sector size metadata item. */
typedef struct VhdxVDiskLogicalSectorSize *PVhdxVDiskLogicalSectorSize;

/**
 * VHDX virtual disk physical sector size.
 */
#pragma pack(1)
typedef struct VhdxVDiskPhysicalSectorSize
{
    /** Physical sector size. */
    uint64_t    u64PhysicalSectorSize;
} VhdxVDiskPhysicalSectorSize;
#pragma pack()
/** Pointer to an on disk VHDX virtual disk physical sector size metadata item. */
typedef struct VhdxVDiskPhysicalSectorSize *PVhdxVDiskPhysicalSectorSize;

/**
 * VHDX parent locator header.
 */
#pragma pack(1)
typedef struct VhdxParentLocatorHeader
{
    /** Locator type UUID. */
    RTUUID      UuidLocatorType;
    /** Reserved. */
    uint16_t    u16Reserved;
    /** Number of key value pairs. */
    uint16_t    u16KeyValueCount;
} VhdxParentLocatorHeader;
#pragma pack()
/** Pointer to an on disk VHDX parent locator header metadata item. */
typedef struct VhdxParentLocatorHeader *PVhdxParentLocatorHeader;

/** VHDX parent locator type. */
#define VHDX_PARENT_LOCATOR_TYPE_VHDX "b04aefb7-d19e-4a81-b789-25b8e9445913"

/**
 * VHDX parent locator entry.
 */
#pragma pack(1)
typedef struct VhdxParentLocatorEntry
{
    /** Offset of the key. */
    uint32_t    u32KeyOffset;
    /** Offset of the value. */
    uint32_t    u32ValueOffset;
    /** Length of the key. */
    uint16_t    u16KeyLength;
    /** Length of the value. */
    uint16_t    u16ValueLength;
} VhdxParentLocatorEntry;
#pragma pack()
/** Pointer to an on disk VHDX parent locator entry. */
typedef struct VhdxParentLocatorEntry *PVhdxParentLocatorEntry;


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

typedef enum VHDXMETADATAITEM
{
    VHDXMETADATAITEM_UNKNOWN = 0,
    VHDXMETADATAITEM_FILE_PARAMS,
    VHDXMETADATAITEM_VDISK_SIZE,
    VHDXMETADATAITEM_PAGE83_DATA,
    VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE,
    VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE,
    VHDXMETADATAITEM_PARENT_LOCATOR,
    VHDXMETADATAITEM_32BIT_HACK = 0x7fffffff
} VHDXMETADATAITEM;

/**
 * Table to validate the metadata item UUIDs and the flags.
 */
typedef struct VHDXMETADATAITEMPROPS
{
    /** Item UUID. */
    const char          *pszItemUuid;
    /** Flag whether this is a user or system metadata item. */
    bool                 fIsUser;
    /** Flag whether this is a virtual disk or file metadata item. */
    bool                 fIsVDisk;
    /** Flag whether this metadata item is required to load the file. */
    bool                 fIsRequired;
    /** Metadata item enum associated with this UUID. */
    VHDXMETADATAITEM     enmMetadataItem;
} VHDXMETADATAITEMPROPS;

/**
 * VHDX image data structure.
 */
typedef struct VHDXIMAGE
{
    /** Image name. */
    const char         *pszFilename;
    /** Storage handle. */
    PVDIOSTORAGE        pStorage;

    /** Pointer to the per-disk VD interface list. */
    PVDINTERFACE        pVDIfsDisk;
    /** Pointer to the per-image VD interface list. */
    PVDINTERFACE        pVDIfsImage;
    /** Error interface. */
    PVDINTERFACEERROR   pIfError;
    /** I/O interface. */
    PVDINTERFACEIOINT   pIfIo;

    /** Open flags passed by VBoxHD layer. */
    unsigned            uOpenFlags;
    /** Image flags defined during creation or determined during open. */
    unsigned            uImageFlags;
    /** Version of the VHDX image format. */
    unsigned            uVersion;
    /** Total size of the image. */
    uint64_t            cbSize;
    /** Logical sector size of the image. */
    uint32_t            cbLogicalSector;
    /** Block size of the image. */
    size_t              cbBlock;
    /** Physical geometry of this image. */
    VDGEOMETRY          PCHSGeometry;
    /** Logical geometry of this image. */
    VDGEOMETRY          LCHSGeometry;

    /** The BAT. */
    PVhdxBatEntry       paBat;
    /** Chunk ratio. */
    uint32_t            uChunkRatio;

} VHDXIMAGE, *PVHDXIMAGE;

/**
 * Endianess conversion direction.
 */
typedef enum VHDXECONV
{
    /** Host to file endianess. */
    VHDXECONV_H2F = 0,
    /** File to host endianess. */
    VHDXECONV_F2H
} VHDXECONV;

/** Macros for endianess conversion. */
#define SET_ENDIAN_U16(u16) (enmConv == VHDXECONV_H2F ? RT_H2LE_U16(u16) : RT_LE2H_U16(u16))
#define SET_ENDIAN_U32(u32) (enmConv == VHDXECONV_H2F ? RT_H2LE_U32(u32) : RT_LE2H_U32(u32))
#define SET_ENDIAN_U64(u64) (enmConv == VHDXECONV_H2F ? RT_H2LE_U64(u64) : RT_LE2H_U64(u64))


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

/**
 * NULL-terminated array of supported file extensions.
 */
static const VDFILEEXTENSION s_aVhdxFileExtensions[] =
{
    {"vhdx", VDTYPE_HDD},
    {NULL, VDTYPE_INVALID}
};

/**
 * Static table to verify the metadata item properties and the flags.
 */
static const VHDXMETADATAITEMPROPS s_aVhdxMetadataItemProps[] =
{
    /* pcszItemUuid                               fIsUser, fIsVDisk, fIsRequired, enmMetadataItem */
    {VHDX_METADATA_TBL_ENTRY_ITEM_FILE_PARAMS,    false,   false,    true,        VHDXMETADATAITEM_FILE_PARAMS},
    {VHDX_METADATA_TBL_ENTRY_ITEM_VDISK_SIZE,     false,   true,     true,        VHDXMETADATAITEM_VDISK_SIZE},
    {VHDX_METADATA_TBL_ENTRY_ITEM_PAGE83_DATA,    false,   true,     true,        VHDXMETADATAITEM_PAGE83_DATA},
    {VHDX_METADATA_TBL_ENTRY_ITEM_LOG_SECT_SIZE,  false,   true,     true,        VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE},
    {VHDX_METADATA_TBL_ENTRY_ITEM_PHYS_SECT_SIZE, false,   true,     true,        VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE},
    {VHDX_METADATA_TBL_ENTRY_ITEM_PARENT_LOCATOR, false,   false,    true,        VHDXMETADATAITEM_PARENT_LOCATOR}
};


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

/**
 * Converts the file identifier between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pFileIdentifierConv Where to store the converted file identifier.
 * @param   pFileIdentifier     The file identifier to convert.
 *
 * @note It is safe to use the same pointer for pFileIdentifierConv and pFileIdentifier.
 */
DECLINLINE(void) vhdxConvFileIdentifierEndianess(VHDXECONV enmConv, PVhdxFileIdentifier pFileIdentifierConv,
                                                 PVhdxFileIdentifier pFileIdentifier)
{
    pFileIdentifierConv->u64Signature = SET_ENDIAN_U64(pFileIdentifier->u64Signature);
    for (unsigned i = 0; i < RT_ELEMENTS(pFileIdentifierConv->awszCreator); i++)
        pFileIdentifierConv->awszCreator[i] = SET_ENDIAN_U16(pFileIdentifier->awszCreator[i]);
}

/**
 * Converts a UUID between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pUuidConv           Where to store the converted UUID.
 * @param   pUuid               The UUID to convert.
 *
 * @note It is safe to use the same pointer for pUuidConv and pUuid.
 */
DECLINLINE(void) vhdxConvUuidEndianess(VHDXECONV enmConv, PRTUUID pUuidConv, PRTUUID pUuid)
{
    RT_NOREF1(enmConv);
#if 1
    memcpy(pUuidConv, pUuid, sizeof(RTUUID));
#else
    pUuidConv->Gen.u32TimeLow              = SET_ENDIAN_U32(pUuid->Gen.u32TimeLow);
    pUuidConv->Gen.u16TimeMid              = SET_ENDIAN_U16(pUuid->Gen.u16TimeMid);
    pUuidConv->Gen.u16TimeHiAndVersion     = SET_ENDIAN_U16(pUuid->Gen.u16TimeHiAndVersion);
    pUuidConv->Gen.u8ClockSeqHiAndReserved = pUuid->Gen.u8ClockSeqHiAndReserved;
    pUuidConv->Gen.u8ClockSeqLow           = pUuid->Gen.u8ClockSeqLow;
    for (unsigned i = 0; i < RT_ELEMENTS(pUuidConv->Gen.au8Node); i++)
        pUuidConv->Gen.au8Node[i] = pUuid->Gen.au8Node[i];
#endif
}

/**
 * Converts a VHDX header between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pHdrConv            Where to store the converted header.
 * @param   pHdr                The VHDX header to convert.
 *
 * @note It is safe to use the same pointer for pHdrConv and pHdr.
 */
DECLINLINE(void) vhdxConvHeaderEndianess(VHDXECONV enmConv, PVhdxHeader pHdrConv, PVhdxHeader pHdr)
{
    pHdrConv->u32Signature      = SET_ENDIAN_U32(pHdr->u32Signature);
    pHdrConv->u32Checksum       = SET_ENDIAN_U32(pHdr->u32Checksum);
    pHdrConv->u64SequenceNumber = SET_ENDIAN_U64(pHdr->u64SequenceNumber);
    vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidFileWrite, &pHdrConv->UuidFileWrite);
    vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidDataWrite, &pHdrConv->UuidDataWrite);
    vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidLog, &pHdrConv->UuidLog);
    pHdrConv->u16LogVersion     = SET_ENDIAN_U16(pHdr->u16LogVersion);
    pHdrConv->u16Version        = SET_ENDIAN_U16(pHdr->u16Version);
    pHdrConv->u32LogLength      = SET_ENDIAN_U32(pHdr->u32LogLength);
    pHdrConv->u64LogOffset      = SET_ENDIAN_U64(pHdr->u64LogOffset);
}

/**
 * Converts a VHDX region table header between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pRegTblHdrConv      Where to store the converted header.
 * @param   pRegTblHdr          The VHDX region table header to convert.
 *
 * @note It is safe to use the same pointer for pRegTblHdrConv and pRegTblHdr.
 */
DECLINLINE(void) vhdxConvRegionTblHdrEndianess(VHDXECONV enmConv, PVhdxRegionTblHdr pRegTblHdrConv,
                                               PVhdxRegionTblHdr pRegTblHdr)
{
    pRegTblHdrConv->u32Signature  = SET_ENDIAN_U32(pRegTblHdr->u32Signature);
    pRegTblHdrConv->u32Checksum   = SET_ENDIAN_U32(pRegTblHdr->u32Checksum);
    pRegTblHdrConv->u32EntryCount = SET_ENDIAN_U32(pRegTblHdr->u32EntryCount);
    pRegTblHdrConv->u32Reserved   = SET_ENDIAN_U32(pRegTblHdr->u32Reserved);
}

/**
 * Converts a VHDX region table entry between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pRegTblEntConv      Where to store the converted region table entry.
 * @param   pRegTblEnt          The VHDX region table entry to convert.
 *
 * @note It is safe to use the same pointer for pRegTblEntConv and pRegTblEnt.
 */
DECLINLINE(void) vhdxConvRegionTblEntryEndianess(VHDXECONV enmConv, PVhdxRegionTblEntry pRegTblEntConv,
                                                 PVhdxRegionTblEntry pRegTblEnt)
{
    vhdxConvUuidEndianess(enmConv, &pRegTblEntConv->UuidObject, &pRegTblEnt->UuidObject);
    pRegTblEntConv->u64FileOffset = SET_ENDIAN_U64(pRegTblEnt->u64FileOffset);
    pRegTblEntConv->u32Length     = SET_ENDIAN_U32(pRegTblEnt->u32Length);
    pRegTblEntConv->u32Flags      = SET_ENDIAN_U32(pRegTblEnt->u32Flags);
}

#if 0 /* unused */

/**
 * Converts a VHDX log entry header between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pLogEntryHdrConv    Where to store the converted log entry header.
 * @param   pLogEntryHdr        The VHDX log entry header to convert.
 *
 * @note It is safe to use the same pointer for pLogEntryHdrConv and pLogEntryHdr.
 */
DECLINLINE(void) vhdxConvLogEntryHdrEndianess(VHDXECONV enmConv, PVhdxLogEntryHdr pLogEntryHdrConv,
                                              PVhdxLogEntryHdr pLogEntryHdr)
{
    pLogEntryHdrConv->u32Signature         = SET_ENDIAN_U32(pLogEntryHdr->u32Signature);
    pLogEntryHdrConv->u32Checksum          = SET_ENDIAN_U32(pLogEntryHdr->u32Checksum);
    pLogEntryHdrConv->u32EntryLength       = SET_ENDIAN_U32(pLogEntryHdr->u32EntryLength);
    pLogEntryHdrConv->u32Tail              = SET_ENDIAN_U32(pLogEntryHdr->u32Tail);
    pLogEntryHdrConv->u64SequenceNumber    = SET_ENDIAN_U64(pLogEntryHdr->u64SequenceNumber);
    pLogEntryHdrConv->u32DescriptorCount   = SET_ENDIAN_U32(pLogEntryHdr->u32DescriptorCount);
    pLogEntryHdrConv->u32Reserved          = SET_ENDIAN_U32(pLogEntryHdr->u32Reserved);
    vhdxConvUuidEndianess(enmConv, &pLogEntryHdrConv->UuidLog, &pLogEntryHdr->UuidLog);
    pLogEntryHdrConv->u64FlushedFileOffset = SET_ENDIAN_U64(pLogEntryHdr->u64FlushedFileOffset);
}

/**
 * Converts a VHDX log zero descriptor between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pLogZeroDescConv    Where to store the converted log zero descriptor.
 * @param   pLogZeroDesc        The VHDX log zero descriptor to convert.
 *
 * @note It is safe to use the same pointer for pLogZeroDescConv and pLogZeroDesc.
 */
DECLINLINE(void) vhdxConvLogZeroDescEndianess(VHDXECONV enmConv, PVhdxLogZeroDesc pLogZeroDescConv,
                                              PVhdxLogZeroDesc pLogZeroDesc)
{
    pLogZeroDescConv->u32ZeroSignature  = SET_ENDIAN_U32(pLogZeroDesc->u32ZeroSignature);
    pLogZeroDescConv->u32Reserved       = SET_ENDIAN_U32(pLogZeroDesc->u32Reserved);
    pLogZeroDescConv->u64ZeroLength     = SET_ENDIAN_U64(pLogZeroDesc->u64ZeroLength);
    pLogZeroDescConv->u64FileOffset     = SET_ENDIAN_U64(pLogZeroDesc->u64FileOffset);
    pLogZeroDescConv->u64SequenceNumber = SET_ENDIAN_U64(pLogZeroDesc->u64SequenceNumber);
}


/**
 * Converts a VHDX log data descriptor between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pLogDataDescConv    Where to store the converted log data descriptor.
 * @param   pLogDataDesc        The VHDX log data descriptor to convert.
 *
 * @note It is safe to use the same pointer for pLogDataDescConv and pLogDataDesc.
 */
DECLINLINE(void) vhdxConvLogDataDescEndianess(VHDXECONV enmConv, PVhdxLogDataDesc pLogDataDescConv,
                                              PVhdxLogDataDesc pLogDataDesc)
{
    pLogDataDescConv->u32DataSignature  = SET_ENDIAN_U32(pLogDataDesc->u32DataSignature);
    pLogDataDescConv->u32TrailingBytes  = SET_ENDIAN_U32(pLogDataDesc->u32TrailingBytes);
    pLogDataDescConv->u64LeadingBytes   = SET_ENDIAN_U64(pLogDataDesc->u64LeadingBytes);
    pLogDataDescConv->u64FileOffset     = SET_ENDIAN_U64(pLogDataDesc->u64FileOffset);
    pLogDataDescConv->u64SequenceNumber = SET_ENDIAN_U64(pLogDataDesc->u64SequenceNumber);
}


/**
 * Converts a VHDX log data sector between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pLogDataSectorConv  Where to store the converted log data sector.
 * @param   pLogDataSector      The VHDX log data sector to convert.
 *
 * @note It is safe to use the same pointer for pLogDataSectorConv and pLogDataSector.
 */
DECLINLINE(void) vhdxConvLogDataSectorEndianess(VHDXECONV enmConv, PVhdxLogDataSector pLogDataSectorConv,
                                                PVhdxLogDataSector pLogDataSector)
{
    pLogDataSectorConv->u32DataSignature = SET_ENDIAN_U32(pLogDataSector->u32DataSignature);
    pLogDataSectorConv->u32SequenceHigh  = SET_ENDIAN_U32(pLogDataSector->u32SequenceHigh);
    pLogDataSectorConv->u32SequenceLow   = SET_ENDIAN_U32(pLogDataSector->u32SequenceLow);
}

#endif /* unused */

/**
 * Converts a BAT between file and host endianess.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   paBatEntriesConv    Where to store the converted BAT.
 * @param   paBatEntries        The VHDX BAT to convert.
 *
 * @note It is safe to use the same pointer for paBatEntriesConv and paBatEntries.
 */
DECLINLINE(void) vhdxConvBatTableEndianess(VHDXECONV enmConv, PVhdxBatEntry paBatEntriesConv,
                                           PVhdxBatEntry paBatEntries, uint32_t cBatEntries)
{
    for (uint32_t i = 0; i < cBatEntries; i++)
        paBatEntriesConv[i].u64BatEntry = SET_ENDIAN_U64(paBatEntries[i].u64BatEntry);
}

/**
 * Converts a VHDX metadata table header between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv             Direction of the conversion.
 * @param   pMetadataTblHdrConv Where to store the converted metadata table header.
 * @param   pMetadataTblHdr     The VHDX metadata table header to convert.
 *
 * @note It is safe to use the same pointer for pMetadataTblHdrConv and pMetadataTblHdr.
 */
DECLINLINE(void) vhdxConvMetadataTblHdrEndianess(VHDXECONV enmConv, PVhdxMetadataTblHdr pMetadataTblHdrConv,
                                                 PVhdxMetadataTblHdr pMetadataTblHdr)
{
    pMetadataTblHdrConv->u64Signature  = SET_ENDIAN_U64(pMetadataTblHdr->u64Signature);
    pMetadataTblHdrConv->u16Reserved   = SET_ENDIAN_U16(pMetadataTblHdr->u16Reserved);
    pMetadataTblHdrConv->u16EntryCount = SET_ENDIAN_U16(pMetadataTblHdr->u16EntryCount);
    for (unsigned i = 0; i < RT_ELEMENTS(pMetadataTblHdr->u32Reserved2); i++)
        pMetadataTblHdrConv->u32Reserved2[i] = SET_ENDIAN_U32(pMetadataTblHdr->u32Reserved2[i]);
}

/**
 * Converts a VHDX metadata table entry between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv               Direction of the conversion.
 * @param   pMetadataTblEntryConv Where to store the converted metadata table entry.
 * @param   pMetadataTblEntry     The VHDX metadata table entry to convert.
 *
 * @note It is safe to use the same pointer for pMetadataTblEntryConv and pMetadataTblEntry.
 */
DECLINLINE(void) vhdxConvMetadataTblEntryEndianess(VHDXECONV enmConv, PVhdxMetadataTblEntry pMetadataTblEntryConv,
                                                   PVhdxMetadataTblEntry pMetadataTblEntry)
{
    vhdxConvUuidEndianess(enmConv, &pMetadataTblEntryConv->UuidItem, &pMetadataTblEntry->UuidItem);
    pMetadataTblEntryConv->u32Offset   = SET_ENDIAN_U32(pMetadataTblEntry->u32Offset);
    pMetadataTblEntryConv->u32Length   = SET_ENDIAN_U32(pMetadataTblEntry->u32Length);
    pMetadataTblEntryConv->u32Flags    = SET_ENDIAN_U32(pMetadataTblEntry->u32Flags);
    pMetadataTblEntryConv->u32Reserved = SET_ENDIAN_U32(pMetadataTblEntry->u32Reserved);
}

/**
 * Converts a VHDX file parameters item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv               Direction of the conversion.
 * @param   pFileParamsConv       Where to store the converted file parameters item entry.
 * @param   pFileParams           The VHDX file parameters item to convert.
 *
 * @note It is safe to use the same pointer for pFileParamsConv and pFileParams.
 */
DECLINLINE(void) vhdxConvFileParamsEndianess(VHDXECONV enmConv, PVhdxFileParameters pFileParamsConv,
                                             PVhdxFileParameters pFileParams)
{
    pFileParamsConv->u32BlockSize = SET_ENDIAN_U32(pFileParams->u32BlockSize);
    pFileParamsConv->u32Flags     = SET_ENDIAN_U32(pFileParams->u32Flags);
}

/**
 * Converts a VHDX virtual disk size item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv               Direction of the conversion.
 * @param   pVDiskSizeConv        Where to store the converted virtual disk size item entry.
 * @param   pVDiskSize            The VHDX virtual disk size item to convert.
 *
 * @note It is safe to use the same pointer for pVDiskSizeConv and pVDiskSize.
 */
DECLINLINE(void) vhdxConvVDiskSizeEndianess(VHDXECONV enmConv, PVhdxVDiskSize pVDiskSizeConv,
                                            PVhdxVDiskSize pVDiskSize)
{
    pVDiskSizeConv->u64VDiskSize  = SET_ENDIAN_U64(pVDiskSize->u64VDiskSize);
}

#if 0 /* unused */

/**
 * Converts a VHDX page 83 data item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv               Direction of the conversion.
 * @param   pPage83DataConv       Where to store the converted page 83 data item entry.
 * @param   pPage83Data           The VHDX page 83 data item to convert.
 *
 * @note It is safe to use the same pointer for pPage83DataConv and pPage83Data.
 */
DECLINLINE(void) vhdxConvPage83DataEndianess(VHDXECONV enmConv, PVhdxPage83Data pPage83DataConv,
                                             PVhdxPage83Data pPage83Data)
{
    vhdxConvUuidEndianess(enmConv, &pPage83DataConv->UuidPage83Data, &pPage83Data->UuidPage83Data);
}
#endif /* unused */

/**
 * Converts a VHDX logical sector size item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv               Direction of the conversion.
 * @param   pVDiskLogSectSizeConv Where to store the converted logical sector size item entry.
 * @param   pVDiskLogSectSize     The VHDX logical sector size item to convert.
 *
 * @note It is safe to use the same pointer for pVDiskLogSectSizeConv and pVDiskLogSectSize.
 */
DECLINLINE(void) vhdxConvVDiskLogSectSizeEndianess(VHDXECONV enmConv, PVhdxVDiskLogicalSectorSize pVDiskLogSectSizeConv,
                                                   PVhdxVDiskLogicalSectorSize pVDiskLogSectSize)
{
    pVDiskLogSectSizeConv->u32LogicalSectorSize = SET_ENDIAN_U32(pVDiskLogSectSize->u32LogicalSectorSize);
}

#if 0 /* unused */

/**
 * Converts a VHDX physical sector size item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv                Direction of the conversion.
 * @param   pVDiskPhysSectSizeConv Where to store the converted physical sector size item entry.
 * @param   pVDiskPhysSectSize     The VHDX physical sector size item to convert.
 *
 * @note It is safe to use the same pointer for pVDiskPhysSectSizeConv and pVDiskPhysSectSize.
 */
DECLINLINE(void) vhdxConvVDiskPhysSectSizeEndianess(VHDXECONV enmConv, PVhdxVDiskPhysicalSectorSize pVDiskPhysSectSizeConv,
                                                    PVhdxVDiskPhysicalSectorSize pVDiskPhysSectSize)
{
    pVDiskPhysSectSizeConv->u64PhysicalSectorSize = SET_ENDIAN_U64(pVDiskPhysSectSize->u64PhysicalSectorSize);
}


/**
 * Converts a VHDX parent locator header item between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv                Direction of the conversion.
 * @param   pParentLocatorHdrConv  Where to store the converted parent locator header item entry.
 * @param   pParentLocatorHdr      The VHDX parent locator header item to convert.
 *
 * @note It is safe to use the same pointer for pParentLocatorHdrConv and pParentLocatorHdr.
 */
DECLINLINE(void) vhdxConvParentLocatorHeaderEndianness(VHDXECONV enmConv, PVhdxParentLocatorHeader pParentLocatorHdrConv,
                                                       PVhdxParentLocatorHeader pParentLocatorHdr)
{
    vhdxConvUuidEndianess(enmConv, &pParentLocatorHdrConv->UuidLocatorType, &pParentLocatorHdr->UuidLocatorType);
    pParentLocatorHdrConv->u16Reserved      = SET_ENDIAN_U16(pParentLocatorHdr->u16Reserved);
    pParentLocatorHdrConv->u16KeyValueCount = SET_ENDIAN_U16(pParentLocatorHdr->u16KeyValueCount);
}


/**
 * Converts a VHDX parent locator entry between file and host endianness.
 *
 * @returns nothing.
 * @param   enmConv                 Direction of the conversion.
 * @param   pParentLocatorEntryConv Where to store the converted parent locator entry.
 * @param   pParentLocatorEntry     The VHDX parent locator entry to convert.
 *
 * @note It is safe to use the same pointer for pParentLocatorEntryConv and pParentLocatorEntry.
 */
DECLINLINE(void) vhdxConvParentLocatorEntryEndianess(VHDXECONV enmConv, PVhdxParentLocatorEntry pParentLocatorEntryConv,
                                                     PVhdxParentLocatorEntry pParentLocatorEntry)
{
    pParentLocatorEntryConv->u32KeyOffset   = SET_ENDIAN_U32(pParentLocatorEntry->u32KeyOffset);
    pParentLocatorEntryConv->u32ValueOffset = SET_ENDIAN_U32(pParentLocatorEntry->u32ValueOffset);
    pParentLocatorEntryConv->u16KeyLength   = SET_ENDIAN_U16(pParentLocatorEntry->u16KeyLength);
    pParentLocatorEntryConv->u16ValueLength = SET_ENDIAN_U16(pParentLocatorEntry->u16ValueLength);
}

#endif /* unused */

/**
 * Internal. Free all allocated space for representing an image except pImage,
 * and optionally delete the image from disk.
 */
static int vhdxFreeImage(PVHDXIMAGE pImage, 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 (pImage)
    {
        if (pImage->pStorage)
        {
            rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
            pImage->pStorage = NULL;
        }

        if (pImage->paBat)
        {
            RTMemFree(pImage->paBat);
            pImage->paBat = NULL;
        }

        if (fDelete && pImage->pszFilename)
            vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
    }

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

/**
 * Loads all required fields from the given VHDX header.
 * The header must be converted to the host endianess and validated already.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   pHdr      The header to load.
 */
static int vhdxLoadHeader(PVHDXIMAGE pImage, PVhdxHeader pHdr)
{
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p pHdr=%#p\n", pImage, pHdr));

    /*
     * Most fields in the header are not required because the backend implements
     * readonly access only so far.
     * We just have to check that the log is empty, we have to refuse to load the
     * image otherwsie because replaying the log is not implemented.
     */
    if (pHdr->u16Version == VHDX_HEADER_VHDX_VERSION)
    {
        /* Check that the log UUID is zero. */
        pImage->uVersion = pHdr->u16Version;
        if (!RTUuidIsNull(&pHdr->UuidLog))
            rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                           "VHDX: Image \'%s\' has a non empty log which is not supported",
                           pImage->pszFilename);
    }
    else
        rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                       "VHDX: Image \'%s\' uses an unsupported version (%u) of the VHDX format",
                       pImage->pszFilename, pHdr->u16Version);

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

/**
 * Determines the current header and loads it.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 */
static int vhdxFindAndLoadCurrentHeader(PVHDXIMAGE pImage)
{
    PVhdxHeader pHdr1, pHdr2;
    uint32_t u32ChkSum = 0;
    uint32_t u32ChkSumSaved = 0;
    bool fHdr1Valid = false;
    bool fHdr2Valid = false;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p\n", pImage));

    /*
     * The VHDX format defines two headers at different offsets to provide failure
     * consistency. Only one header is current. This can be determined using the
     * sequence number and checksum fields in the header.
     */
    pHdr1 = (PVhdxHeader)RTMemAllocZ(sizeof(VhdxHeader));
    pHdr2 = (PVhdxHeader)RTMemAllocZ(sizeof(VhdxHeader));

    if (pHdr1 && pHdr2)
    {
        /* Read the first header. */
        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_HEADER1_OFFSET,
                                   pHdr1, sizeof(*pHdr1));
        if (RT_SUCCESS(rc))
        {
            vhdxConvHeaderEndianess(VHDXECONV_F2H, pHdr1, pHdr1);

            /* Validate checksum. */
            u32ChkSumSaved = pHdr1->u32Checksum;
            pHdr1->u32Checksum = 0;
            u32ChkSum = RTCrc32C(pHdr1, sizeof(VhdxHeader));

            if (   pHdr1->u32Signature == VHDX_HEADER_SIGNATURE
                && u32ChkSum == u32ChkSumSaved)
                fHdr1Valid = true;
        }

        /* Try to read the second header in any case (even if reading the first failed). */
        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_HEADER2_OFFSET,
                                   pHdr2, sizeof(*pHdr2));
        if (RT_SUCCESS(rc))
        {
            vhdxConvHeaderEndianess(VHDXECONV_F2H, pHdr2, pHdr2);

            /* Validate checksum. */
            u32ChkSumSaved = pHdr2->u32Checksum;
            pHdr2->u32Checksum = 0;
            u32ChkSum = RTCrc32C(pHdr2, sizeof(VhdxHeader));

            if (   pHdr2->u32Signature == VHDX_HEADER_SIGNATURE
                && u32ChkSum == u32ChkSumSaved)
                fHdr2Valid = true;
        }

        /* Determine the current header. */
        if (fHdr1Valid != fHdr2Valid)
        {
            /* Only one header is valid - use it. */
            rc = vhdxLoadHeader(pImage, fHdr1Valid ? pHdr1 : pHdr2);
        }
        else if (!fHdr1Valid && !fHdr2Valid)
        {
            /* Crap, both headers are corrupt, refuse to load the image. */
            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                           "VHDX: Can not load the image because both headers are corrupt");
        }
        else
        {
            /* Both headers are valid. Use the sequence number to find the current one. */
            if (pHdr1->u64SequenceNumber > pHdr2->u64SequenceNumber)
                rc = vhdxLoadHeader(pImage, pHdr1);
            else
                rc = vhdxLoadHeader(pImage, pHdr2);
        }
    }
    else
        rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
                       "VHDX: Out of memory while allocating memory for the header");

    if (pHdr1)
        RTMemFree(pHdr1);
    if (pHdr2)
        RTMemFree(pHdr2);

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

/**
 * Loads the BAT region.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   offRegion Start offset of the region.
 * @param   cbRegion  Size of the region.
 */
static int vhdxLoadBatRegion(PVHDXIMAGE pImage, uint64_t offRegion,
                             size_t cbRegion)
{
    int rc = VINF_SUCCESS;
    uint32_t cDataBlocks;
    uint32_t uChunkRatio;
    uint32_t cSectorBitmapBlocks;
    uint32_t cBatEntries;
    uint32_t cbBatEntries;
    PVhdxBatEntry paBatEntries = NULL;

    LogFlowFunc(("pImage=%#p\n", pImage));

    /* Calculate required values first. */
    uint64_t uChunkRatio64 = (RT_BIT_64(23) * pImage->cbLogicalSector) / pImage->cbBlock;
    uChunkRatio = (uint32_t)uChunkRatio64; Assert(uChunkRatio == uChunkRatio64);
    uint64_t cDataBlocks64 = pImage->cbSize / pImage->cbBlock;
    cDataBlocks = (uint32_t)cDataBlocks64; Assert(cDataBlocks == cDataBlocks64);

    if (pImage->cbSize % pImage->cbBlock)
        cDataBlocks++;

    cSectorBitmapBlocks = cDataBlocks / uChunkRatio;
    if (cDataBlocks % uChunkRatio)
        cSectorBitmapBlocks++;

    cBatEntries = cDataBlocks + (cDataBlocks - 1)/uChunkRatio;
    cbBatEntries = cBatEntries * sizeof(VhdxBatEntry);

    if (cbBatEntries <= cbRegion)
    {
        /*
         * Load the complete BAT region first, convert to host endianess and process
         * it afterwards. The SB entries can be removed because they are not needed yet.
         */
        paBatEntries = (PVhdxBatEntry)RTMemAlloc(cbBatEntries);
        if (paBatEntries)
        {
            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offRegion,
                                       paBatEntries, cbBatEntries);
            if (RT_SUCCESS(rc))
            {
                vhdxConvBatTableEndianess(VHDXECONV_F2H, paBatEntries, paBatEntries,
                                          cBatEntries);

                /* Go through the table and validate it. */
                for (unsigned i = 0; i < cBatEntries; i++)
                {
                    if (   i != 0
                        && (i % uChunkRatio) == 0)
                    {
/**
 * Disabled the verification because there are images out there with the sector bitmap
 * marked as present. The entry is never accessed and the image is readonly anyway,
 * so no harm done.
 */
#if 0
                        /* Sector bitmap block. */
                        if (   VHDX_BAT_ENTRY_GET_STATE(paBatEntries[i].u64BatEntry)
                            != VHDX_BAT_ENTRY_SB_BLOCK_NOT_PRESENT)
                        {
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: Sector bitmap block at entry %u of image \'%s\' marked as present, violation of the specification",
                                           i, pImage->pszFilename);
                            break;
                        }
#endif
                    }
                    else
                    {
                        /* Payload block. */
                        if (   VHDX_BAT_ENTRY_GET_STATE(paBatEntries[i].u64BatEntry)
                            == VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT)
                        {
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: Payload block at entry %u of image \'%s\' marked as partially present, violation of the specification",
                                           i, pImage->pszFilename);
                            break;
                        }
                    }
                }

                if (RT_SUCCESS(rc))
                {
                    pImage->paBat       = paBatEntries;
                    pImage->uChunkRatio = uChunkRatio;
                }
            }
            else
                rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                               "VHDX: Error reading the BAT from image \'%s\'",
                               pImage->pszFilename);
        }
        else
            rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
                           "VHDX: Out of memory allocating memory for %u BAT entries of image \'%s\'",
                           cBatEntries, pImage->pszFilename);
    }
    else
        rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                       "VHDX: Mismatch between calculated number of BAT entries and region size (expected %u got %u) for image \'%s\'",
                       cbBatEntries, cbRegion, pImage->pszFilename);

    if (   RT_FAILURE(rc)
        && paBatEntries)
        RTMemFree(paBatEntries);

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

/**
 * Load the file parameters metadata item from the file.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   offItem   File offset where the data is stored.
 * @param   cbItem    Size of the item in the file.
 */
static int vhdxLoadFileParametersMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
{
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));

    if (cbItem != sizeof(VhdxFileParameters))
        rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                       "VHDX: File parameters item size mismatch (expected %u got %zu) in image \'%s\'",
                       sizeof(VhdxFileParameters), cbItem, pImage->pszFilename);
    else
    {
        VhdxFileParameters FileParameters;

        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
                                   &FileParameters, sizeof(FileParameters));
        if (RT_SUCCESS(rc))
        {
            vhdxConvFileParamsEndianess(VHDXECONV_F2H, &FileParameters, &FileParameters);
            pImage->cbBlock = FileParameters.u32BlockSize;

            /** @todo No support for differencing images yet. */
            if (FileParameters.u32Flags & VHDX_FILE_PARAMETERS_FLAGS_HAS_PARENT)
                rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                               "VHDX: Image \'%s\' is a differencing image which is not supported yet",
                               pImage->pszFilename);
        }
        else
            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                           "VHDX: Reading the file parameters metadata item from image \'%s\' failed",
                           pImage->pszFilename);
    }

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

/**
 * Load the virtual disk size metadata item from the file.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   offItem   File offset where the data is stored.
 * @param   cbItem    Size of the item in the file.
 */
static int vhdxLoadVDiskSizeMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
{
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));

    if (cbItem != sizeof(VhdxVDiskSize))
        rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                       "VHDX: Virtual disk size item size mismatch (expected %u got %zu) in image \'%s\'",
                       sizeof(VhdxVDiskSize), cbItem, pImage->pszFilename);
    else
    {
        VhdxVDiskSize VDiskSize;

        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
                                   &VDiskSize, sizeof(VDiskSize));
        if (RT_SUCCESS(rc))
        {
            vhdxConvVDiskSizeEndianess(VHDXECONV_F2H, &VDiskSize, &VDiskSize);
            pImage->cbSize = VDiskSize.u64VDiskSize;
        }
        else
            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                           "VHDX: Reading the virtual disk size metadata item from image \'%s\' failed",
                           pImage->pszFilename);
    }

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

/**
 * Load the logical sector size metadata item from the file.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   offItem   File offset where the data is stored.
 * @param   cbItem    Size of the item in the file.
 */
static int vhdxLoadVDiskLogSectorSizeMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
{
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));

    if (cbItem != sizeof(VhdxVDiskLogicalSectorSize))
        rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                       "VHDX: Virtual disk logical sector size item size mismatch (expected %u got %zu) in image \'%s\'",
                       sizeof(VhdxVDiskLogicalSectorSize), cbItem, pImage->pszFilename);
    else
    {
        VhdxVDiskLogicalSectorSize VDiskLogSectSize;

        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
                                   &VDiskLogSectSize, sizeof(VDiskLogSectSize));
        if (RT_SUCCESS(rc))
        {
            vhdxConvVDiskLogSectSizeEndianess(VHDXECONV_F2H, &VDiskLogSectSize,
                                              &VDiskLogSectSize);
            pImage->cbLogicalSector = VDiskLogSectSize.u32LogicalSectorSize;
        }
        else
            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                           "VHDX: Reading the virtual disk logical sector size metadata item from image \'%s\' failed",
                           pImage->pszFilename);
    }

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

/**
 * Loads the metadata region.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 * @param   offRegion Start offset of the region.
 * @param   cbRegion  Size of the region.
 */
static int vhdxLoadMetadataRegion(PVHDXIMAGE pImage, uint64_t offRegion,
                                  size_t cbRegion)
{
    VhdxMetadataTblHdr MetadataTblHdr;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p\n", pImage));

    /* Load the header first. */
    rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offRegion,
                               &MetadataTblHdr, sizeof(MetadataTblHdr));
    if (RT_SUCCESS(rc))
    {
        vhdxConvMetadataTblHdrEndianess(VHDXECONV_F2H, &MetadataTblHdr, &MetadataTblHdr);

        /* Validate structure. */
        if (MetadataTblHdr.u64Signature != VHDX_METADATA_TBL_HDR_SIGNATURE)
            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                           "VHDX: Incorrect metadata table header signature for image \'%s\'",
                           pImage->pszFilename);
        else if (MetadataTblHdr.u16EntryCount > VHDX_METADATA_TBL_HDR_ENTRY_COUNT_MAX)
            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                           "VHDX: Incorrect entry count in metadata table header of image \'%s\'",
                           pImage->pszFilename);
        else if (cbRegion < (MetadataTblHdr.u16EntryCount * sizeof(VhdxMetadataTblEntry) + sizeof(VhdxMetadataTblHdr)))
            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                           "VHDX: Metadata table of image \'%s\' exceeds region size",
                           pImage->pszFilename);

        if (RT_SUCCESS(rc))
        {
            uint64_t offMetadataTblEntry = offRegion + sizeof(VhdxMetadataTblHdr);

            for (unsigned i = 0; i < MetadataTblHdr.u16EntryCount; i++)
            {
                uint64_t offMetadataItem = 0;
                VHDXMETADATAITEM enmMetadataItem = VHDXMETADATAITEM_UNKNOWN;
                VhdxMetadataTblEntry MetadataTblEntry;

                rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offMetadataTblEntry,
                                           &MetadataTblEntry, sizeof(MetadataTblEntry));
                if (RT_FAILURE(rc))
                {
                    rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                                   "VHDX: Reading metadata table entry from image \'%s\' failed",
                                   pImage->pszFilename);
                    break;
                }

                vhdxConvMetadataTblEntryEndianess(VHDXECONV_F2H, &MetadataTblEntry, &MetadataTblEntry);

                /* Check whether the flags match the expectations. */
                for (unsigned idxProp = 0; idxProp < RT_ELEMENTS(s_aVhdxMetadataItemProps); idxProp++)
                {
                    if (!RTUuidCompareStr(&MetadataTblEntry.UuidItem,
                                          s_aVhdxMetadataItemProps[idxProp].pszItemUuid))
                    {
                        /*
                         * Check for specification violations and bail out, except
                         * for the required flag of the physical sector size metadata item.
                         * Early images had the required flag not set opposed to the specification.
                         * We don't want to brerak those images.
                         */
                        if (   !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_USER)
                            != s_aVhdxMetadataItemProps[idxProp].fIsUser)
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: User flag of metadata item does not meet expectations \'%s\'",
                                           pImage->pszFilename);
                        else if (   !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_VDISK)
                                 != s_aVhdxMetadataItemProps[idxProp].fIsVDisk)
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: Virtual disk flag of metadata item does not meet expectations \'%s\'",
                                           pImage->pszFilename);
                        else if (      !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED)
                                    != s_aVhdxMetadataItemProps[idxProp].fIsRequired
                                 && (s_aVhdxMetadataItemProps[idxProp].enmMetadataItem != VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE))
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: Required flag of metadata item does not meet expectations \'%s\'",
                                           pImage->pszFilename);
                        else
                            enmMetadataItem = s_aVhdxMetadataItemProps[idxProp].enmMetadataItem;

                        break;
                    }
                }

                if (RT_FAILURE(rc))
                    break;

                offMetadataItem = offRegion + MetadataTblEntry.u32Offset;

                switch (enmMetadataItem)
                {
                    case VHDXMETADATAITEM_FILE_PARAMS:
                    {
                        rc = vhdxLoadFileParametersMetadata(pImage, offMetadataItem,
                                                            MetadataTblEntry.u32Length);
                        break;
                    }
                    case VHDXMETADATAITEM_VDISK_SIZE:
                    {
                        rc = vhdxLoadVDiskSizeMetadata(pImage, offMetadataItem,
                                                       MetadataTblEntry.u32Length);
                        break;
                    }
                    case VHDXMETADATAITEM_PAGE83_DATA:
                    {
                        /*
                         * Nothing to do here for now (marked as required but
                         * there is no API to pass this information to the caller)
                         * so far.
                         */
                        break;
                    }
                    case VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE:
                    {
                        rc = vhdxLoadVDiskLogSectorSizeMetadata(pImage, offMetadataItem,
                                                                MetadataTblEntry.u32Length);
                        break;
                    }
                    case VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE:
                    {
                        /*
                         * Nothing to do here for now (marked as required but
                         * there is no API to pass this information to the caller)
                         * so far.
                         */
                        break;
                    }
                    case VHDXMETADATAITEM_PARENT_LOCATOR:
                    {
                        rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                                       "VHDX: Image \'%s\' is a differencing image which is not supported yet",
                                       pImage->pszFilename);
                        break;
                    }
                    case VHDXMETADATAITEM_UNKNOWN:
                    default:
                        if (MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED)
                            rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                                           "VHDX: Unsupported but required metadata item in image \'%s\'",
                                           pImage->pszFilename);
                }

                if (RT_FAILURE(rc))
                    break;

                offMetadataTblEntry += sizeof(MetadataTblEntry);
            }
        }
    }
    else
        rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                       "VHDX: Reading the metadata table header for image \'%s\' failed",
                       pImage->pszFilename);

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

/**
 * Loads the region table and the associated regions.
 *
 * @returns VBox status code.
 * @param   pImage    Image instance data.
 */
static int vhdxLoadRegionTable(PVHDXIMAGE pImage)
{
    uint8_t *pbRegionTbl = NULL;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p\n", pImage));

    /* Load the complete region table into memory. */
    pbRegionTbl = (uint8_t *)RTMemTmpAlloc(VHDX_REGION_TBL_SIZE_MAX);
    if (pbRegionTbl)
    {
        rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_REGION_TBL_HDR_OFFSET,
                                   pbRegionTbl, VHDX_REGION_TBL_SIZE_MAX);
        if (RT_SUCCESS(rc))
        {
            PVhdxRegionTblHdr pRegionTblHdr;
            VhdxRegionTblHdr RegionTblHdr;
            uint32_t u32ChkSum = 0;

            /*
             * Copy the region table header to a dedicated structure where we can
             * convert it to host endianess.
             */
            memcpy(&RegionTblHdr, pbRegionTbl, sizeof(RegionTblHdr));
            vhdxConvRegionTblHdrEndianess(VHDXECONV_F2H, &RegionTblHdr, &RegionTblHdr);

            /* Set checksum field to 0 during crc computation. */
            pRegionTblHdr = (PVhdxRegionTblHdr)pbRegionTbl;
            pRegionTblHdr->u32Checksum = 0;

            /* Verify the region table integrity. */
            u32ChkSum = RTCrc32C(pbRegionTbl, VHDX_REGION_TBL_SIZE_MAX);

            if (RegionTblHdr.u32Signature != VHDX_REGION_TBL_HDR_SIGNATURE)
                rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                               "VHDX: Invalid signature for region table header of image \'%s\'",
                               pImage->pszFilename);
            else if (u32ChkSum != RegionTblHdr.u32Checksum)
                rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                               "VHDX: CRC32 checksum mismatch for the region table of image \'%s\' (expected %#x got %#x)",
                               pImage->pszFilename, RegionTblHdr.u32Checksum, u32ChkSum);
            else if (RegionTblHdr.u32EntryCount > VHDX_REGION_TBL_HDR_ENTRY_COUNT_MAX)
                rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                               "VHDX: Invalid entry count field in the region table header of image \'%s\'",
                               pImage->pszFilename);

            if (RT_SUCCESS(rc))
            {
                /* Parse the region table entries. */
                PVhdxRegionTblEntry pRegTblEntry = (PVhdxRegionTblEntry)(pbRegionTbl + sizeof(VhdxRegionTblHdr));
                VhdxRegionTblEntry RegTblEntryBat; /* BAT region table entry. */
                bool fBatRegPresent = false;
                RT_ZERO(RegTblEntryBat); /* Maybe uninitialized, gcc. */

                for (unsigned i = 0; i < RegionTblHdr.u32EntryCount; i++)
                {
                    vhdxConvRegionTblEntryEndianess(VHDXECONV_F2H, pRegTblEntry, pRegTblEntry);

                    /* Check the uuid for known regions. */
                    if (!RTUuidCompareStr(&pRegTblEntry->UuidObject, VHDX_REGION_TBL_ENTRY_UUID_BAT))
                    {
                        /*
                         * Save the BAT region and process it later.
                         * It may come before the metadata region but needs the block size.
                         */
                        if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
                        {
                            fBatRegPresent = true;
                            RegTblEntryBat.u32Length = pRegTblEntry->u32Length;
                            RegTblEntryBat.u64FileOffset = pRegTblEntry->u64FileOffset;
                        }
                        else
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: BAT region not marked as required in image \'%s\'",
                                           pImage->pszFilename);
                    }
                    else if (!RTUuidCompareStr(&pRegTblEntry->UuidObject, VHDX_REGION_TBL_ENTRY_UUID_METADATA))
                    {
                        if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
                            rc = vhdxLoadMetadataRegion(pImage, pRegTblEntry->u64FileOffset, pRegTblEntry->u32Length);
                        else
                            rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                           "VHDX: Metadata region not marked as required in image \'%s\'",
                                           pImage->pszFilename);
                    }
                    else if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
                    {
                        /* The region is not known but marked as required, fail to load the image. */
                        rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
                                       "VHDX: Unknown required region in image \'%s\'",
                                       pImage->pszFilename);
                    }

                    if (RT_FAILURE(rc))
                        break;

                    pRegTblEntry++;
                }

                if (fBatRegPresent)
                    rc = vhdxLoadBatRegion(pImage, RegTblEntryBat.u64FileOffset, RegTblEntryBat.u32Length);
                else
                    rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
                                   "VHDX: BAT region in image \'%s\' is missing",
                                   pImage->pszFilename);
            }
        }
        else
            rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
                           "VHDX: Reading the region table for image \'%s\' failed",
                           pImage->pszFilename);
    }
    else
        rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
                       "VHDX: Out of memory allocating memory for the region table of image \'%s\'",
                       pImage->pszFilename);

    if (pbRegionTbl)
        RTMemTmpFree(pbRegionTbl);

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

/**
 * Internal: Open an image, constructing all necessary data structures.
 */
static int vhdxOpenImage(PVHDXIMAGE pImage, unsigned uOpenFlags)
{
    uint64_t cbFile = 0;
    VhdxFileIdentifier FileIdentifier;
    int rc = VINF_SUCCESS;

    LogFlowFunc(("pImage=%#p uOpenFlags=%#x\n", pImage, uOpenFlags));
    pImage->uOpenFlags = uOpenFlags;

    pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
    pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
    AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);

    /* Refuse write access, it is not implemented so far. */
    if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
        return VERR_NOT_SUPPORTED;

    /*
     * Open the image.
     */
    rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
                           VDOpenFlagsToFileOpenFlags(uOpenFlags,
                                                      false /* fCreate */),
                           &pImage->pStorage);

    /* Do NOT signal an appropriate error here, as the VD layer has the
     * choice of retrying the open if it failed. */
    if (RT_SUCCESS(rc))
        rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);

    if (RT_SUCCESS(rc))
    {
        if (cbFile > sizeof(FileIdentifier))
        {
            rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_FILE_IDENTIFIER_OFFSET,
                                       &FileIdentifier, sizeof(FileIdentifier));
            if (RT_SUCCESS(rc))
            {
                vhdxConvFileIdentifierEndianess(VHDXECONV_F2H, &FileIdentifier,
                                                &FileIdentifier);
                if (FileIdentifier.u64Signature != VHDX_FILE_IDENTIFIER_SIGNATURE)
                    rc = VERR_VD_GEN_INVALID_HEADER;
                else
                    rc = vhdxFindAndLoadCurrentHeader(pImage);

                /* Load the region table. */
                if (RT_SUCCESS(rc))
                    rc = vhdxLoadRegionTable(pImage);
            }
        }
        else
            rc = VERR_VD_GEN_INVALID_HEADER;
    }

    if (RT_FAILURE(rc))
        vhdxFreeImage(pImage, false);

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


/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
static DECLCALLBACK(int) vhdxCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
                                          PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
{
    RT_NOREF1(pVDIfsDisk);
    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
    PVDIOSTORAGE pStorage = NULL;
    uint64_t cbFile;
    int rc = VINF_SUCCESS;
    VhdxFileIdentifier FileIdentifier;

    PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);

    if (   !VALID_PTR(pszFilename)
        || !*pszFilename)
        rc = VERR_INVALID_PARAMETER;
    else
    {
        /*
         * Open the file and read the file identifier.
         */
        rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
                               VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
                                                          false /* fCreate */),
                               &pStorage);
        if (RT_SUCCESS(rc))
        {
            rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
            if (RT_SUCCESS(rc))
            {
                if (cbFile > sizeof(FileIdentifier))
                {
                    rc = vdIfIoIntFileReadSync(pIfIo, pStorage, VHDX_FILE_IDENTIFIER_OFFSET,
                                               &FileIdentifier, sizeof(FileIdentifier));
                    if (RT_SUCCESS(rc))
                    {
                        vhdxConvFileIdentifierEndianess(VHDXECONV_F2H, &FileIdentifier,
                                                        &FileIdentifier);
                        if (FileIdentifier.u64Signature != VHDX_FILE_IDENTIFIER_SIGNATURE)
                            rc = VERR_VD_GEN_INVALID_HEADER;
                        else
                            *penmType = VDTYPE_HDD;
                    }
                }
                else
                    rc = VERR_VD_GEN_INVALID_HEADER;
            }
        }

        if (pStorage)
            vdIfIoIntFileClose(pIfIo, pStorage);
    }

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

/** @copydoc VBOXHDDBACKEND::pfnOpen */
static DECLCALLBACK(int) vhdxOpen(const char *pszFilename, unsigned uOpenFlags,
                                  PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
                                  VDTYPE enmType, void **ppBackendData)
{
    LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
    int rc;
    PVHDXIMAGE pImage;

    NOREF(enmType); /**< @todo r=klaus make use of the type info. */

    /* Check open flags. All valid flags are supported. */
    if (   uOpenFlags & ~VD_OPEN_FLAGS_MASK
        || !VALID_PTR(pszFilename)
        || !*pszFilename)
        rc = VERR_INVALID_PARAMETER;
    else
    {
        pImage = (PVHDXIMAGE)RTMemAllocZ(sizeof(VHDXIMAGE));
        if (!pImage)
            rc = VERR_NO_MEMORY;
        else
        {
            pImage->pszFilename = pszFilename;
            pImage->pStorage = NULL;
            pImage->pVDIfsDisk = pVDIfsDisk;
            pImage->pVDIfsImage = pVDIfsImage;

            rc = vhdxOpenImage(pImage, uOpenFlags);
            if (RT_SUCCESS(rc))
                *ppBackendData = pImage;
            else
                RTMemFree(pImage);
        }
    }

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

/** @interface_method_impl{VBOXHDDBACKEND,pfnCreate} */
static DECLCALLBACK(int) vhdxCreate(const char *pszFilename, uint64_t cbSize,
                                    unsigned uImageFlags, const char *pszComment,
                                    PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
                                    PCRTUUID pUuid, unsigned uOpenFlags,
                                    unsigned uPercentStart, unsigned uPercentSpan,
                                    PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
                                    PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
                                    void **ppBackendData)
{
    RT_NOREF8(pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags);
    RT_NOREF7(uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData);
    LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%u ppBackendData=%#p",
                 pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
    int rc = VERR_NOT_SUPPORTED;

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

/** @copydoc VBOXHDDBACKEND::pfnRename */
static DECLCALLBACK(int) vhdxRename(void *pBackendData, const char *pszFilename)
{
    LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
    int rc = VINF_SUCCESS;
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;

    /* Check arguments. */
    if (   !pImage
        || !pszFilename
        || !*pszFilename)
        rc = VERR_INVALID_PARAMETER;
    else
    {
        /* Close the image. */
        rc = vhdxFreeImage(pImage, false);
        if (RT_SUCCESS(rc))
        {
            /* Rename the file. */
            rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
            if (RT_FAILURE(rc))
            {
                /* The move failed, try to reopen the original image. */
                int rc2 = vhdxOpenImage(pImage, pImage->uOpenFlags);
                if (RT_FAILURE(rc2))
                    rc = rc2;
            }
            else
            {
                /* Update pImage with the new information. */
                pImage->pszFilename = pszFilename;

                /* Open the old image with new name. */
                rc = vhdxOpenImage(pImage, pImage->uOpenFlags);
            }
        }
    }

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

/** @copydoc VBOXHDDBACKEND::pfnClose */
static DECLCALLBACK(int) vhdxClose(void *pBackendData, bool fDelete)
{
    LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    rc = vhdxFreeImage(pImage, fDelete);
    RTMemFree(pImage);

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

/** @copydoc VBOXHDDBACKEND::pfnRead */
static DECLCALLBACK(int) vhdxRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
                                  PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
{
    LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
                 pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc = VINF_SUCCESS;

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

    if (   uOffset + cbToRead > pImage->cbSize
        || cbToRead == 0)
        rc = VERR_INVALID_PARAMETER;
    else
    {
        uint32_t idxBat = (uint32_t)(uOffset / pImage->cbBlock); Assert(idxBat == uOffset / pImage->cbBlock);
        uint32_t offRead = uOffset % pImage->cbBlock;
        uint64_t uBatEntry;

        idxBat += idxBat / pImage->uChunkRatio; /* Add interleaving sector bitmap entries. */
        uBatEntry = pImage->paBat[idxBat].u64BatEntry;

        cbToRead = RT_MIN(cbToRead, pImage->cbBlock - offRead);

        switch (VHDX_BAT_ENTRY_GET_STATE(uBatEntry))
        {
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_NOT_PRESENT:
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNDEFINED:
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_ZERO:
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNMAPPED:
            {
                vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
                break;
            }
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_FULLY_PRESENT:
            {
                uint64_t offFile = VHDX_BAT_ENTRY_GET_FILE_OFFSET(uBatEntry) + offRead;
                rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, offFile,
                                           pIoCtx, cbToRead);
                break;
            }
            case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT:
            default:
                rc = VERR_INVALID_PARAMETER;
                break;
        }

        if (pcbActuallyRead)
            *pcbActuallyRead = cbToRead;
    }

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

/** @copydoc VBOXHDDBACKEND::pfnWrite */
static DECLCALLBACK(int) vhdxWrite(void *pBackendData, uint64_t uOffset,  size_t cbToWrite,
                                   PVDIOCTX pIoCtx, size_t *pcbWriteProcess, size_t *pcbPreRead,
                                   size_t *pcbPostRead, unsigned fWrite)
{
    RT_NOREF5(pIoCtx, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
    LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
                 pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

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

    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
        rc = VERR_VD_IMAGE_READ_ONLY;
    else if (   uOffset + cbToWrite > pImage->cbSize
             || cbToWrite == 0)
        rc = VERR_INVALID_PARAMETER;
    else
        rc = VERR_NOT_SUPPORTED;

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

/** @copydoc VBOXHDDBACKEND::pfnFlush */
static DECLCALLBACK(int) vhdxFlush(void *pBackendData, PVDIOCTX pIoCtx)
{
    RT_NOREF1(pIoCtx);
    LogFlowFunc(("pBackendData=%#p pIoCtx=%#p\n", pBackendData, pIoCtx));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
        rc = VERR_VD_IMAGE_READ_ONLY;
    else
        rc = VERR_NOT_SUPPORTED;

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

/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
static DECLCALLBACK(unsigned) vhdxGetVersion(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;

    AssertPtr(pImage);

    if (pImage)
        return pImage->uVersion;
    else
        return 0;
}

/** @copydoc VBOXHDDBACKEND::pfnGetSectorSize */
static DECLCALLBACK(uint32_t) vhdxGetSectorSize(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    uint32_t cb = 0;

    AssertPtr(pImage);

    if (pImage && pImage->pStorage)
        cb = pImage->cbLogicalSector;

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

/** @copydoc VBOXHDDBACKEND::pfnGetSize */
static DECLCALLBACK(uint64_t) vhdxGetSize(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    uint64_t cb = 0;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
static DECLCALLBACK(uint64_t) vhdxGetFileSize(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    uint64_t cb = 0;

    AssertPtr(pImage);

    if (pImage)
    {
        uint64_t cbFile;
        if (pImage->pStorage)
        {
            int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
            if (RT_SUCCESS(rc))
                cb = cbFile;
        }
    }

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

/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
static DECLCALLBACK(int) vhdxGetPCHSGeometry(void *pBackendData,
                                             PVDGEOMETRY pPCHSGeometry)
{
    LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

    if (pImage)
    {
        if (pImage->PCHSGeometry.cCylinders)
        {
            *pPCHSGeometry = pImage->PCHSGeometry;
            rc = VINF_SUCCESS;
        }
        else
            rc = VERR_VD_GEOMETRY_NOT_SET;
    }
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
    return rc;
}

/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
static DECLCALLBACK(int) vhdxSetPCHSGeometry(void *pBackendData,
                                             PCVDGEOMETRY pPCHSGeometry)
{
    LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc = VINF_SUCCESS;

    AssertPtr(pImage);

    if (pImage)
    {
        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
            rc = VERR_VD_IMAGE_READ_ONLY;
        else
            pImage->PCHSGeometry = *pPCHSGeometry;
    }
    else
        rc = VERR_VD_NOT_OPENED;

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

/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
static DECLCALLBACK(int) vhdxGetLCHSGeometry(void *pBackendData,
                                             PVDGEOMETRY pLCHSGeometry)
{
     LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc = VINF_SUCCESS;

    AssertPtr(pImage);

    if (pImage)
    {
        if (pImage->LCHSGeometry.cCylinders)
            *pLCHSGeometry = pImage->LCHSGeometry;
        else
            rc = VERR_VD_GEOMETRY_NOT_SET;
    }
    else
        rc = VERR_VD_NOT_OPENED;

    LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
    return rc;
}

/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
static DECLCALLBACK(int) vhdxSetLCHSGeometry(void *pBackendData,
                                             PCVDGEOMETRY pLCHSGeometry)
{
    LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc = VINF_SUCCESS;

    AssertPtr(pImage);

    if (pImage)
    {
        if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
            rc = VERR_VD_IMAGE_READ_ONLY;
        else
            pImage->LCHSGeometry = *pLCHSGeometry;
    }
    else
        rc = VERR_VD_NOT_OPENED;

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

/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
static DECLCALLBACK(unsigned) vhdxGetImageFlags(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    unsigned uImageFlags;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
static DECLCALLBACK(unsigned) vhdxGetOpenFlags(void *pBackendData)
{
    LogFlowFunc(("pBackendData=%#p\n", pBackendData));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    unsigned uOpenFlags;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
static DECLCALLBACK(int) vhdxSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
{
    LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc = VINF_SUCCESS;

    /* Image must be opened and the new flags must be valid. */
    if (!pImage || (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY | VD_OPEN_FLAGS_INFO | VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
        rc = VERR_INVALID_PARAMETER;
    else
    {
        /* Implement this operation via reopening the image. */
        rc = vhdxFreeImage(pImage, false);
        if (RT_SUCCESS(rc))
            rc = vhdxOpenImage(pImage, uOpenFlags);
    }

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

/** @copydoc VBOXHDDBACKEND::pfnGetComment */
static DECLCALLBACK(int) vhdxGetComment(void *pBackendData, char *pszComment,
                                        size_t cbComment)
{
    RT_NOREF2(pszComment, cbComment);
    LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetComment */
static DECLCALLBACK(int) vhdxSetComment(void *pBackendData, const char *pszComment)
{
    RT_NOREF1(pszComment);
    LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
static DECLCALLBACK(int) vhdxGetUuid(void *pBackendData, PRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
static DECLCALLBACK(int) vhdxSetUuid(void *pBackendData, PCRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

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

    if (pImage)
    {
        if (!(pImage->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 VBOXHDDBACKEND::pfnGetModificationUuid */
static DECLCALLBACK(int) vhdxGetModificationUuid(void *pBackendData, PRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
static DECLCALLBACK(int) vhdxSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

    if (pImage)
    {
        if (!(pImage->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 VBOXHDDBACKEND::pfnGetParentUuid */
static DECLCALLBACK(int) vhdxGetParentUuid(void *pBackendData, PRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
static DECLCALLBACK(int) vhdxSetParentUuid(void *pBackendData, PCRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

    if (pImage)
    {
        if (!(pImage->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 VBOXHDDBACKEND::pfnGetParentModificationUuid */
static DECLCALLBACK(int) vhdxGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

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

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

/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
static DECLCALLBACK(int) vhdxSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
{
    RT_NOREF1(pUuid);
    LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
    int rc;

    AssertPtr(pImage);

    if (pImage)
    {
        if (!(pImage->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 VBOXHDDBACKEND::pfnDump */
static DECLCALLBACK(void) vhdxDump(void *pBackendData)
{
    PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;

    AssertPtr(pImage);
    if (pImage)
    {
        vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%u\n",
                        pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
                        pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
                        pImage->cbLogicalSector);
    }
}


const VBOXHDDBACKEND g_VhdxBackend =
{
    /* pszBackendName */
    "VHDX",
    /* cbSize */
    sizeof(VBOXHDDBACKEND),
    /* uBackendCaps */
    VD_CAP_FILE | VD_CAP_VFS,
    /* paFileExtensions */
    s_aVhdxFileExtensions,
    /* paConfigInfo */
    NULL,
    /* pfnCheckIfValid */
    vhdxCheckIfValid,
    /* pfnOpen */
    vhdxOpen,
    /* pfnCreate */
    vhdxCreate,
    /* pfnRename */
    vhdxRename,
    /* pfnClose */
    vhdxClose,
    /* pfnRead */
    vhdxRead,
    /* pfnWrite */
    vhdxWrite,
    /* pfnFlush */
    vhdxFlush,
    /* pfnDiscard */
    NULL,
    /* pfnGetVersion */
    vhdxGetVersion,
    /* pfnGetSectorSize */
    vhdxGetSectorSize,
    /* pfnGetSize */
    vhdxGetSize,
    /* pfnGetFileSize */
    vhdxGetFileSize,
    /* pfnGetPCHSGeometry */
    vhdxGetPCHSGeometry,
    /* pfnSetPCHSGeometry */
    vhdxSetPCHSGeometry,
    /* pfnGetLCHSGeometry */
    vhdxGetLCHSGeometry,
    /* pfnSetLCHSGeometry */
    vhdxSetLCHSGeometry,
    /* pfnGetImageFlags */
    vhdxGetImageFlags,
    /* pfnGetOpenFlags */
    vhdxGetOpenFlags,
    /* pfnSetOpenFlags */
    vhdxSetOpenFlags,
    /* pfnGetComment */
    vhdxGetComment,
    /* pfnSetComment */
    vhdxSetComment,
    /* pfnGetUuid */
    vhdxGetUuid,
    /* pfnSetUuid */
    vhdxSetUuid,
    /* pfnGetModificationUuid */
    vhdxGetModificationUuid,
    /* pfnSetModificationUuid */
    vhdxSetModificationUuid,
    /* pfnGetParentUuid */
    vhdxGetParentUuid,
    /* pfnSetParentUuid */
    vhdxSetParentUuid,
    /* pfnGetParentModificationUuid */
    vhdxGetParentModificationUuid,
    /* pfnSetParentModificationUuid */
    vhdxSetParentModificationUuid,
    /* pfnDump */
    vhdxDump,
    /* pfnGetTimestamp */
    NULL,
    /* pfnGetParentTimestamp */
    NULL,
    /* pfnSetParentTimestamp */
    NULL,
    /* pfnGetParentFilename */
    NULL,
    /* pfnSetParentFilename */
    NULL,
    /* pfnComposeLocation */
    genericFileComposeLocation,
    /* pfnComposeName */
    genericFileComposeName,
    /* pfnCompact */
    NULL,
    /* pfnResize */
    NULL,
    /* pfnRepair */
    NULL,
    /* pfnTraverseMetadata */
    NULL
};