VHDX.cpp@ 47627

Last change on this file since 47627 was 46613, checked in by vboxsync, 12 years ago
Storage: Propagate errors when closing a file but free everything nevertheless (see @bugref{6791})
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.8 KB

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

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

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

Download in other formats: