VHDX.cpp@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 21 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 91.0 KB

Rev	Line
[41315]	1	/* $Id: VHDX.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
	2	/** @file
	3	* VHDX - VHDX Disk image, Core Code.
	4	*/
	5
	6	/*
[98103]	7	* Copyright (C) 2012-2023 Oracle and/or its affiliates.
[41315]	8	*
[96407]	9	* This file is part of VirtualBox base platform packages, as
	10	* available from https://www.virtualbox.org.
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License
	14	* as published by the Free Software Foundation, in version 3 of the
	15	* License.
	16	*
	17	* This program is distributed in the hope that it will be useful, but
	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, see <https://www.gnu.org/licenses>.
	24	*
	25	* SPDX-License-Identifier: GPL-3.0-only
[41315]	26	*/
	27
[57358]	28
	29	/*********************************************************************************************************************************
	30	* Header Files *
	31	*********************************************************************************************************************************/
[50531]	32	#define LOG_GROUP LOG_GROUP_VD_VHDX
[41315]	33	#include <VBox/vd-plugin.h>
	34	#include <VBox/err.h>
	35
	36	#include <VBox/log.h>
[41353]	37	#include <iprt/asm.h>
[41315]	38	#include <iprt/assert.h>
	39	#include <iprt/alloc.h>
	40	#include <iprt/path.h>
	41	#include <iprt/uuid.h>
	42	#include <iprt/crc.h>
	43
[50988]	44	#include "VDBackends.h"
[66494]	45	#include "VDBackendsInline.h"
[50988]	46
[41315]	47
[57358]	48	/*********************************************************************************************************************************
	49	* On disk data structures *
	50	*********************************************************************************************************************************/
	51
[41315]	52	/**
	53	* VHDX file type identifier.
	54	*/
	55	#pragma pack(1)
	56	typedef struct VhdxFileIdentifier
	57	{
	58	/** Signature. */
	59	uint64_t u64Signature;
	60	/** Creator ID - UTF-16 string (not neccessarily null terminated). */
	61	uint16_t awszCreator[256];
	62	} VhdxFileIdentifier;
	63	#pragma pack()
	64	/** Pointer to an on disk VHDX file type identifier. */
	65	typedef VhdxFileIdentifier *PVhdxFileIdentifier;
	66
	67	/** VHDX file type identifier signature ("vhdxfile"). */
	68	#define VHDX_FILE_IDENTIFIER_SIGNATURE UINT64_C(0x656c696678646876)
	69	/** Start offset of the VHDX file type identifier. */
	70	#define VHDX_FILE_IDENTIFIER_OFFSET UINT64_C(0)
	71
	72	/**
	73	* VHDX header.
	74	*/
	75	#pragma pack(1)
	76	typedef struct VhdxHeader
	77	{
	78	/** Signature. */
	79	uint32_t u32Signature;
	80	/** Checksum. */
	81	uint32_t u32Checksum;
	82	/** Sequence number. */
	83	uint64_t u64SequenceNumber;
	84	/** File write UUID. */
	85	RTUUID UuidFileWrite;
	86	/** Data write UUID. */
	87	RTUUID UuidDataWrite;
	88	/** Log UUID. */
	89	RTUUID UuidLog;
	90	/** Version of the log format. */
	91	uint16_t u16LogVersion;
[64272]	92	/** VHDX format version. */
[41315]	93	uint16_t u16Version;
	94	/** Length of the log region. */
	95	uint32_t u32LogLength;
	96	/** Start offset of the log offset in the file. */
	97	uint64_t u64LogOffset;
	98	/** Reserved bytes. */
	99	uint8_t u8Reserved[4016];
	100	} VhdxHeader;
	101	#pragma pack()
	102	/** Pointer to an on disk VHDX header. */
	103	typedef VhdxHeader *PVhdxHeader;
	104
	105	/** VHDX header signature ("head"). */
	106	#define VHDX_HEADER_SIGNATURE UINT32_C(0x64616568)
	107	/** Start offset of the first VHDX header. */
	108	#define VHDX_HEADER1_OFFSET _64K
	109	/** Start offset of the second VHDX header. */
	110	#define VHDX_HEADER2_OFFSET _128K
	111	/** Current Log format version. */
	112	#define VHDX_HEADER_LOG_VERSION UINT16_C(0)
	113	/** Current VHDX format version. */
	114	#define VHDX_HEADER_VHDX_VERSION UINT16_C(1)
	115
	116	/**
	117	* VHDX region table header
	118	*/
	119	#pragma pack(1)
	120	typedef struct VhdxRegionTblHdr
	121	{
	122	/** Signature. */
	123	uint32_t u32Signature;
	124	/** Checksum. */
	125	uint32_t u32Checksum;
	126	/** Number of region table entries following this header. */
	127	uint32_t u32EntryCount;
	128	/** Reserved. */
	129	uint32_t u32Reserved;
	130	} VhdxRegionTblHdr;
	131	#pragma pack()
	132	/** Pointer to an on disk VHDX region table header. */
	133	typedef VhdxRegionTblHdr *PVhdxRegionTblHdr;
	134
	135	/** VHDX region table header signature. */
	136	#define VHDX_REGION_TBL_HDR_SIGNATURE UINT32_C(0x69676572)
	137	/** Maximum number of entries which can follow. */
	138	#define VHDX_REGION_TBL_HDR_ENTRY_COUNT_MAX UINT32_C(2047)
	139	/** Offset where the region table is stored (192 KB). */
	140	#define VHDX_REGION_TBL_HDR_OFFSET UINT64_C(196608)
	141	/** Maximum size of the region table. */
	142	#define VHDX_REGION_TBL_SIZE_MAX _64K
	143
	144	/**
	145	* VHDX region table entry.
	146	*/
	147	#pragma pack(1)
	148	typedef struct VhdxRegionTblEntry
	149	{
	150	/** Object UUID. */
	151	RTUUID UuidObject;
	152	/** File offset of the region. */
	153	uint64_t u64FileOffset;
	154	/** Length of the region in bytes. */
	155	uint32_t u32Length;
	156	/** Flags for this object. */
	157	uint32_t u32Flags;
	158	} VhdxRegionTblEntry;
	159	#pragma pack()
	160	/** Pointer to an on disk VHDX region table entry. */
	161	typedef struct VhdxRegionTblEntry *PVhdxRegionTblEntry;
	162
	163	/** Flag whether this region is required. */
	164	#define VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED RT_BIT_32(0)
	165	/** UUID for the BAT region. */
	166	#define VHDX_REGION_TBL_ENTRY_UUID_BAT "2dc27766-f623-4200-9d64-115e9bfd4a08"
	167	/** UUID for the metadata region. */
	168	#define VHDX_REGION_TBL_ENTRY_UUID_METADATA "8b7ca206-4790-4b9a-b8fe-575f050f886e"
	169
	170	/**
	171	* VHDX Log entry header.
	172	*/
	173	#pragma pack(1)
	174	typedef struct VhdxLogEntryHdr
	175	{
	176	/** Signature. */
	177	uint32_t u32Signature;
	178	/** Checksum. */
	179	uint32_t u32Checksum;
	180	/** Total length of the entry in bytes. */
	181	uint32_t u32EntryLength;
	182	/** Tail of the log entries. */
	183	uint32_t u32Tail;
	184	/** Sequence number. */
	185	uint64_t u64SequenceNumber;
	186	/** Number of descriptors in this log entry. */
	187	uint32_t u32DescriptorCount;
	188	/** Reserved. */
	189	uint32_t u32Reserved;
	190	/** Log UUID. */
	191	RTUUID UuidLog;
	192	/** VHDX file size in bytes while the log entry was written. */
	193	uint64_t u64FlushedFileOffset;
	194	/** File size in bytes all allocated file structures fit into when the
	195	* log entry was written. */
	196	uint64_t u64LastFileOffset;
	197	} VhdxLogEntryHdr;
	198	#pragma pack()
	199	/** Pointer to an on disk VHDX log entry header. */
	200	typedef struct VhdxLogEntryHdr *PVhdxLogEntryHdr;
	201
	202	/** VHDX log entry signature ("loge"). */
	203	#define VHDX_LOG_ENTRY_HEADER_SIGNATURE UINT32_C(0x65676f6c)
	204
	205	/**
	206	* VHDX log zero descriptor.
	207	*/
	208	#pragma pack(1)
	209	typedef struct VhdxLogZeroDesc
	210	{
	211	/** Signature of this descriptor. */
	212	uint32_t u32ZeroSignature;
	213	/** Reserved. */
	214	uint32_t u32Reserved;
	215	/** Length of the section to zero. */
	216	uint64_t u64ZeroLength;
	217	/** File offset to write zeros to. */
	218	uint64_t u64FileOffset;
	219	/** Sequence number (must macht the field in the log entry header). */
	220	uint64_t u64SequenceNumber;
	221	} VhdxLogZeroDesc;
	222	#pragma pack()
	223	/** Pointer to an on disk VHDX log zero descriptor. */
	224	typedef struct VhdxLogZeroDesc *PVhdxLogZeroDesc;
	225
	226	/** Signature of a VHDX log zero descriptor ("zero"). */
	227	#define VHDX_LOG_ZERO_DESC_SIGNATURE UINT32_C(0x6f72657a)
	228
	229	/**
	230	* VHDX log data descriptor.
	231	*/
	232	#pragma pack(1)
	233	typedef struct VhdxLogDataDesc
	234	{
	235	/** Signature of this descriptor. */
	236	uint32_t u32DataSignature;
	237	/** Trailing 4 bytes removed from the update. */
	238	uint32_t u32TrailingBytes;
	239	/** Leading 8 bytes removed from the update. */
	240	uint64_t u64LeadingBytes;
	241	/** File offset to write zeros to. */
	242	uint64_t u64FileOffset;
	243	/** Sequence number (must macht the field in the log entry header). */
	244	uint64_t u64SequenceNumber;
	245	} VhdxLogDataDesc;
	246	#pragma pack()
	247	/** Pointer to an on disk VHDX log data descriptor. */
	248	typedef struct VhdxLogDataDesc *PVhdxLogDataDesc;
	249
	250	/** Signature of a VHDX log data descriptor ("desc"). */
	251	#define VHDX_LOG_DATA_DESC_SIGNATURE UINT32_C(0x63736564)
	252
	253	/**
	254	* VHDX log data sector.
	255	*/
	256	#pragma pack(1)
	257	typedef struct VhdxLogDataSector
	258	{
	259	/** Signature of the data sector. */
	260	uint32_t u32DataSignature;
	261	/** 4 most significant bytes of the sequence number. */
	262	uint32_t u32SequenceHigh;
	263	/** Raw data associated with the update. */
	264	uint8_t u8Data[4084];
	265	/** 4 least significant bytes of the sequence number. */
	266	uint32_t u32SequenceLow;
	267	} VhdxLogDataSector;
	268	#pragma pack()
	269	/** Pointer to an on disk VHDX log data sector. */
	270	typedef VhdxLogDataSector *PVhdxLogDataSector;
	271
	272	/** Signature of a VHDX log data sector ("data"). */
	273	#define VHDX_LOG_DATA_SECTOR_SIGNATURE UINT32_C(0x61746164)
	274
	275	/**
[41345]	276	* VHDX BAT entry.
	277	*/
	278	#pragma pack(1)
	279	typedef struct VhdxBatEntry
	280	{
	281	/** The BAT entry, contains state and offset. */
	282	uint64_t u64BatEntry;
	283	} VhdxBatEntry;
	284	#pragma pack()
	285	typedef VhdxBatEntry *PVhdxBatEntry;
	286
	287	/** Return the BAT state from a given entry. */
	288	#define VHDX_BAT_ENTRY_GET_STATE(bat) ((bat) & UINT64_C(0x7))
	289	/** Get the FileOffsetMB field from a given BAT entry. */
	290	#define VHDX_BAT_ENTRY_GET_FILE_OFFSET_MB(bat) (((bat) & UINT64_C(0xfffffffffff00000)) >> 20)
	291	/** Get a byte offset from the BAT entry. */
	292	#define VHDX_BAT_ENTRY_GET_FILE_OFFSET(bat) (VHDX_BAT_ENTRY_GET_FILE_OFFSET_MB(bat) * (uint64_t)_1M)
	293
	294	/** Block not present and the data is undefined. */
	295	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_NOT_PRESENT (0)
	296	/** Data in this block is undefined. */
	297	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNDEFINED (1)
	298	/** Data in this block contains zeros. */
	299	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_ZERO (2)
	300	/** Block was unmapped by the application or system and data is either zero or
	301	* the data before the block was unmapped. */
	302	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNMAPPED (3)
	303	/** Block data is in the file pointed to by the FileOffsetMB field. */
	304	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_FULLY_PRESENT (6)
	305	/** Block is partially present, use sector bitmap to get present sectors. */
	306	#define VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT (7)
	307
	308	/** The sector bitmap block is undefined and not allocated in the file. */
	309	#define VHDX_BAT_ENTRY_SB_BLOCK_NOT_PRESENT (0)
	310	/** The sector bitmap block is defined at the file location. */
	311	#define VHDX_BAT_ENTRY_SB_BLOCK_PRESENT (6)
	312
	313	/**
[41315]	314	* VHDX Metadata tabl header.
	315	*/
	316	#pragma pack(1)
	317	typedef struct VhdxMetadataTblHdr
	318	{
	319	/** Signature. */
	320	uint64_t u64Signature;
	321	/** Reserved. */
	322	uint16_t u16Reserved;
	323	/** Number of entries in the table. */
	324	uint16_t u16EntryCount;
	325	/** Reserved */
	326	uint32_t u32Reserved2[5];
	327	} VhdxMetadataTblHdr;
	328	#pragma pack()
	329	/** Pointer to an on disk metadata table header. */
	330	typedef VhdxMetadataTblHdr *PVhdxMetadataTblHdr;
	331
	332	/** Signature of a VHDX metadata table header ("metadata"). */
	333	#define VHDX_METADATA_TBL_HDR_SIGNATURE UINT64_C(0x617461646174656d)
	334	/** Maximum number of entries the metadata table can have. */
	335	#define VHDX_METADATA_TBL_HDR_ENTRY_COUNT_MAX UINT16_C(2047)
	336
	337	/**
	338	* VHDX Metadata table entry.
	339	*/
	340	#pragma pack(1)
	341	typedef struct VhdxMetadataTblEntry
	342	{
	343	/** Item UUID. */
	344	RTUUID UuidItem;
	345	/** Offset of the metadata item. */
	346	uint32_t u32Offset;
	347	/** Length of the metadata item. */
	348	uint32_t u32Length;
	349	/** Flags for the metadata item. */
	350	uint32_t u32Flags;
	351	/** Reserved. */
	352	uint32_t u32Reserved;
	353	} VhdxMetadataTblEntry;
	354	#pragma pack()
	355	/** Pointer to an on disk metadata table entry. */
	356	typedef VhdxMetadataTblEntry *PVhdxMetadataTblEntry;
	357
	358	/** FLag whether the metadata item is system or user metadata. */
	359	#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_USER RT_BIT_32(0)
	360	/** FLag whether the metadata item is file or virtual disk metadata. */
	361	#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_VDISK RT_BIT_32(1)
	362	/** FLag whether the backend must understand the metadata item to load the image. */
	363	#define VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED RT_BIT_32(2)
	364
	365	/** File parameters item UUID. */
	366	#define VHDX_METADATA_TBL_ENTRY_ITEM_FILE_PARAMS "caa16737-fa36-4d43-b3b6-33f0aa44e76b"
	367	/** Virtual disk size item UUID. */
[41345]	368	#define VHDX_METADATA_TBL_ENTRY_ITEM_VDISK_SIZE "2fa54224-cd1b-4876-b211-5dbed83bf4b8"
[41315]	369	/** Page 83 UUID. */
	370	#define VHDX_METADATA_TBL_ENTRY_ITEM_PAGE83_DATA "beca12ab-b2e6-4523-93ef-c309e000c746"
	371	/** Logical sector size UUID. */
	372	#define VHDX_METADATA_TBL_ENTRY_ITEM_LOG_SECT_SIZE "8141bf1d-a96f-4709-ba47-f233a8faab5f"
	373	/** Physical sector size UUID. */
	374	#define VHDX_METADATA_TBL_ENTRY_ITEM_PHYS_SECT_SIZE "cda348c7-445d-4471-9cc9-e9885251c556"
	375	/** Parent locator UUID. */
	376	#define VHDX_METADATA_TBL_ENTRY_ITEM_PARENT_LOCATOR "a8d35f2d-b30b-454d-abf7-d3d84834ab0c"
	377
	378	/**
	379	* VHDX File parameters metadata item.
	380	*/
	381	#pragma pack(1)
	382	typedef struct VhdxFileParameters
	383	{
	384	/** Block size. */
	385	uint32_t u32BlockSize;
	386	/** Flags. */
	387	uint32_t u32Flags;
	388	} VhdxFileParameters;
	389	#pragma pack()
	390	/** Pointer to an on disk VHDX file parameters metadata item. */
	391	typedef struct VhdxFileParameters *PVhdxFileParameters;
	392
	393	/** Flag whether to leave blocks allocated in the file or if it is possible to unmap them. */
	394	#define VHDX_FILE_PARAMETERS_FLAGS_LEAVE_BLOCKS_ALLOCATED RT_BIT_32(0)
	395	/** Flag whether this file has a parent VHDX file. */
	396	#define VHDX_FILE_PARAMETERS_FLAGS_HAS_PARENT RT_BIT_32(1)
	397
	398	/**
	399	* VHDX virtual disk size metadata item.
	400	*/
	401	#pragma pack(1)
	402	typedef struct VhdxVDiskSize
	403	{
	404	/** Virtual disk size. */
	405	uint64_t u64VDiskSize;
	406	} VhdxVDiskSize;
	407	#pragma pack()
	408	/** Pointer to an on disk VHDX virtual disk size metadata item. */
	409	typedef struct VhdxVDiskSize *PVhdxVDiskSize;
	410
	411	/**
	412	* VHDX page 83 data metadata item.
	413	*/
	414	#pragma pack(1)
	415	typedef struct VhdxPage83Data
	416	{
	417	/** UUID for the SCSI device. */
	418	RTUUID UuidPage83Data;
	419	} VhdxPage83Data;
	420	#pragma pack()
	421	/** Pointer to an on disk VHDX vpage 83 data metadata item. */
	422	typedef struct VhdxPage83Data *PVhdxPage83Data;
	423
	424	/**
	425	* VHDX virtual disk logical sector size.
	426	*/
	427	#pragma pack(1)
	428	typedef struct VhdxVDiskLogicalSectorSize
	429	{
	430	/** Logical sector size. */
[41345]	431	uint32_t u32LogicalSectorSize;
[41315]	432	} VhdxVDiskLogicalSectorSize;
	433	#pragma pack()
	434	/** Pointer to an on disk VHDX virtual disk logical sector size metadata item. */
	435	typedef struct VhdxVDiskLogicalSectorSize *PVhdxVDiskLogicalSectorSize;
	436
	437	/**
	438	* VHDX virtual disk physical sector size.
	439	*/
	440	#pragma pack(1)
	441	typedef struct VhdxVDiskPhysicalSectorSize
	442	{
	443	/** Physical sector size. */
	444	uint64_t u64PhysicalSectorSize;
	445	} VhdxVDiskPhysicalSectorSize;
	446	#pragma pack()
	447	/** Pointer to an on disk VHDX virtual disk physical sector size metadata item. */
	448	typedef struct VhdxVDiskPhysicalSectorSize *PVhdxVDiskPhysicalSectorSize;
	449
	450	/**
	451	* VHDX parent locator header.
	452	*/
	453	#pragma pack(1)
	454	typedef struct VhdxParentLocatorHeader
	455	{
	456	/** Locator type UUID. */
	457	RTUUID UuidLocatorType;
	458	/** Reserved. */
	459	uint16_t u16Reserved;
	460	/** Number of key value pairs. */
	461	uint16_t u16KeyValueCount;
	462	} VhdxParentLocatorHeader;
	463	#pragma pack()
	464	/** Pointer to an on disk VHDX parent locator header metadata item. */
	465	typedef struct VhdxParentLocatorHeader *PVhdxParentLocatorHeader;
	466
	467	/** VHDX parent locator type. */
	468	#define VHDX_PARENT_LOCATOR_TYPE_VHDX "b04aefb7-d19e-4a81-b789-25b8e9445913"
	469
	470	/**
	471	* VHDX parent locator entry.
	472	*/
	473	#pragma pack(1)
	474	typedef struct VhdxParentLocatorEntry
	475	{
	476	/** Offset of the key. */
	477	uint32_t u32KeyOffset;
	478	/** Offset of the value. */
	479	uint32_t u32ValueOffset;
	480	/** Length of the key. */
	481	uint16_t u16KeyLength;
	482	/** Length of the value. */
	483	uint16_t u16ValueLength;
	484	} VhdxParentLocatorEntry;
	485	#pragma pack()
	486	/** Pointer to an on disk VHDX parent locator entry. */
	487	typedef struct VhdxParentLocatorEntry *PVhdxParentLocatorEntry;
	488
	489
[57358]	490	/*********************************************************************************************************************************
	491	* Constants And Macros, Structures and Typedefs *
	492	*********************************************************************************************************************************/
	493
[41315]	494	typedef enum VHDXMETADATAITEM
	495	{
	496	VHDXMETADATAITEM_UNKNOWN = 0,
	497	VHDXMETADATAITEM_FILE_PARAMS,
	498	VHDXMETADATAITEM_VDISK_SIZE,
	499	VHDXMETADATAITEM_PAGE83_DATA,
	500	VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE,
	501	VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE,
	502	VHDXMETADATAITEM_PARENT_LOCATOR,
	503	VHDXMETADATAITEM_32BIT_HACK = 0x7fffffff
	504	} VHDXMETADATAITEM;
	505
	506	/**
	507	* Table to validate the metadata item UUIDs and the flags.
	508	*/
	509	typedef struct VHDXMETADATAITEMPROPS
	510	{
	511	/** Item UUID. */
	512	const char *pszItemUuid;
	513	/** Flag whether this is a user or system metadata item. */
	514	bool fIsUser;
	515	/** Flag whether this is a virtual disk or file metadata item. */
	516	bool fIsVDisk;
	517	/** Flag whether this metadata item is required to load the file. */
	518	bool fIsRequired;
	519	/** Metadata item enum associated with this UUID. */
	520	VHDXMETADATAITEM enmMetadataItem;
	521	} VHDXMETADATAITEMPROPS;
	522
	523	/**
	524	* VHDX image data structure.
	525	*/
	526	typedef struct VHDXIMAGE
	527	{
	528	/** Image name. */
[48851]	529	const char *pszFilename;
[41315]	530	/** Storage handle. */
[48851]	531	PVDIOSTORAGE pStorage;
[41315]	532
	533	/** Pointer to the per-disk VD interface list. */
[48851]	534	PVDINTERFACE pVDIfsDisk;
[41315]	535	/** Pointer to the per-image VD interface list. */
[48851]	536	PVDINTERFACE pVDIfsImage;
[41315]	537	/** Error interface. */
[48851]	538	PVDINTERFACEERROR pIfError;
[41315]	539	/** I/O interface. */
[48851]	540	PVDINTERFACEIOINT pIfIo;
[41315]	541
	542	/** Open flags passed by VBoxHD layer. */
[48851]	543	unsigned uOpenFlags;
[41315]	544	/** Image flags defined during creation or determined during open. */
[48851]	545	unsigned uImageFlags;
[41315]	546	/** Version of the VHDX image format. */
[48851]	547	unsigned uVersion;
[41315]	548	/** Total size of the image. */
[48851]	549	uint64_t cbSize;
[41345]	550	/** Logical sector size of the image. */
[48851]	551	uint32_t cbLogicalSector;
[41345]	552	/** Block size of the image. */
[48851]	553	size_t cbBlock;
[41315]	554	/** Physical geometry of this image. */
[48851]	555	VDGEOMETRY PCHSGeometry;
[41315]	556	/** Logical geometry of this image. */
[48851]	557	VDGEOMETRY LCHSGeometry;
[41315]	558
[41345]	559	/** The BAT. */
[48851]	560	PVhdxBatEntry paBat;
[41345]	561	/** Chunk ratio. */
[48851]	562	uint32_t uChunkRatio;
[66486]	563	/** The static region list. */
	564	VDREGIONLIST RegionList;
[41315]	565	} VHDXIMAGE, *PVHDXIMAGE;
	566
	567	/**
	568	* Endianess conversion direction.
	569	*/
	570	typedef enum VHDXECONV
	571	{
	572	/** Host to file endianess. */
	573	VHDXECONV_H2F = 0,
	574	/** File to host endianess. */
	575	VHDXECONV_F2H
	576	} VHDXECONV;
	577
	578	/** Macros for endianess conversion. */
	579	#define SET_ENDIAN_U16(u16) (enmConv == VHDXECONV_H2F ? RT_H2LE_U16(u16) : RT_LE2H_U16(u16))
	580	#define SET_ENDIAN_U32(u32) (enmConv == VHDXECONV_H2F ? RT_H2LE_U32(u32) : RT_LE2H_U32(u32))
	581	#define SET_ENDIAN_U64(u64) (enmConv == VHDXECONV_H2F ? RT_H2LE_U64(u64) : RT_LE2H_U64(u64))
	582
	583
[57358]	584	/*********************************************************************************************************************************
	585	* Static Variables *
	586	*********************************************************************************************************************************/
	587
[41315]	588	/**
	589	* NULL-terminated array of supported file extensions.
	590	*/
	591	static const VDFILEEXTENSION s_aVhdxFileExtensions[] =
	592	{
	593	{"vhdx", VDTYPE_HDD},
	594	{NULL, VDTYPE_INVALID}
	595	};
	596
	597	/**
	598	* Static table to verify the metadata item properties and the flags.
	599	*/
	600	static const VHDXMETADATAITEMPROPS s_aVhdxMetadataItemProps[] =
	601	{
	602	/* pcszItemUuid fIsUser, fIsVDisk, fIsRequired, enmMetadataItem */
	603	{VHDX_METADATA_TBL_ENTRY_ITEM_FILE_PARAMS, false, false, true, VHDXMETADATAITEM_FILE_PARAMS},
	604	{VHDX_METADATA_TBL_ENTRY_ITEM_VDISK_SIZE, false, true, true, VHDXMETADATAITEM_VDISK_SIZE},
	605	{VHDX_METADATA_TBL_ENTRY_ITEM_PAGE83_DATA, false, true, true, VHDXMETADATAITEM_PAGE83_DATA},
	606	{VHDX_METADATA_TBL_ENTRY_ITEM_LOG_SECT_SIZE, false, true, true, VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE},
[46029]	607	{VHDX_METADATA_TBL_ENTRY_ITEM_PHYS_SECT_SIZE, false, true, true, VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE},
[41315]	608	{VHDX_METADATA_TBL_ENTRY_ITEM_PARENT_LOCATOR, false, false, true, VHDXMETADATAITEM_PARENT_LOCATOR}
	609	};
	610
	611
[57358]	612	/*********************************************************************************************************************************
	613	* Internal Functions *
	614	*********************************************************************************************************************************/
	615
[41315]	616	/**
	617	* Converts the file identifier between file and host endianness.
	618	*
	619	* @returns nothing.
	620	* @param enmConv Direction of the conversion.
	621	* @param pFileIdentifierConv Where to store the converted file identifier.
	622	* @param pFileIdentifier The file identifier to convert.
	623	*
	624	* @note It is safe to use the same pointer for pFileIdentifierConv and pFileIdentifier.
	625	*/
	626	DECLINLINE(void) vhdxConvFileIdentifierEndianess(VHDXECONV enmConv, PVhdxFileIdentifier pFileIdentifierConv,
	627	PVhdxFileIdentifier pFileIdentifier)
	628	{
	629	pFileIdentifierConv->u64Signature = SET_ENDIAN_U64(pFileIdentifier->u64Signature);
	630	for (unsigned i = 0; i < RT_ELEMENTS(pFileIdentifierConv->awszCreator); i++)
	631	pFileIdentifierConv->awszCreator[i] = SET_ENDIAN_U16(pFileIdentifier->awszCreator[i]);
	632	}
	633
	634	/**
	635	* Converts a UUID between file and host endianness.
	636	*
	637	* @returns nothing.
	638	* @param enmConv Direction of the conversion.
	639	* @param pUuidConv Where to store the converted UUID.
	640	* @param pUuid The UUID to convert.
	641	*
	642	* @note It is safe to use the same pointer for pUuidConv and pUuid.
	643	*/
	644	DECLINLINE(void) vhdxConvUuidEndianess(VHDXECONV enmConv, PRTUUID pUuidConv, PRTUUID pUuid)
	645	{
[62743]	646	RT_NOREF1(enmConv);
[41447]	647	#if 1
[87753]	648	/** @todo r=andy Code looks temporary disabled to me, fixes strict release builds:
[87917]	649	* "accessing 16 bytes at offsets 0 and 0 overlaps 16 bytes at offset 0 [-Werror=restrict]" */
[87753]	650	RTUUID uuidTmp;
	651	memcpy(&uuidTmp, pUuid, sizeof(RTUUID));
	652	memcpy(pUuidConv, &uuidTmp, sizeof(RTUUID));
[41447]	653	#else
[41315]	654	pUuidConv->Gen.u32TimeLow = SET_ENDIAN_U32(pUuid->Gen.u32TimeLow);
	655	pUuidConv->Gen.u16TimeMid = SET_ENDIAN_U16(pUuid->Gen.u16TimeMid);
	656	pUuidConv->Gen.u16TimeHiAndVersion = SET_ENDIAN_U16(pUuid->Gen.u16TimeHiAndVersion);
	657	pUuidConv->Gen.u8ClockSeqHiAndReserved = pUuid->Gen.u8ClockSeqHiAndReserved;
	658	pUuidConv->Gen.u8ClockSeqLow = pUuid->Gen.u8ClockSeqLow;
[41317]	659	for (unsigned i = 0; i < RT_ELEMENTS(pUuidConv->Gen.au8Node); i++)
	660	pUuidConv->Gen.au8Node[i] = pUuid->Gen.au8Node[i];
[41447]	661	#endif
[41315]	662	}
	663
	664	/**
	665	* Converts a VHDX header between file and host endianness.
	666	*
	667	* @returns nothing.
	668	* @param enmConv Direction of the conversion.
	669	* @param pHdrConv Where to store the converted header.
	670	* @param pHdr The VHDX header to convert.
	671	*
	672	* @note It is safe to use the same pointer for pHdrConv and pHdr.
	673	*/
	674	DECLINLINE(void) vhdxConvHeaderEndianess(VHDXECONV enmConv, PVhdxHeader pHdrConv, PVhdxHeader pHdr)
	675	{
	676	pHdrConv->u32Signature = SET_ENDIAN_U32(pHdr->u32Signature);
	677	pHdrConv->u32Checksum = SET_ENDIAN_U32(pHdr->u32Checksum);
	678	pHdrConv->u64SequenceNumber = SET_ENDIAN_U64(pHdr->u64SequenceNumber);
	679	vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidFileWrite, &pHdrConv->UuidFileWrite);
	680	vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidDataWrite, &pHdrConv->UuidDataWrite);
	681	vhdxConvUuidEndianess(enmConv, &pHdrConv->UuidLog, &pHdrConv->UuidLog);
	682	pHdrConv->u16LogVersion = SET_ENDIAN_U16(pHdr->u16LogVersion);
	683	pHdrConv->u16Version = SET_ENDIAN_U16(pHdr->u16Version);
	684	pHdrConv->u32LogLength = SET_ENDIAN_U32(pHdr->u32LogLength);
	685	pHdrConv->u64LogOffset = SET_ENDIAN_U64(pHdr->u64LogOffset);
	686	}
	687
	688	/**
	689	* Converts a VHDX region table header between file and host endianness.
	690	*
	691	* @returns nothing.
	692	* @param enmConv Direction of the conversion.
	693	* @param pRegTblHdrConv Where to store the converted header.
	694	* @param pRegTblHdr The VHDX region table header to convert.
	695	*
	696	* @note It is safe to use the same pointer for pRegTblHdrConv and pRegTblHdr.
	697	*/
	698	DECLINLINE(void) vhdxConvRegionTblHdrEndianess(VHDXECONV enmConv, PVhdxRegionTblHdr pRegTblHdrConv,
	699	PVhdxRegionTblHdr pRegTblHdr)
	700	{
	701	pRegTblHdrConv->u32Signature = SET_ENDIAN_U32(pRegTblHdr->u32Signature);
	702	pRegTblHdrConv->u32Checksum = SET_ENDIAN_U32(pRegTblHdr->u32Checksum);
	703	pRegTblHdrConv->u32EntryCount = SET_ENDIAN_U32(pRegTblHdr->u32EntryCount);
	704	pRegTblHdrConv->u32Reserved = SET_ENDIAN_U32(pRegTblHdr->u32Reserved);
	705	}
	706
	707	/**
	708	* Converts a VHDX region table entry between file and host endianness.
	709	*
	710	* @returns nothing.
	711	* @param enmConv Direction of the conversion.
	712	* @param pRegTblEntConv Where to store the converted region table entry.
	713	* @param pRegTblEnt The VHDX region table entry to convert.
	714	*
	715	* @note It is safe to use the same pointer for pRegTblEntConv and pRegTblEnt.
	716	*/
	717	DECLINLINE(void) vhdxConvRegionTblEntryEndianess(VHDXECONV enmConv, PVhdxRegionTblEntry pRegTblEntConv,
	718	PVhdxRegionTblEntry pRegTblEnt)
	719	{
	720	vhdxConvUuidEndianess(enmConv, &pRegTblEntConv->UuidObject, &pRegTblEnt->UuidObject);
	721	pRegTblEntConv->u64FileOffset = SET_ENDIAN_U64(pRegTblEnt->u64FileOffset);
	722	pRegTblEntConv->u32Length = SET_ENDIAN_U32(pRegTblEnt->u32Length);
	723	pRegTblEntConv->u32Flags = SET_ENDIAN_U32(pRegTblEnt->u32Flags);
	724	}
	725
[63495]	726	#if 0 /* unused */
	727
[41315]	728	/**
	729	* Converts a VHDX log entry header between file and host endianness.
	730	*
	731	* @returns nothing.
	732	* @param enmConv Direction of the conversion.
	733	* @param pLogEntryHdrConv Where to store the converted log entry header.
	734	* @param pLogEntryHdr The VHDX log entry header to convert.
	735	*
	736	* @note It is safe to use the same pointer for pLogEntryHdrConv and pLogEntryHdr.
	737	*/
	738	DECLINLINE(void) vhdxConvLogEntryHdrEndianess(VHDXECONV enmConv, PVhdxLogEntryHdr pLogEntryHdrConv,
	739	PVhdxLogEntryHdr pLogEntryHdr)
	740	{
	741	pLogEntryHdrConv->u32Signature = SET_ENDIAN_U32(pLogEntryHdr->u32Signature);
	742	pLogEntryHdrConv->u32Checksum = SET_ENDIAN_U32(pLogEntryHdr->u32Checksum);
	743	pLogEntryHdrConv->u32EntryLength = SET_ENDIAN_U32(pLogEntryHdr->u32EntryLength);
	744	pLogEntryHdrConv->u32Tail = SET_ENDIAN_U32(pLogEntryHdr->u32Tail);
	745	pLogEntryHdrConv->u64SequenceNumber = SET_ENDIAN_U64(pLogEntryHdr->u64SequenceNumber);
	746	pLogEntryHdrConv->u32DescriptorCount = SET_ENDIAN_U32(pLogEntryHdr->u32DescriptorCount);
	747	pLogEntryHdrConv->u32Reserved = SET_ENDIAN_U32(pLogEntryHdr->u32Reserved);
	748	vhdxConvUuidEndianess(enmConv, &pLogEntryHdrConv->UuidLog, &pLogEntryHdr->UuidLog);
	749	pLogEntryHdrConv->u64FlushedFileOffset = SET_ENDIAN_U64(pLogEntryHdr->u64FlushedFileOffset);
	750	}
	751
	752	/**
	753	* Converts a VHDX log zero descriptor between file and host endianness.
	754	*
	755	* @returns nothing.
	756	* @param enmConv Direction of the conversion.
	757	* @param pLogZeroDescConv Where to store the converted log zero descriptor.
	758	* @param pLogZeroDesc The VHDX log zero descriptor to convert.
	759	*
	760	* @note It is safe to use the same pointer for pLogZeroDescConv and pLogZeroDesc.
	761	*/
	762	DECLINLINE(void) vhdxConvLogZeroDescEndianess(VHDXECONV enmConv, PVhdxLogZeroDesc pLogZeroDescConv,
	763	PVhdxLogZeroDesc pLogZeroDesc)
	764	{
	765	pLogZeroDescConv->u32ZeroSignature = SET_ENDIAN_U32(pLogZeroDesc->u32ZeroSignature);
	766	pLogZeroDescConv->u32Reserved = SET_ENDIAN_U32(pLogZeroDesc->u32Reserved);
	767	pLogZeroDescConv->u64ZeroLength = SET_ENDIAN_U64(pLogZeroDesc->u64ZeroLength);
	768	pLogZeroDescConv->u64FileOffset = SET_ENDIAN_U64(pLogZeroDesc->u64FileOffset);
	769	pLogZeroDescConv->u64SequenceNumber = SET_ENDIAN_U64(pLogZeroDesc->u64SequenceNumber);
	770	}
	771
[63495]	772
[41315]	773	/**
	774	* Converts a VHDX log data descriptor between file and host endianness.
	775	*
	776	* @returns nothing.
	777	* @param enmConv Direction of the conversion.
	778	* @param pLogDataDescConv Where to store the converted log data descriptor.
	779	* @param pLogDataDesc The VHDX log data descriptor to convert.
	780	*
	781	* @note It is safe to use the same pointer for pLogDataDescConv and pLogDataDesc.
	782	*/
	783	DECLINLINE(void) vhdxConvLogDataDescEndianess(VHDXECONV enmConv, PVhdxLogDataDesc pLogDataDescConv,
	784	PVhdxLogDataDesc pLogDataDesc)
	785	{
	786	pLogDataDescConv->u32DataSignature = SET_ENDIAN_U32(pLogDataDesc->u32DataSignature);
	787	pLogDataDescConv->u32TrailingBytes = SET_ENDIAN_U32(pLogDataDesc->u32TrailingBytes);
	788	pLogDataDescConv->u64LeadingBytes = SET_ENDIAN_U64(pLogDataDesc->u64LeadingBytes);
	789	pLogDataDescConv->u64FileOffset = SET_ENDIAN_U64(pLogDataDesc->u64FileOffset);
	790	pLogDataDescConv->u64SequenceNumber = SET_ENDIAN_U64(pLogDataDesc->u64SequenceNumber);
	791	}
	792
[63495]	793
[41315]	794	/**
	795	* Converts a VHDX log data sector between file and host endianness.
	796	*
	797	* @returns nothing.
	798	* @param enmConv Direction of the conversion.
	799	* @param pLogDataSectorConv Where to store the converted log data sector.
	800	* @param pLogDataSector The VHDX log data sector to convert.
	801	*
	802	* @note It is safe to use the same pointer for pLogDataSectorConv and pLogDataSector.
	803	*/
	804	DECLINLINE(void) vhdxConvLogDataSectorEndianess(VHDXECONV enmConv, PVhdxLogDataSector pLogDataSectorConv,
	805	PVhdxLogDataSector pLogDataSector)
	806	{
	807	pLogDataSectorConv->u32DataSignature = SET_ENDIAN_U32(pLogDataSector->u32DataSignature);
	808	pLogDataSectorConv->u32SequenceHigh = SET_ENDIAN_U32(pLogDataSector->u32SequenceHigh);
	809	pLogDataSectorConv->u32SequenceLow = SET_ENDIAN_U32(pLogDataSector->u32SequenceLow);
	810	}
	811
[63495]	812	#endif /* unused */
	813
[41315]	814	/**
[41345]	815	* Converts a BAT between file and host endianess.
	816	*
	817	* @returns nothing.
	818	* @param enmConv Direction of the conversion.
	819	* @param paBatEntriesConv Where to store the converted BAT.
	820	* @param paBatEntries The VHDX BAT to convert.
[64272]	821	* @param cBatEntries Number of entries in the BAT.
[41345]	822	*
	823	* @note It is safe to use the same pointer for paBatEntriesConv and paBatEntries.
	824	*/
	825	DECLINLINE(void) vhdxConvBatTableEndianess(VHDXECONV enmConv, PVhdxBatEntry paBatEntriesConv,
	826	PVhdxBatEntry paBatEntries, uint32_t cBatEntries)
	827	{
	828	for (uint32_t i = 0; i < cBatEntries; i++)
	829	paBatEntriesConv[i].u64BatEntry = SET_ENDIAN_U64(paBatEntries[i].u64BatEntry);
	830	}
	831
	832	/**
[41315]	833	* Converts a VHDX metadata table header between file and host endianness.
	834	*
	835	* @returns nothing.
	836	* @param enmConv Direction of the conversion.
	837	* @param pMetadataTblHdrConv Where to store the converted metadata table header.
	838	* @param pMetadataTblHdr The VHDX metadata table header to convert.
	839	*
	840	* @note It is safe to use the same pointer for pMetadataTblHdrConv and pMetadataTblHdr.
	841	*/
	842	DECLINLINE(void) vhdxConvMetadataTblHdrEndianess(VHDXECONV enmConv, PVhdxMetadataTblHdr pMetadataTblHdrConv,
	843	PVhdxMetadataTblHdr pMetadataTblHdr)
	844	{
	845	pMetadataTblHdrConv->u64Signature = SET_ENDIAN_U64(pMetadataTblHdr->u64Signature);
	846	pMetadataTblHdrConv->u16Reserved = SET_ENDIAN_U16(pMetadataTblHdr->u16Reserved);
	847	pMetadataTblHdrConv->u16EntryCount = SET_ENDIAN_U16(pMetadataTblHdr->u16EntryCount);
	848	for (unsigned i = 0; i < RT_ELEMENTS(pMetadataTblHdr->u32Reserved2); i++)
	849	pMetadataTblHdrConv->u32Reserved2[i] = SET_ENDIAN_U32(pMetadataTblHdr->u32Reserved2[i]);
	850	}
	851
	852	/**
	853	* Converts a VHDX metadata table entry between file and host endianness.
	854	*
	855	* @returns nothing.
	856	* @param enmConv Direction of the conversion.
	857	* @param pMetadataTblEntryConv Where to store the converted metadata table entry.
	858	* @param pMetadataTblEntry The VHDX metadata table entry to convert.
	859	*
	860	* @note It is safe to use the same pointer for pMetadataTblEntryConv and pMetadataTblEntry.
	861	*/
	862	DECLINLINE(void) vhdxConvMetadataTblEntryEndianess(VHDXECONV enmConv, PVhdxMetadataTblEntry pMetadataTblEntryConv,
	863	PVhdxMetadataTblEntry pMetadataTblEntry)
	864	{
	865	vhdxConvUuidEndianess(enmConv, &pMetadataTblEntryConv->UuidItem, &pMetadataTblEntry->UuidItem);
	866	pMetadataTblEntryConv->u32Offset = SET_ENDIAN_U32(pMetadataTblEntry->u32Offset);
	867	pMetadataTblEntryConv->u32Length = SET_ENDIAN_U32(pMetadataTblEntry->u32Length);
	868	pMetadataTblEntryConv->u32Flags = SET_ENDIAN_U32(pMetadataTblEntry->u32Flags);
	869	pMetadataTblEntryConv->u32Reserved = SET_ENDIAN_U32(pMetadataTblEntry->u32Reserved);
	870	}
	871
	872	/**
	873	* Converts a VHDX file parameters item between file and host endianness.
	874	*
	875	* @returns nothing.
	876	* @param enmConv Direction of the conversion.
	877	* @param pFileParamsConv Where to store the converted file parameters item entry.
	878	* @param pFileParams The VHDX file parameters item to convert.
	879	*
	880	* @note It is safe to use the same pointer for pFileParamsConv and pFileParams.
	881	*/
	882	DECLINLINE(void) vhdxConvFileParamsEndianess(VHDXECONV enmConv, PVhdxFileParameters pFileParamsConv,
	883	PVhdxFileParameters pFileParams)
	884	{
	885	pFileParamsConv->u32BlockSize = SET_ENDIAN_U32(pFileParams->u32BlockSize);
	886	pFileParamsConv->u32Flags = SET_ENDIAN_U32(pFileParams->u32Flags);
	887	}
	888
	889	/**
	890	* Converts a VHDX virtual disk size item between file and host endianness.
	891	*
	892	* @returns nothing.
	893	* @param enmConv Direction of the conversion.
	894	* @param pVDiskSizeConv Where to store the converted virtual disk size item entry.
	895	* @param pVDiskSize The VHDX virtual disk size item to convert.
	896	*
	897	* @note It is safe to use the same pointer for pVDiskSizeConv and pVDiskSize.
	898	*/
	899	DECLINLINE(void) vhdxConvVDiskSizeEndianess(VHDXECONV enmConv, PVhdxVDiskSize pVDiskSizeConv,
	900	PVhdxVDiskSize pVDiskSize)
	901	{
	902	pVDiskSizeConv->u64VDiskSize = SET_ENDIAN_U64(pVDiskSize->u64VDiskSize);
	903	}
	904
[63495]	905	#if 0 /* unused */
	906
[41315]	907	/**
	908	* Converts a VHDX page 83 data item between file and host endianness.
	909	*
	910	* @returns nothing.
	911	* @param enmConv Direction of the conversion.
	912	* @param pPage83DataConv Where to store the converted page 83 data item entry.
	913	* @param pPage83Data The VHDX page 83 data item to convert.
	914	*
	915	* @note It is safe to use the same pointer for pPage83DataConv and pPage83Data.
	916	*/
	917	DECLINLINE(void) vhdxConvPage83DataEndianess(VHDXECONV enmConv, PVhdxPage83Data pPage83DataConv,
	918	PVhdxPage83Data pPage83Data)
	919	{
	920	vhdxConvUuidEndianess(enmConv, &pPage83DataConv->UuidPage83Data, &pPage83Data->UuidPage83Data);
	921	}
[63495]	922	#endif /* unused */
[41315]	923
	924	/**
	925	* Converts a VHDX logical sector size item between file and host endianness.
	926	*
	927	* @returns nothing.
	928	* @param enmConv Direction of the conversion.
	929	* @param pVDiskLogSectSizeConv Where to store the converted logical sector size item entry.
	930	* @param pVDiskLogSectSize The VHDX logical sector size item to convert.
	931	*
	932	* @note It is safe to use the same pointer for pVDiskLogSectSizeConv and pVDiskLogSectSize.
	933	*/
	934	DECLINLINE(void) vhdxConvVDiskLogSectSizeEndianess(VHDXECONV enmConv, PVhdxVDiskLogicalSectorSize pVDiskLogSectSizeConv,
	935	PVhdxVDiskLogicalSectorSize pVDiskLogSectSize)
	936	{
[41345]	937	pVDiskLogSectSizeConv->u32LogicalSectorSize = SET_ENDIAN_U32(pVDiskLogSectSize->u32LogicalSectorSize);
[41315]	938	}
	939
[63495]	940	#if 0 /* unused */
	941
[41315]	942	/**
	943	* Converts a VHDX physical sector size item between file and host endianness.
	944	*
	945	* @returns nothing.
	946	* @param enmConv Direction of the conversion.
	947	* @param pVDiskPhysSectSizeConv Where to store the converted physical sector size item entry.
	948	* @param pVDiskPhysSectSize The VHDX physical sector size item to convert.
	949	*
	950	* @note It is safe to use the same pointer for pVDiskPhysSectSizeConv and pVDiskPhysSectSize.
	951	*/
	952	DECLINLINE(void) vhdxConvVDiskPhysSectSizeEndianess(VHDXECONV enmConv, PVhdxVDiskPhysicalSectorSize pVDiskPhysSectSizeConv,
	953	PVhdxVDiskPhysicalSectorSize pVDiskPhysSectSize)
	954	{
	955	pVDiskPhysSectSizeConv->u64PhysicalSectorSize = SET_ENDIAN_U64(pVDiskPhysSectSize->u64PhysicalSectorSize);
	956	}
	957
[63495]	958
[41315]	959	/**
	960	* Converts a VHDX parent locator header item between file and host endianness.
	961	*
	962	* @returns nothing.
	963	* @param enmConv Direction of the conversion.
	964	* @param pParentLocatorHdrConv Where to store the converted parent locator header item entry.
	965	* @param pParentLocatorHdr The VHDX parent locator header item to convert.
	966	*
	967	* @note It is safe to use the same pointer for pParentLocatorHdrConv and pParentLocatorHdr.
	968	*/
	969	DECLINLINE(void) vhdxConvParentLocatorHeaderEndianness(VHDXECONV enmConv, PVhdxParentLocatorHeader pParentLocatorHdrConv,
	970	PVhdxParentLocatorHeader pParentLocatorHdr)
	971	{
	972	vhdxConvUuidEndianess(enmConv, &pParentLocatorHdrConv->UuidLocatorType, &pParentLocatorHdr->UuidLocatorType);
	973	pParentLocatorHdrConv->u16Reserved = SET_ENDIAN_U16(pParentLocatorHdr->u16Reserved);
	974	pParentLocatorHdrConv->u16KeyValueCount = SET_ENDIAN_U16(pParentLocatorHdr->u16KeyValueCount);
	975	}
	976
[63495]	977
[41315]	978	/**
	979	* Converts a VHDX parent locator entry between file and host endianness.
	980	*
	981	* @returns nothing.
	982	* @param enmConv Direction of the conversion.
	983	* @param pParentLocatorEntryConv Where to store the converted parent locator entry.
	984	* @param pParentLocatorEntry The VHDX parent locator entry to convert.
	985	*
	986	* @note It is safe to use the same pointer for pParentLocatorEntryConv and pParentLocatorEntry.
	987	*/
	988	DECLINLINE(void) vhdxConvParentLocatorEntryEndianess(VHDXECONV enmConv, PVhdxParentLocatorEntry pParentLocatorEntryConv,
	989	PVhdxParentLocatorEntry pParentLocatorEntry)
	990	{
	991	pParentLocatorEntryConv->u32KeyOffset = SET_ENDIAN_U32(pParentLocatorEntry->u32KeyOffset);
	992	pParentLocatorEntryConv->u32ValueOffset = SET_ENDIAN_U32(pParentLocatorEntry->u32ValueOffset);
	993	pParentLocatorEntryConv->u16KeyLength = SET_ENDIAN_U16(pParentLocatorEntry->u16KeyLength);
	994	pParentLocatorEntryConv->u16ValueLength = SET_ENDIAN_U16(pParentLocatorEntry->u16ValueLength);
	995	}
	996
[63495]	997	#endif /* unused */
	998
[41315]	999	/**
	1000	* Internal. Free all allocated space for representing an image except pImage,
	1001	* and optionally delete the image from disk.
	1002	*/
	1003	static int vhdxFreeImage(PVHDXIMAGE pImage, bool fDelete)
	1004	{
	1005	int rc = VINF_SUCCESS;
	1006
	1007	/* Freeing a never allocated image (e.g. because the open failed) is
	1008	* not signalled as an error. After all nothing bad happens. */
	1009	if (pImage)
	1010	{
	1011	if (pImage->pStorage)
	1012	{
[46613]	1013	rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
[41315]	1014	pImage->pStorage = NULL;
	1015	}
	1016
[41345]	1017	if (pImage->paBat)
	1018	{
	1019	RTMemFree(pImage->paBat);
	1020	pImage->paBat = NULL;
	1021	}
	1022
[41315]	1023	if (fDelete && pImage->pszFilename)
	1024	vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
	1025	}
	1026
	1027	LogFlowFunc(("returns %Rrc\n", rc));
	1028	return rc;
	1029	}
	1030
	1031	/**
	1032	* Loads all required fields from the given VHDX header.
	1033	* The header must be converted to the host endianess and validated already.
	1034	*
	1035	* @returns VBox status code.
	1036	* @param pImage Image instance data.
	1037	* @param pHdr The header to load.
	1038	*/
	1039	static int vhdxLoadHeader(PVHDXIMAGE pImage, PVhdxHeader pHdr)
	1040	{
	1041	int rc = VINF_SUCCESS;
	1042
	1043	LogFlowFunc(("pImage=%#p pHdr=%#p\n", pImage, pHdr));
	1044
	1045	/*
	1046	* Most fields in the header are not required because the backend implements
	1047	* readonly access only so far.
	1048	* We just have to check that the log is empty, we have to refuse to load the
	1049	* image otherwsie because replaying the log is not implemented.
	1050	*/
	1051	if (pHdr->u16Version == VHDX_HEADER_VHDX_VERSION)
	1052	{
	1053	/* Check that the log UUID is zero. */
	1054	pImage->uVersion = pHdr->u16Version;
	1055	if (!RTUuidIsNull(&pHdr->UuidLog))
	1056	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1057	"VHDX: Image \'%s\' has a non empty log which is not supported",
	1058	pImage->pszFilename);
	1059	}
	1060	else
	1061	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1062	"VHDX: Image \'%s\' uses an unsupported version (%u) of the VHDX format",
	1063	pImage->pszFilename, pHdr->u16Version);
	1064
	1065	LogFlowFunc(("return rc=%Rrc\n", rc));
	1066	return rc;
	1067	}
	1068
	1069	/**
	1070	* Determines the current header and loads it.
	1071	*
	1072	* @returns VBox status code.
	1073	* @param pImage Image instance data.
	1074	*/
	1075	static int vhdxFindAndLoadCurrentHeader(PVHDXIMAGE pImage)
	1076	{
[41447]	1077	PVhdxHeader pHdr1, pHdr2;
[41315]	1078	uint32_t u32ChkSum = 0;
	1079	uint32_t u32ChkSumSaved = 0;
	1080	bool fHdr1Valid = false;
	1081	bool fHdr2Valid = false;
	1082	int rc = VINF_SUCCESS;
	1083
	1084	LogFlowFunc(("pImage=%#p\n", pImage));
	1085
	1086	/*
	1087	* The VHDX format defines two headers at different offsets to provide failure
	1088	* consistency. Only one header is current. This can be determined using the
	1089	* sequence number and checksum fields in the header.
	1090	*/
[41447]	1091	pHdr1 = (PVhdxHeader)RTMemAllocZ(sizeof(VhdxHeader));
	1092	pHdr2 = (PVhdxHeader)RTMemAllocZ(sizeof(VhdxHeader));
[41315]	1093
[41447]	1094	if (pHdr1 && pHdr2)
[41315]	1095	{
[41447]	1096	/* Read the first header. */
	1097	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_HEADER1_OFFSET,
[44233]	1098	pHdr1, sizeof(*pHdr1));
[41447]	1099	if (RT_SUCCESS(rc))
	1100	{
	1101	vhdxConvHeaderEndianess(VHDXECONV_F2H, pHdr1, pHdr1);
[41315]	1102
[41447]	1103	/* Validate checksum. */
	1104	u32ChkSumSaved = pHdr1->u32Checksum;
	1105	pHdr1->u32Checksum = 0;
[50526]	1106	u32ChkSum = RTCrc32C(pHdr1, sizeof(VhdxHeader));
[41315]	1107
[41447]	1108	if ( pHdr1->u32Signature == VHDX_HEADER_SIGNATURE
[50526]	1109	&& u32ChkSum == u32ChkSumSaved)
[41447]	1110	fHdr1Valid = true;
	1111	}
[41315]	1112
[41447]	1113	/* Try to read the second header in any case (even if reading the first failed). */
	1114	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_HEADER2_OFFSET,
[44233]	1115	pHdr2, sizeof(*pHdr2));
[41447]	1116	if (RT_SUCCESS(rc))
	1117	{
	1118	vhdxConvHeaderEndianess(VHDXECONV_F2H, pHdr2, pHdr2);
[41315]	1119
[41447]	1120	/* Validate checksum. */
	1121	u32ChkSumSaved = pHdr2->u32Checksum;
	1122	pHdr2->u32Checksum = 0;
[50526]	1123	u32ChkSum = RTCrc32C(pHdr2, sizeof(VhdxHeader));
[41315]	1124
[41447]	1125	if ( pHdr2->u32Signature == VHDX_HEADER_SIGNATURE
[50526]	1126	&& u32ChkSum == u32ChkSumSaved)
[41447]	1127	fHdr2Valid = true;
	1128	}
[41315]	1129
[41447]	1130	/* Determine the current header. */
	1131	if (fHdr1Valid != fHdr2Valid)
	1132	{
	1133	/* Only one header is valid - use it. */
	1134	rc = vhdxLoadHeader(pImage, fHdr1Valid ? pHdr1 : pHdr2);
	1135	}
	1136	else if (!fHdr1Valid && !fHdr2Valid)
	1137	{
	1138	/* Crap, both headers are corrupt, refuse to load the image. */
	1139	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1140	"VHDX: Can not load the image because both headers are corrupt");
	1141	}
	1142	else
	1143	{
	1144	/* Both headers are valid. Use the sequence number to find the current one. */
	1145	if (pHdr1->u64SequenceNumber > pHdr2->u64SequenceNumber)
	1146	rc = vhdxLoadHeader(pImage, pHdr1);
	1147	else
	1148	rc = vhdxLoadHeader(pImage, pHdr2);
	1149	}
[41315]	1150	}
	1151	else
[41447]	1152	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	1153	"VHDX: Out of memory while allocating memory for the header");
[41315]	1154
[41447]	1155	if (pHdr1)
	1156	RTMemFree(pHdr1);
	1157	if (pHdr2)
	1158	RTMemFree(pHdr2);
	1159
[41315]	1160	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1161	return rc;
	1162	}
	1163
	1164	/**
	1165	* Loads the BAT region.
	1166	*
	1167	* @returns VBox status code.
	1168	* @param pImage Image instance data.
	1169	* @param offRegion Start offset of the region.
	1170	* @param cbRegion Size of the region.
	1171	*/
	1172	static int vhdxLoadBatRegion(PVHDXIMAGE pImage, uint64_t offRegion,
	1173	size_t cbRegion)
	1174	{
	1175	int rc = VINF_SUCCESS;
[41345]	1176	uint32_t cDataBlocks;
	1177	uint32_t uChunkRatio;
	1178	uint32_t cSectorBitmapBlocks;
	1179	uint32_t cBatEntries;
	1180	uint32_t cbBatEntries;
	1181	PVhdxBatEntry paBatEntries = NULL;
[41315]	1182
	1183	LogFlowFunc(("pImage=%#p\n", pImage));
	1184
[41350]	1185	/* Calculate required values first. */
[48851]	1186	uint64_t uChunkRatio64 = (RT_BIT_64(23) * pImage->cbLogicalSector) / pImage->cbBlock;
	1187	uChunkRatio = (uint32_t)uChunkRatio64; Assert(uChunkRatio == uChunkRatio64);
	1188	uint64_t cDataBlocks64 = pImage->cbSize / pImage->cbBlock;
	1189	cDataBlocks = (uint32_t)cDataBlocks64; Assert(cDataBlocks == cDataBlocks64);
	1190
[41345]	1191	if (pImage->cbSize % pImage->cbBlock)
	1192	cDataBlocks++;
	1193
	1194	cSectorBitmapBlocks = cDataBlocks / uChunkRatio;
	1195	if (cDataBlocks % uChunkRatio)
	1196	cSectorBitmapBlocks++;
	1197
	1198	cBatEntries = cDataBlocks + (cDataBlocks - 1)/uChunkRatio;
	1199	cbBatEntries = cBatEntries * sizeof(VhdxBatEntry);
	1200
	1201	if (cbBatEntries <= cbRegion)
	1202	{
	1203	/*
	1204	* Load the complete BAT region first, convert to host endianess and process
	1205	* it afterwards. The SB entries can be removed because they are not needed yet.
	1206	*/
	1207	paBatEntries = (PVhdxBatEntry)RTMemAlloc(cbBatEntries);
	1208	if (paBatEntries)
	1209	{
	1210	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offRegion,
[44233]	1211	paBatEntries, cbBatEntries);
[41345]	1212	if (RT_SUCCESS(rc))
	1213	{
	1214	vhdxConvBatTableEndianess(VHDXECONV_F2H, paBatEntries, paBatEntries,
	1215	cBatEntries);
	1216
	1217	/* Go through the table and validate it. */
	1218	for (unsigned i = 0; i < cBatEntries; i++)
	1219	{
	1220	if ( i != 0
	1221	&& (i % uChunkRatio) == 0)
	1222	{
[46029]	1223	/**
	1224	* Disabled the verification because there are images out there with the sector bitmap
	1225	* marked as present. The entry is never accessed and the image is readonly anyway,
	1226	* so no harm done.
	1227	*/
	1228	#if 0
[41345]	1229	/* Sector bitmap block. */
	1230	if ( VHDX_BAT_ENTRY_GET_STATE(paBatEntries[i].u64BatEntry)
	1231	!= VHDX_BAT_ENTRY_SB_BLOCK_NOT_PRESENT)
	1232	{
	1233	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1234	"VHDX: Sector bitmap block at entry %u of image \'%s\' marked as present, violation of the specification",
	1235	i, pImage->pszFilename);
	1236	break;
	1237	}
[46029]	1238	#endif
[41345]	1239	}
	1240	else
	1241	{
	1242	/* Payload block. */
	1243	if ( VHDX_BAT_ENTRY_GET_STATE(paBatEntries[i].u64BatEntry)
	1244	== VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT)
	1245	{
	1246	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1247	"VHDX: Payload block at entry %u of image \'%s\' marked as partially present, violation of the specification",
	1248	i, pImage->pszFilename);
	1249	break;
	1250	}
	1251	}
	1252	}
	1253
	1254	if (RT_SUCCESS(rc))
	1255	{
	1256	pImage->paBat = paBatEntries;
	1257	pImage->uChunkRatio = uChunkRatio;
	1258	}
	1259	}
	1260	else
	1261	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1262	"VHDX: Error reading the BAT from image \'%s\'",
	1263	pImage->pszFilename);
	1264	}
	1265	else
	1266	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	1267	"VHDX: Out of memory allocating memory for %u BAT entries of image \'%s\'",
[57007]	1268	cBatEntries, pImage->pszFilename);
[41345]	1269	}
	1270	else
	1271	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1272	"VHDX: Mismatch between calculated number of BAT entries and region size (expected %u got %u) for image \'%s\'",
	1273	cbBatEntries, cbRegion, pImage->pszFilename);
	1274
	1275	if ( RT_FAILURE(rc)
	1276	&& paBatEntries)
	1277	RTMemFree(paBatEntries);
	1278
[41315]	1279	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1280	return rc;
	1281	}
	1282
	1283	/**
[41345]	1284	* Load the file parameters metadata item from the file.
	1285	*
	1286	* @returns VBox status code.
	1287	* @param pImage Image instance data.
	1288	* @param offItem File offset where the data is stored.
	1289	* @param cbItem Size of the item in the file.
	1290	*/
	1291	static int vhdxLoadFileParametersMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
	1292	{
	1293	int rc = VINF_SUCCESS;
	1294
	1295	LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));
	1296
	1297	if (cbItem != sizeof(VhdxFileParameters))
	1298	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1299	"VHDX: File parameters item size mismatch (expected %u got %zu) in image \'%s\'",
	1300	sizeof(VhdxFileParameters), cbItem, pImage->pszFilename);
	1301	else
	1302	{
	1303	VhdxFileParameters FileParameters;
	1304
	1305	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
[44233]	1306	&FileParameters, sizeof(FileParameters));
[41345]	1307	if (RT_SUCCESS(rc))
	1308	{
	1309	vhdxConvFileParamsEndianess(VHDXECONV_F2H, &FileParameters, &FileParameters);
	1310	pImage->cbBlock = FileParameters.u32BlockSize;
	1311
[63567]	1312	/** @todo No support for differencing images yet. */
[41345]	1313	if (FileParameters.u32Flags & VHDX_FILE_PARAMETERS_FLAGS_HAS_PARENT)
	1314	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1315	"VHDX: Image \'%s\' is a differencing image which is not supported yet",
	1316	pImage->pszFilename);
	1317	}
	1318	else
	1319	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1320	"VHDX: Reading the file parameters metadata item from image \'%s\' failed",
	1321	pImage->pszFilename);
	1322	}
	1323
	1324	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1325	return rc;
	1326	}
	1327
	1328	/**
	1329	* Load the virtual disk size metadata item from the file.
	1330	*
	1331	* @returns VBox status code.
	1332	* @param pImage Image instance data.
	1333	* @param offItem File offset where the data is stored.
	1334	* @param cbItem Size of the item in the file.
	1335	*/
	1336	static int vhdxLoadVDiskSizeMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
	1337	{
	1338	int rc = VINF_SUCCESS;
	1339
	1340	LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));
	1341
	1342	if (cbItem != sizeof(VhdxVDiskSize))
	1343	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1344	"VHDX: Virtual disk size item size mismatch (expected %u got %zu) in image \'%s\'",
	1345	sizeof(VhdxVDiskSize), cbItem, pImage->pszFilename);
	1346	else
	1347	{
	1348	VhdxVDiskSize VDiskSize;
	1349
	1350	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
[44233]	1351	&VDiskSize, sizeof(VDiskSize));
[41345]	1352	if (RT_SUCCESS(rc))
	1353	{
	1354	vhdxConvVDiskSizeEndianess(VHDXECONV_F2H, &VDiskSize, &VDiskSize);
	1355	pImage->cbSize = VDiskSize.u64VDiskSize;
	1356	}
	1357	else
	1358	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1359	"VHDX: Reading the virtual disk size metadata item from image \'%s\' failed",
	1360	pImage->pszFilename);
	1361	}
	1362
	1363	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1364	return rc;
	1365	}
	1366
	1367	/**
	1368	* Load the logical sector size metadata item from the file.
	1369	*
	1370	* @returns VBox status code.
	1371	* @param pImage Image instance data.
	1372	* @param offItem File offset where the data is stored.
	1373	* @param cbItem Size of the item in the file.
	1374	*/
	1375	static int vhdxLoadVDiskLogSectorSizeMetadata(PVHDXIMAGE pImage, uint64_t offItem, size_t cbItem)
	1376	{
	1377	int rc = VINF_SUCCESS;
	1378
	1379	LogFlowFunc(("pImage=%#p offItem=%llu cbItem=%zu\n", pImage, offItem, cbItem));
	1380
	1381	if (cbItem != sizeof(VhdxVDiskLogicalSectorSize))
	1382	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1383	"VHDX: Virtual disk logical sector size item size mismatch (expected %u got %zu) in image \'%s\'",
	1384	sizeof(VhdxVDiskLogicalSectorSize), cbItem, pImage->pszFilename);
	1385	else
	1386	{
	1387	VhdxVDiskLogicalSectorSize VDiskLogSectSize;
	1388
	1389	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offItem,
[44233]	1390	&VDiskLogSectSize, sizeof(VDiskLogSectSize));
[41345]	1391	if (RT_SUCCESS(rc))
	1392	{
	1393	vhdxConvVDiskLogSectSizeEndianess(VHDXECONV_F2H, &VDiskLogSectSize,
	1394	&VDiskLogSectSize);
	1395	pImage->cbLogicalSector = VDiskLogSectSize.u32LogicalSectorSize;
	1396	}
	1397	else
	1398	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1399	"VHDX: Reading the virtual disk logical sector size metadata item from image \'%s\' failed",
	1400	pImage->pszFilename);
	1401	}
	1402
	1403	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1404	return rc;
	1405	}
	1406
	1407	/**
[41315]	1408	* Loads the metadata region.
	1409	*
	1410	* @returns VBox status code.
	1411	* @param pImage Image instance data.
	1412	* @param offRegion Start offset of the region.
	1413	* @param cbRegion Size of the region.
	1414	*/
	1415	static int vhdxLoadMetadataRegion(PVHDXIMAGE pImage, uint64_t offRegion,
	1416	size_t cbRegion)
	1417	{
	1418	VhdxMetadataTblHdr MetadataTblHdr;
	1419	int rc = VINF_SUCCESS;
	1420
	1421	LogFlowFunc(("pImage=%#p\n", pImage));
	1422
	1423	/* Load the header first. */
	1424	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offRegion,
[44233]	1425	&MetadataTblHdr, sizeof(MetadataTblHdr));
[41315]	1426	if (RT_SUCCESS(rc))
	1427	{
	1428	vhdxConvMetadataTblHdrEndianess(VHDXECONV_F2H, &MetadataTblHdr, &MetadataTblHdr);
	1429
	1430	/* Validate structure. */
	1431	if (MetadataTblHdr.u64Signature != VHDX_METADATA_TBL_HDR_SIGNATURE)
	1432	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1433	"VHDX: Incorrect metadata table header signature for image \'%s\'",
	1434	pImage->pszFilename);
	1435	else if (MetadataTblHdr.u16EntryCount > VHDX_METADATA_TBL_HDR_ENTRY_COUNT_MAX)
	1436	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1437	"VHDX: Incorrect entry count in metadata table header of image \'%s\'",
	1438	pImage->pszFilename);
	1439	else if (cbRegion < (MetadataTblHdr.u16EntryCount * sizeof(VhdxMetadataTblEntry) + sizeof(VhdxMetadataTblHdr)))
	1440	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1441	"VHDX: Metadata table of image \'%s\' exceeds region size",
	1442	pImage->pszFilename);
	1443
	1444	if (RT_SUCCESS(rc))
	1445	{
	1446	uint64_t offMetadataTblEntry = offRegion + sizeof(VhdxMetadataTblHdr);
	1447
	1448	for (unsigned i = 0; i < MetadataTblHdr.u16EntryCount; i++)
	1449	{
	1450	uint64_t offMetadataItem = 0;
	1451	VHDXMETADATAITEM enmMetadataItem = VHDXMETADATAITEM_UNKNOWN;
	1452	VhdxMetadataTblEntry MetadataTblEntry;
	1453
	1454	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, offMetadataTblEntry,
[44233]	1455	&MetadataTblEntry, sizeof(MetadataTblEntry));
[41315]	1456	if (RT_FAILURE(rc))
	1457	{
	1458	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1459	"VHDX: Reading metadata table entry from image \'%s\' failed",
	1460	pImage->pszFilename);
	1461	break;
	1462	}
	1463
	1464	vhdxConvMetadataTblEntryEndianess(VHDXECONV_F2H, &MetadataTblEntry, &MetadataTblEntry);
	1465
	1466	/* Check whether the flags match the expectations. */
	1467	for (unsigned idxProp = 0; idxProp < RT_ELEMENTS(s_aVhdxMetadataItemProps); idxProp++)
	1468	{
	1469	if (!RTUuidCompareStr(&MetadataTblEntry.UuidItem,
	1470	s_aVhdxMetadataItemProps[idxProp].pszItemUuid))
	1471	{
[46029]	1472	/*
	1473	* Check for specification violations and bail out, except
	1474	* for the required flag of the physical sector size metadata item.
	1475	* Early images had the required flag not set opposed to the specification.
	1476	* We don't want to brerak those images.
	1477	*/
[41315]	1478	if ( !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_USER)
	1479	!= s_aVhdxMetadataItemProps[idxProp].fIsUser)
	1480	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1481	"VHDX: User flag of metadata item does not meet expectations \'%s\'",
	1482	pImage->pszFilename);
	1483	else if ( !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_VDISK)
	1484	!= s_aVhdxMetadataItemProps[idxProp].fIsVDisk)
	1485	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1486	"VHDX: Virtual disk flag of metadata item does not meet expectations \'%s\'",
	1487	pImage->pszFilename);
[46029]	1488	else if ( !!(MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED)
	1489	!= s_aVhdxMetadataItemProps[idxProp].fIsRequired
	1490	&& (s_aVhdxMetadataItemProps[idxProp].enmMetadataItem != VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE))
[41315]	1491	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1492	"VHDX: Required flag of metadata item does not meet expectations \'%s\'",
	1493	pImage->pszFilename);
	1494	else
	1495	enmMetadataItem = s_aVhdxMetadataItemProps[idxProp].enmMetadataItem;
	1496
	1497	break;
	1498	}
	1499	}
	1500
	1501	if (RT_FAILURE(rc))
	1502	break;
	1503
	1504	offMetadataItem = offRegion + MetadataTblEntry.u32Offset;
	1505
	1506	switch (enmMetadataItem)
	1507	{
	1508	case VHDXMETADATAITEM_FILE_PARAMS:
	1509	{
[41345]	1510	rc = vhdxLoadFileParametersMetadata(pImage, offMetadataItem,
	1511	MetadataTblEntry.u32Length);
[41315]	1512	break;
	1513	}
	1514	case VHDXMETADATAITEM_VDISK_SIZE:
	1515	{
[41345]	1516	rc = vhdxLoadVDiskSizeMetadata(pImage, offMetadataItem,
	1517	MetadataTblEntry.u32Length);
[41315]	1518	break;
	1519	}
	1520	case VHDXMETADATAITEM_PAGE83_DATA:
	1521	{
	1522	/*
	1523	* Nothing to do here for now (marked as required but
	1524	* there is no API to pass this information to the caller)
	1525	* so far.
	1526	*/
	1527	break;
	1528	}
	1529	case VHDXMETADATAITEM_LOGICAL_SECTOR_SIZE:
	1530	{
[41345]	1531	rc = vhdxLoadVDiskLogSectorSizeMetadata(pImage, offMetadataItem,
	1532	MetadataTblEntry.u32Length);
[41315]	1533	break;
	1534	}
	1535	case VHDXMETADATAITEM_PHYSICAL_SECTOR_SIZE:
	1536	{
	1537	/*
	1538	* Nothing to do here for now (marked as required but
	1539	* there is no API to pass this information to the caller)
	1540	* so far.
	1541	*/
	1542	break;
	1543	}
	1544	case VHDXMETADATAITEM_PARENT_LOCATOR:
	1545	{
[41345]	1546	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1547	"VHDX: Image \'%s\' is a differencing image which is not supported yet",
	1548	pImage->pszFilename);
[41315]	1549	break;
	1550	}
	1551	case VHDXMETADATAITEM_UNKNOWN:
	1552	default:
	1553	if (MetadataTblEntry.u32Flags & VHDX_METADATA_TBL_ENTRY_FLAGS_IS_REQUIRED)
	1554	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1555	"VHDX: Unsupported but required metadata item in image \'%s\'",
	1556	pImage->pszFilename);
	1557	}
	1558
	1559	if (RT_FAILURE(rc))
	1560	break;
	1561
	1562	offMetadataTblEntry += sizeof(MetadataTblEntry);
	1563	}
	1564	}
	1565	}
	1566	else
	1567	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1568	"VHDX: Reading the metadata table header for image \'%s\' failed",
	1569	pImage->pszFilename);
	1570
	1571	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1572	return rc;
	1573	}
	1574
	1575	/**
	1576	* Loads the region table and the associated regions.
	1577	*
	1578	* @returns VBox status code.
	1579	* @param pImage Image instance data.
	1580	*/
	1581	static int vhdxLoadRegionTable(PVHDXIMAGE pImage)
	1582	{
	1583	uint8_t *pbRegionTbl = NULL;
	1584	int rc = VINF_SUCCESS;
	1585
	1586	LogFlowFunc(("pImage=%#p\n", pImage));
	1587
	1588	/* Load the complete region table into memory. */
	1589	pbRegionTbl = (uint8_t *)RTMemTmpAlloc(VHDX_REGION_TBL_SIZE_MAX);
	1590	if (pbRegionTbl)
	1591	{
	1592	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_REGION_TBL_HDR_OFFSET,
[44233]	1593	pbRegionTbl, VHDX_REGION_TBL_SIZE_MAX);
[41315]	1594	if (RT_SUCCESS(rc))
	1595	{
	1596	PVhdxRegionTblHdr pRegionTblHdr;
	1597	VhdxRegionTblHdr RegionTblHdr;
	1598	uint32_t u32ChkSum = 0;
	1599
	1600	/*
	1601	* Copy the region table header to a dedicated structure where we can
	1602	* convert it to host endianess.
	1603	*/
	1604	memcpy(&RegionTblHdr, pbRegionTbl, sizeof(RegionTblHdr));
	1605	vhdxConvRegionTblHdrEndianess(VHDXECONV_F2H, &RegionTblHdr, &RegionTblHdr);
	1606
	1607	/* Set checksum field to 0 during crc computation. */
	1608	pRegionTblHdr = (PVhdxRegionTblHdr)pbRegionTbl;
	1609	pRegionTblHdr->u32Checksum = 0;
	1610
	1611	/* Verify the region table integrity. */
[50526]	1612	u32ChkSum = RTCrc32C(pbRegionTbl, VHDX_REGION_TBL_SIZE_MAX);
[41315]	1613
	1614	if (RegionTblHdr.u32Signature != VHDX_REGION_TBL_HDR_SIGNATURE)
	1615	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1616	"VHDX: Invalid signature for region table header of image \'%s\'",
	1617	pImage->pszFilename);
	1618	else if (u32ChkSum != RegionTblHdr.u32Checksum)
	1619	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1620	"VHDX: CRC32 checksum mismatch for the region table of image \'%s\' (expected %#x got %#x)",
	1621	pImage->pszFilename, RegionTblHdr.u32Checksum, u32ChkSum);
	1622	else if (RegionTblHdr.u32EntryCount > VHDX_REGION_TBL_HDR_ENTRY_COUNT_MAX)
	1623	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1624	"VHDX: Invalid entry count field in the region table header of image \'%s\'",
	1625	pImage->pszFilename);
	1626
	1627	if (RT_SUCCESS(rc))
	1628	{
	1629	/* Parse the region table entries. */
	1630	PVhdxRegionTblEntry pRegTblEntry = (PVhdxRegionTblEntry)(pbRegionTbl + sizeof(VhdxRegionTblHdr));
[48861]	1631	VhdxRegionTblEntry RegTblEntryBat; /* BAT region table entry. */
[41345]	1632	bool fBatRegPresent = false;
[48861]	1633	RT_ZERO(RegTblEntryBat); /* Maybe uninitialized, gcc. */
[41315]	1634
	1635	for (unsigned i = 0; i < RegionTblHdr.u32EntryCount; i++)
	1636	{
	1637	vhdxConvRegionTblEntryEndianess(VHDXECONV_F2H, pRegTblEntry, pRegTblEntry);
	1638
	1639	/* Check the uuid for known regions. */
	1640	if (!RTUuidCompareStr(&pRegTblEntry->UuidObject, VHDX_REGION_TBL_ENTRY_UUID_BAT))
	1641	{
[41345]	1642	/*
	1643	* Save the BAT region and process it later.
	1644	* It may come before the metadata region but needs the block size.
	1645	*/
[41315]	1646	if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
[41345]	1647	{
	1648	fBatRegPresent = true;
[41350]	1649	RegTblEntryBat.u32Length = pRegTblEntry->u32Length;
	1650	RegTblEntryBat.u64FileOffset = pRegTblEntry->u64FileOffset;
[41345]	1651	}
[41315]	1652	else
	1653	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1654	"VHDX: BAT region not marked as required in image \'%s\'",
	1655	pImage->pszFilename);
	1656	}
	1657	else if (!RTUuidCompareStr(&pRegTblEntry->UuidObject, VHDX_REGION_TBL_ENTRY_UUID_METADATA))
	1658	{
	1659	if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
	1660	rc = vhdxLoadMetadataRegion(pImage, pRegTblEntry->u64FileOffset, pRegTblEntry->u32Length);
	1661	else
	1662	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1663	"VHDX: Metadata region not marked as required in image \'%s\'",
	1664	pImage->pszFilename);
	1665	}
	1666	else if (pRegTblEntry->u32Flags & VHDX_REGION_TBL_ENTRY_FLAGS_IS_REQUIRED)
	1667	{
	1668	/* The region is not known but marked as required, fail to load the image. */
	1669	rc = vdIfError(pImage->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
	1670	"VHDX: Unknown required region in image \'%s\'",
	1671	pImage->pszFilename);
	1672	}
	1673
	1674	if (RT_FAILURE(rc))
	1675	break;
	1676
	1677	pRegTblEntry++;
	1678	}
[41345]	1679
	1680	if (fBatRegPresent)
	1681	rc = vhdxLoadBatRegion(pImage, RegTblEntryBat.u64FileOffset, RegTblEntryBat.u32Length);
	1682	else
	1683	rc = vdIfError(pImage->pIfError, VERR_VD_GEN_INVALID_HEADER, RT_SRC_POS,
	1684	"VHDX: BAT region in image \'%s\' is missing",
	1685	pImage->pszFilename);
[41315]	1686	}
	1687	}
	1688	else
	1689	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS,
	1690	"VHDX: Reading the region table for image \'%s\' failed",
	1691	pImage->pszFilename);
	1692	}
	1693	else
	1694	rc = vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS,
	1695	"VHDX: Out of memory allocating memory for the region table of image \'%s\'",
	1696	pImage->pszFilename);
	1697
	1698	if (pbRegionTbl)
	1699	RTMemTmpFree(pbRegionTbl);
	1700
	1701	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1702	return rc;
	1703	}
	1704
	1705	/**
	1706	* Internal: Open an image, constructing all necessary data structures.
	1707	*/
	1708	static int vhdxOpenImage(PVHDXIMAGE pImage, unsigned uOpenFlags)
	1709	{
	1710	uint64_t cbFile = 0;
	1711	VhdxFileIdentifier FileIdentifier;
	1712	int rc = VINF_SUCCESS;
	1713
	1714	LogFlowFunc(("pImage=%#p uOpenFlags=%#x\n", pImage, uOpenFlags));
	1715	pImage->uOpenFlags = uOpenFlags;
	1716
	1717	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
	1718	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
	1719	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
	1720
	1721	/* Refuse write access, it is not implemented so far. */
	1722	if (!(uOpenFlags & VD_OPEN_FLAGS_READONLY))
	1723	return VERR_NOT_SUPPORTED;
	1724
	1725	/*
	1726	* Open the image.
	1727	*/
	1728	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
	1729	VDOpenFlagsToFileOpenFlags(uOpenFlags,
	1730	false /* fCreate */),
	1731	&pImage->pStorage);
	1732
	1733	/* Do NOT signal an appropriate error here, as the VD layer has the
	1734	* choice of retrying the open if it failed. */
	1735	if (RT_SUCCESS(rc))
	1736	rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
	1737
	1738	if (RT_SUCCESS(rc))
	1739	{
	1740	if (cbFile > sizeof(FileIdentifier))
	1741	{
	1742	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, VHDX_FILE_IDENTIFIER_OFFSET,
[44233]	1743	&FileIdentifier, sizeof(FileIdentifier));
[41315]	1744	if (RT_SUCCESS(rc))
	1745	{
	1746	vhdxConvFileIdentifierEndianess(VHDXECONV_F2H, &FileIdentifier,
	1747	&FileIdentifier);
	1748	if (FileIdentifier.u64Signature != VHDX_FILE_IDENTIFIER_SIGNATURE)
	1749	rc = VERR_VD_GEN_INVALID_HEADER;
	1750	else
	1751	rc = vhdxFindAndLoadCurrentHeader(pImage);
	1752
	1753	/* Load the region table. */
	1754	if (RT_SUCCESS(rc))
	1755	rc = vhdxLoadRegionTable(pImage);
	1756	}
	1757	}
	1758	else
	1759	rc = VERR_VD_GEN_INVALID_HEADER;
	1760	}
	1761
[66486]	1762	if (RT_SUCCESS(rc))
	1763	{
	1764	PVDREGIONDESC pRegion = &pImage->RegionList.aRegions[0];
	1765	pImage->RegionList.fFlags = 0;
	1766	pImage->RegionList.cRegions = 1;
	1767
	1768	pRegion->offRegion = 0; /* Disk start. */
	1769	pRegion->cbBlock = pImage->cbLogicalSector;
	1770	pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
	1771	pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
	1772	pRegion->cbData = pImage->cbLogicalSector;
	1773	pRegion->cbMetadata = 0;
	1774	pRegion->cRegionBlocksOrBytes = pImage->cbSize;
	1775	}
	1776	else
[41315]	1777	vhdxFreeImage(pImage, false);
	1778
	1779	LogFlowFunc(("returns rc=%Rrc\n", rc));
	1780	return rc;
	1781	}
	1782
	1783
[63802]	1784	/** @copydoc VDIMAGEBACKEND::pfnProbe */
	1785	static DECLCALLBACK(int) vhdxProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
[79965]	1786	PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
[41315]	1787	{
[79965]	1788	RT_NOREF(pVDIfsDisk, enmDesiredType);
[41315]	1789	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
	1790	PVDIOSTORAGE pStorage = NULL;
	1791	uint64_t cbFile;
	1792	int rc = VINF_SUCCESS;
	1793	VhdxFileIdentifier FileIdentifier;
	1794
	1795	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
	1796	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
	1797
[90802]	1798	if ( !RT_VALID_PTR(pszFilename)
[41315]	1799	\|\| !*pszFilename)
	1800	rc = VERR_INVALID_PARAMETER;
	1801	else
	1802	{
	1803	/*
	1804	* Open the file and read the file identifier.
	1805	*/
	1806	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
	1807	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
	1808	false /* fCreate */),
	1809	&pStorage);
	1810	if (RT_SUCCESS(rc))
[62743]	1811	{
[41315]	1812	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
[62743]	1813	if (RT_SUCCESS(rc))
[41315]	1814	{
[62743]	1815	if (cbFile > sizeof(FileIdentifier))
[41315]	1816	{
[62743]	1817	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, VHDX_FILE_IDENTIFIER_OFFSET,
	1818	&FileIdentifier, sizeof(FileIdentifier));
	1819	if (RT_SUCCESS(rc))
	1820	{
	1821	vhdxConvFileIdentifierEndianess(VHDXECONV_F2H, &FileIdentifier,
	1822	&FileIdentifier);
	1823	if (FileIdentifier.u64Signature != VHDX_FILE_IDENTIFIER_SIGNATURE)
	1824	rc = VERR_VD_GEN_INVALID_HEADER;
	1825	else
	1826	*penmType = VDTYPE_HDD;
	1827	}
[41315]	1828	}
[62743]	1829	else
	1830	rc = VERR_VD_GEN_INVALID_HEADER;
[41315]	1831	}
	1832	}
	1833
	1834	if (pStorage)
	1835	vdIfIoIntFileClose(pIfIo, pStorage);
	1836	}
	1837
	1838	LogFlowFunc(("returns %Rrc\n", rc));
	1839	return rc;
	1840	}
	1841
[63785]	1842	/** @copydoc VDIMAGEBACKEND::pfnOpen */
[57388]	1843	static DECLCALLBACK(int) vhdxOpen(const char *pszFilename, unsigned uOpenFlags,
	1844	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	1845	VDTYPE enmType, void **ppBackendData)
[41315]	1846	{
[54430]	1847	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
[41315]	1848	int rc;
	1849	PVHDXIMAGE pImage;
	1850
[54430]	1851	NOREF(enmType); /*< @todo r=klaus make use of the type info. /
	1852
[41315]	1853	/* Check open flags. All valid flags are supported. */
	1854	if ( uOpenFlags & ~VD_OPEN_FLAGS_MASK
[90802]	1855	\|\| !RT_VALID_PTR(pszFilename)
[41315]	1856	\|\| !*pszFilename)
	1857	rc = VERR_INVALID_PARAMETER;
	1858	else
	1859	{
[66486]	1860	pImage = (PVHDXIMAGE)RTMemAllocZ(RT_UOFFSETOF(VHDXIMAGE, RegionList.aRegions[1]));
[41315]	1861	if (!pImage)
	1862	rc = VERR_NO_MEMORY;
	1863	else
	1864	{
	1865	pImage->pszFilename = pszFilename;
	1866	pImage->pStorage = NULL;
	1867	pImage->pVDIfsDisk = pVDIfsDisk;
	1868	pImage->pVDIfsImage = pVDIfsImage;
	1869
	1870	rc = vhdxOpenImage(pImage, uOpenFlags);
	1871	if (RT_SUCCESS(rc))
	1872	*ppBackendData = pImage;
	1873	else
	1874	RTMemFree(pImage);
	1875	}
	1876	}
	1877
	1878	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
	1879	return rc;
	1880	}
	1881
[63785]	1882	/** @interface_method_impl{VDIMAGEBACKEND,pfnCreate} */
[54430]	1883	static DECLCALLBACK(int) vhdxCreate(const char *pszFilename, uint64_t cbSize,
	1884	unsigned uImageFlags, const char *pszComment,
	1885	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
	1886	PCRTUUID pUuid, unsigned uOpenFlags,
	1887	unsigned uPercentStart, unsigned uPercentSpan,
	1888	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	1889	PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
	1890	void **ppBackendData)
	1891	{
[62743]	1892	RT_NOREF8(pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags);
	1893	RT_NOREF7(uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData);
[54430]	1894	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",
	1895	pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
	1896	int rc = VERR_NOT_SUPPORTED;
	1897
	1898	LogFlowFunc(("returns %Rrc\n", rc));
	1899	return rc;
	1900	}
	1901
[63785]	1902	/** @copydoc VDIMAGEBACKEND::pfnRename */
[57388]	1903	static DECLCALLBACK(int) vhdxRename(void pBackendData, const char pszFilename)
[41315]	1904	{
	1905	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
	1906	int rc = VINF_SUCCESS;
	1907	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	1908
	1909	/* Check arguments. */
	1910	if ( !pImage
	1911	\|\| !pszFilename
	1912	\|\| !*pszFilename)
	1913	rc = VERR_INVALID_PARAMETER;
	1914	else
	1915	{
	1916	/* Close the image. */
	1917	rc = vhdxFreeImage(pImage, false);
	1918	if (RT_SUCCESS(rc))
	1919	{
	1920	/* Rename the file. */
	1921	rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
	1922	if (RT_FAILURE(rc))
	1923	{
	1924	/* The move failed, try to reopen the original image. */
	1925	int rc2 = vhdxOpenImage(pImage, pImage->uOpenFlags);
	1926	if (RT_FAILURE(rc2))
	1927	rc = rc2;
	1928	}
	1929	else
	1930	{
	1931	/* Update pImage with the new information. */
	1932	pImage->pszFilename = pszFilename;
	1933
	1934	/* Open the old image with new name. */
	1935	rc = vhdxOpenImage(pImage, pImage->uOpenFlags);
	1936	}
	1937	}
	1938	}
	1939
	1940	LogFlowFunc(("returns %Rrc\n", rc));
	1941	return rc;
	1942	}
	1943
[63785]	1944	/** @copydoc VDIMAGEBACKEND::pfnClose */
[57388]	1945	static DECLCALLBACK(int) vhdxClose(void *pBackendData, bool fDelete)
[41315]	1946	{
	1947	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
	1948	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	1949	int rc;
	1950
	1951	rc = vhdxFreeImage(pImage, fDelete);
	1952	RTMemFree(pImage);
	1953
	1954	LogFlowFunc(("returns %Rrc\n", rc));
	1955	return rc;
	1956	}
	1957
[63785]	1958	/** @copydoc VDIMAGEBACKEND::pfnRead */
[57388]	1959	static DECLCALLBACK(int) vhdxRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
	1960	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
[41315]	1961	{
[44252]	1962	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
	1963	pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
[41315]	1964	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
[41350]	1965	int rc = VINF_SUCCESS;
[41315]	1966
	1967	AssertPtr(pImage);
	1968	Assert(uOffset % 512 == 0);
	1969	Assert(cbToRead % 512 == 0);
	1970
	1971	if ( uOffset + cbToRead > pImage->cbSize
	1972	\|\| cbToRead == 0)
	1973	rc = VERR_INVALID_PARAMETER;
	1974	else
	1975	{
[48851]	1976	uint32_t idxBat = (uint32_t)(uOffset / pImage->cbBlock); Assert(idxBat == uOffset / pImage->cbBlock);
[41345]	1977	uint32_t offRead = uOffset % pImage->cbBlock;
	1978	uint64_t uBatEntry;
	1979
	1980	idxBat += idxBat / pImage->uChunkRatio; /* Add interleaving sector bitmap entries. */
	1981	uBatEntry = pImage->paBat[idxBat].u64BatEntry;
	1982
	1983	cbToRead = RT_MIN(cbToRead, pImage->cbBlock - offRead);
	1984
	1985	switch (VHDX_BAT_ENTRY_GET_STATE(uBatEntry))
	1986	{
	1987	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_NOT_PRESENT:
	1988	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNDEFINED:
	1989	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_ZERO:
	1990	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_UNMAPPED:
	1991	{
[44252]	1992	vdIfIoIntIoCtxSet(pImage->pIfIo, pIoCtx, 0, cbToRead);
[41345]	1993	break;
	1994	}
	1995	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_FULLY_PRESENT:
	1996	{
	1997	uint64_t offFile = VHDX_BAT_ENTRY_GET_FILE_OFFSET(uBatEntry) + offRead;
[44252]	1998	rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, offFile,
	1999	pIoCtx, cbToRead);
[41345]	2000	break;
	2001	}
	2002	case VHDX_BAT_ENTRY_PAYLOAD_BLOCK_PARTIALLY_PRESENT:
	2003	default:
	2004	rc = VERR_INVALID_PARAMETER;
	2005	break;
	2006	}
	2007
[41315]	2008	if (pcbActuallyRead)
	2009	*pcbActuallyRead = cbToRead;
	2010	}
	2011
	2012	LogFlowFunc(("returns %Rrc\n", rc));
	2013	return rc;
	2014	}
	2015
[63785]	2016	/** @copydoc VDIMAGEBACKEND::pfnWrite */
[57388]	2017	static DECLCALLBACK(int) vhdxWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
	2018	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
	2019	size_t *pcbPostRead, unsigned fWrite)
[41315]	2020	{
[62743]	2021	RT_NOREF5(pIoCtx, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
[44252]	2022	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
	2023	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
[41315]	2024	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2025	int rc;
	2026
	2027	AssertPtr(pImage);
	2028	Assert(uOffset % 512 == 0);
	2029	Assert(cbToWrite % 512 == 0);
	2030
	2031	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2032	rc = VERR_VD_IMAGE_READ_ONLY;
	2033	else if ( uOffset + cbToWrite > pImage->cbSize
	2034	\|\| cbToWrite == 0)
	2035	rc = VERR_INVALID_PARAMETER;
	2036	else
	2037	rc = VERR_NOT_SUPPORTED;
	2038
	2039	LogFlowFunc(("returns %Rrc\n", rc));
	2040	return rc;
	2041	}
	2042
[63785]	2043	/** @copydoc VDIMAGEBACKEND::pfnFlush */
[57388]	2044	static DECLCALLBACK(int) vhdxFlush(void *pBackendData, PVDIOCTX pIoCtx)
[41315]	2045	{
[62743]	2046	RT_NOREF1(pIoCtx);
[44252]	2047	LogFlowFunc(("pBackendData=%#p pIoCtx=%#p\n", pBackendData, pIoCtx));
[41315]	2048	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2049	int rc;
	2050
	2051	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2052	rc = VERR_VD_IMAGE_READ_ONLY;
	2053	else
	2054	rc = VERR_NOT_SUPPORTED;
	2055
	2056	LogFlowFunc(("returns %Rrc\n", rc));
	2057	return rc;
	2058	}
	2059
[63785]	2060	/** @copydoc VDIMAGEBACKEND::pfnGetVersion */
[57388]	2061	static DECLCALLBACK(unsigned) vhdxGetVersion(void *pBackendData)
[41315]	2062	{
	2063	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2064	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2065
	2066	AssertPtr(pImage);
	2067
	2068	if (pImage)
	2069	return pImage->uVersion;
	2070	else
	2071	return 0;
	2072	}
	2073
[63785]	2074	/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
[57388]	2075	static DECLCALLBACK(uint64_t) vhdxGetFileSize(void *pBackendData)
[41315]	2076	{
	2077	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2078	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2079	uint64_t cb = 0;
	2080
	2081	AssertPtr(pImage);
	2082
	2083	if (pImage)
	2084	{
	2085	uint64_t cbFile;
	2086	if (pImage->pStorage)
	2087	{
	2088	int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
	2089	if (RT_SUCCESS(rc))
	2090	cb = cbFile;
	2091	}
	2092	}
	2093
	2094	LogFlowFunc(("returns %lld\n", cb));
	2095	return cb;
	2096	}
	2097
[63785]	2098	/** @copydoc VDIMAGEBACKEND::pfnGetPCHSGeometry */
[57388]	2099	static DECLCALLBACK(int) vhdxGetPCHSGeometry(void *pBackendData,
	2100	PVDGEOMETRY pPCHSGeometry)
[41315]	2101	{
	2102	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
	2103	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2104	int rc;
	2105
	2106	AssertPtr(pImage);
	2107
	2108	if (pImage)
	2109	{
	2110	if (pImage->PCHSGeometry.cCylinders)
	2111	{
	2112	*pPCHSGeometry = pImage->PCHSGeometry;
	2113	rc = VINF_SUCCESS;
	2114	}
	2115	else
	2116	rc = VERR_VD_GEOMETRY_NOT_SET;
	2117	}
	2118	else
	2119	rc = VERR_VD_NOT_OPENED;
	2120
	2121	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
	2122	return rc;
	2123	}
	2124
[63785]	2125	/** @copydoc VDIMAGEBACKEND::pfnSetPCHSGeometry */
[57388]	2126	static DECLCALLBACK(int) vhdxSetPCHSGeometry(void *pBackendData,
	2127	PCVDGEOMETRY pPCHSGeometry)
[41315]	2128	{
	2129	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
	2130	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2131	int rc = VINF_SUCCESS;
	2132
	2133	AssertPtr(pImage);
	2134
	2135	if (pImage)
	2136	{
	2137	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2138	rc = VERR_VD_IMAGE_READ_ONLY;
	2139	else
	2140	pImage->PCHSGeometry = *pPCHSGeometry;
	2141	}
	2142	else
	2143	rc = VERR_VD_NOT_OPENED;
	2144
	2145	LogFlowFunc(("returns %Rrc\n", rc));
	2146	return rc;
	2147	}
	2148
[63785]	2149	/** @copydoc VDIMAGEBACKEND::pfnGetLCHSGeometry */
[57388]	2150	static DECLCALLBACK(int) vhdxGetLCHSGeometry(void *pBackendData,
	2151	PVDGEOMETRY pLCHSGeometry)
[41315]	2152	{
	2153	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
	2154	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2155	int rc = VINF_SUCCESS;
	2156
	2157	AssertPtr(pImage);
	2158
	2159	if (pImage)
	2160	{
	2161	if (pImage->LCHSGeometry.cCylinders)
	2162	*pLCHSGeometry = pImage->LCHSGeometry;
	2163	else
	2164	rc = VERR_VD_GEOMETRY_NOT_SET;
	2165	}
	2166	else
	2167	rc = VERR_VD_NOT_OPENED;
	2168
	2169	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
	2170	return rc;
	2171	}
	2172
[63785]	2173	/** @copydoc VDIMAGEBACKEND::pfnSetLCHSGeometry */
[57388]	2174	static DECLCALLBACK(int) vhdxSetLCHSGeometry(void *pBackendData,
	2175	PCVDGEOMETRY pLCHSGeometry)
[41315]	2176	{
	2177	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
	2178	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2179	int rc = VINF_SUCCESS;
	2180
	2181	AssertPtr(pImage);
	2182
	2183	if (pImage)
	2184	{
	2185	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
	2186	rc = VERR_VD_IMAGE_READ_ONLY;
	2187	else
	2188	pImage->LCHSGeometry = *pLCHSGeometry;
	2189	}
	2190	else
	2191	rc = VERR_VD_NOT_OPENED;
	2192
	2193	LogFlowFunc(("returns %Rrc\n", rc));
	2194	return rc;
	2195	}
	2196
[66486]	2197	/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
	2198	static DECLCALLBACK(int) vhdxQueryRegions(void pBackendData, PCVDREGIONLIST ppRegionList)
	2199	{
	2200	LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
	2201	PVHDXIMAGE pThis = (PVHDXIMAGE)pBackendData;
	2202
	2203	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	2204
	2205	*ppRegionList = &pThis->RegionList;
	2206	LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
	2207	return VINF_SUCCESS;
	2208	}
	2209
	2210	/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
	2211	static DECLCALLBACK(void) vhdxRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
	2212	{
	2213	RT_NOREF1(pRegionList);
	2214	LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
	2215	PVHDXIMAGE pThis = (PVHDXIMAGE)pBackendData;
	2216	AssertPtr(pThis); RT_NOREF(pThis);
	2217
	2218	/* Nothing to do here. */
	2219	}
	2220
[63785]	2221	/** @copydoc VDIMAGEBACKEND::pfnGetImageFlags */
[57388]	2222	static DECLCALLBACK(unsigned) vhdxGetImageFlags(void *pBackendData)
[41315]	2223	{
	2224	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2225	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2226	unsigned uImageFlags;
	2227
	2228	AssertPtr(pImage);
	2229
	2230	if (pImage)
	2231	uImageFlags = pImage->uImageFlags;
	2232	else
	2233	uImageFlags = 0;
	2234
	2235	LogFlowFunc(("returns %#x\n", uImageFlags));
	2236	return uImageFlags;
	2237	}
	2238
[63785]	2239	/** @copydoc VDIMAGEBACKEND::pfnGetOpenFlags */
[57388]	2240	static DECLCALLBACK(unsigned) vhdxGetOpenFlags(void *pBackendData)
[41315]	2241	{
	2242	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	2243	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2244	unsigned uOpenFlags;
	2245
	2246	AssertPtr(pImage);
	2247
	2248	if (pImage)
	2249	uOpenFlags = pImage->uOpenFlags;
	2250	else
	2251	uOpenFlags = 0;
	2252
	2253	LogFlowFunc(("returns %#x\n", uOpenFlags));
	2254	return uOpenFlags;
	2255	}
	2256
[63785]	2257	/** @copydoc VDIMAGEBACKEND::pfnSetOpenFlags */
[57388]	2258	static DECLCALLBACK(int) vhdxSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
[41315]	2259	{
	2260	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
	2261	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2262	int rc = VINF_SUCCESS;
	2263
	2264	/* Image must be opened and the new flags must be valid. */
[44232]	2265	if (!pImage \|\| (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
[41315]	2266	rc = VERR_INVALID_PARAMETER;
	2267	else
	2268	{
	2269	/* Implement this operation via reopening the image. */
	2270	rc = vhdxFreeImage(pImage, false);
	2271	if (RT_SUCCESS(rc))
	2272	rc = vhdxOpenImage(pImage, uOpenFlags);
	2273	}
	2274
	2275	LogFlowFunc(("returns %Rrc\n", rc));
	2276	return rc;
	2277	}
	2278
[63785]	2279	/** @copydoc VDIMAGEBACKEND::pfnGetComment */
[66494]	2280	VD_BACKEND_CALLBACK_GET_COMMENT_DEF_NOT_SUPPORTED(vhdxGetComment);
[41315]	2281
[63785]	2282	/** @copydoc VDIMAGEBACKEND::pfnSetComment */
[66494]	2283	VD_BACKEND_CALLBACK_SET_COMMENT_DEF_NOT_SUPPORTED(vhdxSetComment, PVHDXIMAGE);
[41315]	2284
[63785]	2285	/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
[66494]	2286	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(vhdxGetUuid);
[41315]	2287
[63785]	2288	/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
[66494]	2289	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(vhdxSetUuid, PVHDXIMAGE);
[41315]	2290
[63785]	2291	/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
[66494]	2292	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(vhdxGetModificationUuid);
[41315]	2293
[63785]	2294	/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
[66494]	2295	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(vhdxSetModificationUuid, PVHDXIMAGE);
[41315]	2296
[63785]	2297	/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
[66494]	2298	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(vhdxGetParentUuid);
[41315]	2299
[63785]	2300	/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
[66494]	2301	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(vhdxSetParentUuid, PVHDXIMAGE);
[41315]	2302
[63785]	2303	/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
[66494]	2304	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(vhdxGetParentModificationUuid);
[41315]	2305
[63785]	2306	/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
[66494]	2307	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(vhdxSetParentModificationUuid, PVHDXIMAGE);
[41315]	2308
[63785]	2309	/** @copydoc VDIMAGEBACKEND::pfnDump */
[57388]	2310	static DECLCALLBACK(void) vhdxDump(void *pBackendData)
[41315]	2311	{
	2312	PVHDXIMAGE pImage = (PVHDXIMAGE)pBackendData;
	2313
	2314	AssertPtr(pImage);
	2315	if (pImage)
	2316	{
[48851]	2317	vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%u\n",
[41315]	2318	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
	2319	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
[41447]	2320	pImage->cbLogicalSector);
[41315]	2321	}
	2322	}
	2323
	2324
[63781]	2325	const VDIMAGEBACKEND g_VhdxBackend =
[41315]	2326	{
[63905]	2327	/* u32Version */
	2328	VD_IMGBACKEND_VERSION,
[41315]	2329	/* pszBackendName */
	2330	"VHDX",
	2331	/* uBackendCaps */
	2332	VD_CAP_FILE \| VD_CAP_VFS,
	2333	/* paFileExtensions */
	2334	s_aVhdxFileExtensions,
	2335	/* paConfigInfo */
	2336	NULL,
[63802]	2337	/* pfnProbe */
	2338	vhdxProbe,
[41315]	2339	/* pfnOpen */
	2340	vhdxOpen,
	2341	/* pfnCreate */
[54430]	2342	vhdxCreate,
[41315]	2343	/* pfnRename */
	2344	vhdxRename,
	2345	/* pfnClose */
	2346	vhdxClose,
	2347	/* pfnRead */
	2348	vhdxRead,
	2349	/* pfnWrite */
	2350	vhdxWrite,
	2351	/* pfnFlush */
	2352	vhdxFlush,
[44252]	2353	/* pfnDiscard */
	2354	NULL,
[41315]	2355	/* pfnGetVersion */
	2356	vhdxGetVersion,
	2357	/* pfnGetFileSize */
	2358	vhdxGetFileSize,
	2359	/* pfnGetPCHSGeometry */
	2360	vhdxGetPCHSGeometry,
	2361	/* pfnSetPCHSGeometry */
	2362	vhdxSetPCHSGeometry,
	2363	/* pfnGetLCHSGeometry */
	2364	vhdxGetLCHSGeometry,
	2365	/* pfnSetLCHSGeometry */
	2366	vhdxSetLCHSGeometry,
[66110]	2367	/* pfnQueryRegions */
[66486]	2368	vhdxQueryRegions,
[66110]	2369	/* pfnRegionListRelease */
[66486]	2370	vhdxRegionListRelease,
[41315]	2371	/* pfnGetImageFlags */
	2372	vhdxGetImageFlags,
	2373	/* pfnGetOpenFlags */
	2374	vhdxGetOpenFlags,
	2375	/* pfnSetOpenFlags */
	2376	vhdxSetOpenFlags,
	2377	/* pfnGetComment */
	2378	vhdxGetComment,
	2379	/* pfnSetComment */
	2380	vhdxSetComment,
	2381	/* pfnGetUuid */
	2382	vhdxGetUuid,
	2383	/* pfnSetUuid */
	2384	vhdxSetUuid,
	2385	/* pfnGetModificationUuid */
	2386	vhdxGetModificationUuid,
	2387	/* pfnSetModificationUuid */
	2388	vhdxSetModificationUuid,
	2389	/* pfnGetParentUuid */
	2390	vhdxGetParentUuid,
	2391	/* pfnSetParentUuid */
	2392	vhdxSetParentUuid,
	2393	/* pfnGetParentModificationUuid */
	2394	vhdxGetParentModificationUuid,
	2395	/* pfnSetParentModificationUuid */
	2396	vhdxSetParentModificationUuid,
	2397	/* pfnDump */
	2398	vhdxDump,
[58132]	2399	/* pfnGetTimestamp */
[41315]	2400	NULL,
[58132]	2401	/* pfnGetParentTimestamp */
[41315]	2402	NULL,
[58132]	2403	/* pfnSetParentTimestamp */
[41315]	2404	NULL,
	2405	/* pfnGetParentFilename */
	2406	NULL,
	2407	/* pfnSetParentFilename */
	2408	NULL,
	2409	/* pfnComposeLocation */
	2410	genericFileComposeLocation,
	2411	/* pfnComposeName */
	2412	genericFileComposeName,
	2413	/* pfnCompact */
	2414	NULL,
	2415	/* pfnResize */
	2416	NULL,
	2417	/* pfnRepair */
[50988]	2418	NULL,
	2419	/* pfnTraverseMetadata */
[63905]	2420	NULL,
	2421	/* u32VersionEnd */
	2422	VD_IMGBACKEND_VERSION
[41315]	2423	};

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Storage/VHDX.cpp@ 98103

Download in other formats: