VHD.cpp@ 49439

Last change on this file since 49439 was 48851, checked in by vboxsync, 11 years ago
Storage: Addressing 64-bit windows warnings.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 115.7 KB

Line
1	/* $Id: VHD.cpp 48851 2013-10-03 20:02:34Z vboxsync $ */
2	/** @file
3	* VHD Disk image, Core Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-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_VD_VHD
22	#include <VBox/vd-plugin.h>
23	#include <VBox/err.h>
24
25	#include <VBox/log.h>
26	#include <VBox/version.h>
27	#include <iprt/asm.h>
28	#include <iprt/assert.h>
29	#include <iprt/mem.h>
30	#include <iprt/uuid.h>
31	#include <iprt/path.h>
32	#include <iprt/string.h>
33
34	#define VHD_RELATIVE_MAX_PATH 512
35	#define VHD_ABSOLUTE_MAX_PATH 512
36
37	#define VHD_SECTOR_SIZE 512
38	#define VHD_BLOCK_SIZE (2 * _1M)
39
40	/* This is common to all VHD disk types and is located at the end of the image */
41	#pragma pack(1)
42	typedef struct VHDFooter
43	{
44	char Cookie[8];
45	uint32_t Features;
46	uint32_t Version;
47	uint64_t DataOffset;
48	uint32_t TimeStamp;
49	uint8_t CreatorApp[4];
50	uint32_t CreatorVer;
51	uint32_t CreatorOS;
52	uint64_t OrigSize;
53	uint64_t CurSize;
54	uint16_t DiskGeometryCylinder;
55	uint8_t DiskGeometryHeads;
56	uint8_t DiskGeometrySectors;
57	uint32_t DiskType;
58	uint32_t Checksum;
59	char UniqueID[16];
60	uint8_t SavedState;
61	uint8_t Reserved[427];
62	} VHDFooter;
63	#pragma pack()
64
65	/* this really is spelled with only one n */
66	#define VHD_FOOTER_COOKIE "conectix"
67	#define VHD_FOOTER_COOKIE_SIZE 8
68
69	#define VHD_FOOTER_FEATURES_NOT_ENABLED 0
70	#define VHD_FOOTER_FEATURES_TEMPORARY 1
71	#define VHD_FOOTER_FEATURES_RESERVED 2
72
73	#define VHD_FOOTER_FILE_FORMAT_VERSION 0x00010000
74	#define VHD_FOOTER_DATA_OFFSET_FIXED UINT64_C(0xffffffffffffffff)
75	#define VHD_FOOTER_DISK_TYPE_FIXED 2
76	#define VHD_FOOTER_DISK_TYPE_DYNAMIC 3
77	#define VHD_FOOTER_DISK_TYPE_DIFFERENCING 4
78
79	#define VHD_MAX_LOCATOR_ENTRIES 8
80	#define VHD_PLATFORM_CODE_NONE 0
81	#define VHD_PLATFORM_CODE_WI2R 0x57693272
82	#define VHD_PLATFORM_CODE_WI2K 0x5769326B
83	#define VHD_PLATFORM_CODE_W2RU 0x57327275
84	#define VHD_PLATFORM_CODE_W2KU 0x57326B75
85	#define VHD_PLATFORM_CODE_MAC 0x4D163220
86	#define VHD_PLATFORM_CODE_MACX 0x4D163258
87
88	/* Header for expanding disk images. */
89	#pragma pack(1)
90	typedef struct VHDParentLocatorEntry
91	{
92	uint32_t u32Code;
93	uint32_t u32DataSpace;
94	uint32_t u32DataLength;
95	uint32_t u32Reserved;
96	uint64_t u64DataOffset;
97	} VHDPLE, *PVHDPLE;
98
99	typedef struct VHDDynamicDiskHeader
100	{
101	char Cookie[8];
102	uint64_t DataOffset;
103	uint64_t TableOffset;
104	uint32_t HeaderVersion;
105	uint32_t MaxTableEntries;
106	uint32_t BlockSize;
107	uint32_t Checksum;
108	uint8_t ParentUuid[16];
109	uint32_t ParentTimeStamp;
110	uint32_t Reserved0;
111	uint16_t ParentUnicodeName[256];
112	VHDPLE ParentLocatorEntry[VHD_MAX_LOCATOR_ENTRIES];
113	uint8_t Reserved1[256];
114	} VHDDynamicDiskHeader;
115	#pragma pack()
116
117	#define VHD_DYNAMIC_DISK_HEADER_COOKIE "cxsparse"
118	#define VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE 8
119	#define VHD_DYNAMIC_DISK_HEADER_VERSION 0x00010000
120
121	/**
122	* Complete VHD image data structure.
123	*/
124	typedef struct VHDIMAGE
125	{
126	/** Image file name. */
127	const char *pszFilename;
128	/** Opaque storage handle. */
129	PVDIOSTORAGE pStorage;
130
131	/** Pointer to the per-disk VD interface list. */
132	PVDINTERFACE pVDIfsDisk;
133	/** Pointer to the per-image VD interface list. */
134	PVDINTERFACE pVDIfsImage;
135	/** Error interface. */
136	PVDINTERFACEERROR pIfError;
137	/** I/O interface. */
138	PVDINTERFACEIOINT pIfIo;
139
140	/** Open flags passed by VBoxHDD layer. */
141	unsigned uOpenFlags;
142	/** Image flags defined during creation or determined during open. */
143	unsigned uImageFlags;
144	/** Total size of the image. */
145	uint64_t cbSize;
146
147	/** Physical geometry of this image. */
148	VDGEOMETRY PCHSGeometry;
149	/** Logical geometry of this image. */
150	VDGEOMETRY LCHSGeometry;
151
152	/** Image UUID. */
153	RTUUID ImageUuid;
154	/** Parent image UUID. */
155	RTUUID ParentUuid;
156
157	/** Parent's time stamp at the time of image creation. */
158	uint32_t u32ParentTimeStamp;
159	/** Relative path to the parent image. */
160	char *pszParentFilename;
161
162	/** The Block Allocation Table. */
163	uint32_t *pBlockAllocationTable;
164	/** Number of entries in the table. */
165	uint32_t cBlockAllocationTableEntries;
166
167	/** Size of one data block. */
168	uint32_t cbDataBlock;
169	/** Sectors per data block. */
170	uint32_t cSectorsPerDataBlock;
171	/** Length of the sector bitmap in bytes. */
172	uint32_t cbDataBlockBitmap;
173	/** A copy of the disk footer. */
174	VHDFooter vhdFooterCopy;
175	/** Current end offset of the file (without the disk footer). */
176	uint64_t uCurrentEndOfFile;
177	/** Size of the data block bitmap in sectors. */
178	uint32_t cDataBlockBitmapSectors;
179	/** Start of the block allocation table. */
180	uint64_t uBlockAllocationTableOffset;
181	/** Buffer to hold block's bitmap for bit search operations. */
182	uint8_t *pu8Bitmap;
183	/** Offset to the next data structure (dynamic disk header). */
184	uint64_t u64DataOffset;
185	/** Flag to force dynamic disk header update. */
186	bool fDynHdrNeedsUpdate;
187	} VHDIMAGE, *PVHDIMAGE;
188
189	/**
190	* Structure tracking the expansion process of the image
191	* for async access.
192	*/
193	typedef struct VHDIMAGEEXPAND
194	{
195	/** Flag indicating the status of each step. */
196	volatile uint32_t fFlags;
197	/** The index in the block allocation table which is written. */
198	uint32_t idxBatAllocated;
199	/** Big endian representation of the block index
200	* which is written in the BAT. */
201	uint32_t idxBlockBe;
202	/** Old end of the file - used for rollback in case of an error. */
203	uint64_t cbEofOld;
204	/** Sector bitmap written to the new block - variable in size. */
205	uint8_t au8Bitmap[1];
206	} VHDIMAGEEXPAND, *PVHDIMAGEEXPAND;
207
208	/**
209	* Flag defines
210	*/
211	#define VHDIMAGEEXPAND_STEP_IN_PROGRESS (0x0)
212	#define VHDIMAGEEXPAND_STEP_FAILED (0x2)
213	#define VHDIMAGEEXPAND_STEP_SUCCESS (0x3)
214	/** All steps completed successfully. */
215	#define VHDIMAGEEXPAND_ALL_SUCCESS (0xff)
216	/** All steps completed (no success indicator) */
217	#define VHDIMAGEEXPAND_ALL_COMPLETE (0xaa)
218
219	/** Every status field has 2 bits so we can encode 4 steps in one byte. */
220	#define VHDIMAGEEXPAND_STATUS_MASK 0x03
221	#define VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT 0x00
222	#define VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT 0x02
223	#define VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT 0x04
224	#define VHDIMAGEEXPAND_BAT_STATUS_SHIFT 0x06
225
226	/**
227	* Helper macros to get and set the status field.
228	*/
229	#define VHDIMAGEEXPAND_STATUS_GET(fFlags, cShift) \
230	(((fFlags) >> (cShift)) & VHDIMAGEEXPAND_STATUS_MASK)
231	#define VHDIMAGEEXPAND_STATUS_SET(fFlags, cShift, uVal) \
232	ASMAtomicOrU32(&(fFlags), ((uVal) & VHDIMAGEEXPAND_STATUS_MASK) << (cShift))
233
234	/*******************************************************************************
235	* Static Variables *
236	*******************************************************************************/
237
238	/** NULL-terminated array of supported file extensions. */
239	static const VDFILEEXTENSION s_aVhdFileExtensions[] =
240	{
241	{"vhd", VDTYPE_HDD},
242	{NULL, VDTYPE_INVALID}
243	};
244
245	/*******************************************************************************
246	* Internal Functions *
247	*******************************************************************************/
248
249
250	/**
251	* Internal: Compute and update header checksum.
252	*/
253	static uint32_t vhdChecksum(void *pHeader, uint32_t cbSize)
254	{
255	uint32_t checksum = 0;
256	for (uint32_t i = 0; i < cbSize; i++)
257	checksum += ((unsigned char *)pHeader)[i];
258	return ~checksum;
259	}
260
261	/**
262	* Internal: Convert filename to UTF16 with appropriate endianness.
263	*/
264	static int vhdFilenameToUtf16(const char pszFilename, uint16_t pu16Buf,
265	uint32_t cbBufSize, uint32_t *pcbActualSize,
266	bool fBigEndian)
267	{
268	int rc;
269	PRTUTF16 tmp16 = NULL;
270	size_t cTmp16Len;
271
272	rc = RTStrToUtf16(pszFilename, &tmp16);
273	if (RT_FAILURE(rc))
274	goto out;
275	cTmp16Len = RTUtf16Len(tmp16);
276	if (cTmp16Len * sizeof(*tmp16) > cbBufSize)
277	{
278	rc = VERR_FILENAME_TOO_LONG;
279	goto out;
280	}
281
282	if (fBigEndian)
283	for (unsigned i = 0; i < cTmp16Len; i++)
284	pu16Buf[i] = RT_H2BE_U16(tmp16[i]);
285	else
286	memcpy(pu16Buf, tmp16, cTmp16Len * sizeof(*tmp16));
287	if (pcbActualSize)
288	pcbActualSize = (uint32_t)(cTmp16Len sizeof(*tmp16));
289
290	out:
291	if (tmp16)
292	RTUtf16Free(tmp16);
293	return rc;
294	}
295
296	/**
297	* Internal: Update one locator entry.
298	*/
299	static int vhdLocatorUpdate(PVHDIMAGE pImage, PVHDPLE pLocator, const char *pszFilename)
300	{
301	int rc = VINF_SUCCESS;
302	uint32_t cb, cbMaxLen = RT_BE2H_U32(pLocator->u32DataSpace);
303	void *pvBuf = RTMemTmpAllocZ(cbMaxLen);
304	char *pszTmp;
305
306	if (!pvBuf)
307	return VERR_NO_MEMORY;
308
309	switch (RT_BE2H_U32(pLocator->u32Code))
310	{
311	case VHD_PLATFORM_CODE_WI2R:
312	{
313	if (RTPathStartsWithRoot(pszFilename))
314	{
315	/* Convert to relative path. */
316	char szPath[RTPATH_MAX];
317	rc = RTPathCalcRelative(szPath, sizeof(szPath), pImage->pszFilename,
318	pszFilename);
319	if (RT_SUCCESS(rc))
320	{
321	/* Update plain relative name. */
322	cb = (uint32_t)strlen(szPath);
323	if (cb > cbMaxLen)
324	{
325	rc = VERR_FILENAME_TOO_LONG;
326	break;
327	}
328	memcpy(pvBuf, szPath, cb);
329	}
330	}
331	else
332	{
333	/* Update plain relative name. */
334	cb = (uint32_t)strlen(pszFilename);
335	if (cb > cbMaxLen)
336	{
337	rc = VERR_FILENAME_TOO_LONG;
338	break;
339	}
340	memcpy(pvBuf, pszFilename, cb);
341	}
342	pLocator->u32DataLength = RT_H2BE_U32(cb);
343	break;
344	}
345	case VHD_PLATFORM_CODE_WI2K:
346	/* Update plain absolute name. */
347	rc = RTPathAbs(pszFilename, (char *)pvBuf, cbMaxLen);
348	if (RT_SUCCESS(rc))
349	pLocator->u32DataLength = RT_H2BE_U32((uint32_t)strlen((const char *)pvBuf));
350	break;
351	case VHD_PLATFORM_CODE_W2RU:
352	if (RTPathStartsWithRoot(pszFilename))
353	{
354	/* Convert to relative path. */
355	char szPath[RTPATH_MAX];
356	rc = RTPathCalcRelative(szPath, sizeof(szPath), pImage->pszFilename,
357	pszFilename);
358	if (RT_SUCCESS(rc))
359	rc = vhdFilenameToUtf16(szPath, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
360	}
361	else
362	{
363	/* Update unicode relative name. */
364	rc = vhdFilenameToUtf16(pszFilename, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
365	}
366
367	if (RT_SUCCESS(rc))
368	pLocator->u32DataLength = RT_H2BE_U32(cb);
369	break;
370	case VHD_PLATFORM_CODE_W2KU:
371	/* Update unicode absolute name. */
372	pszTmp = (char*)RTMemTmpAllocZ(cbMaxLen);
373	if (!pszTmp)
374	{
375	rc = VERR_NO_MEMORY;
376	break;
377	}
378	rc = RTPathAbs(pszFilename, pszTmp, cbMaxLen);
379	if (RT_FAILURE(rc))
380	{
381	RTMemTmpFree(pszTmp);
382	break;
383	}
384	rc = vhdFilenameToUtf16(pszTmp, (uint16_t *)pvBuf, cbMaxLen, &cb, false);
385	RTMemTmpFree(pszTmp);
386	if (RT_SUCCESS(rc))
387	pLocator->u32DataLength = RT_H2BE_U32(cb);
388	break;
389	default:
390	rc = VERR_NOT_IMPLEMENTED;
391	break;
392	}
393
394	if (RT_SUCCESS(rc))
395	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
396	RT_BE2H_U64(pLocator->u64DataOffset),
397	pvBuf, cb);
398
399	if (pvBuf)
400	RTMemTmpFree(pvBuf);
401	return rc;
402	}
403
404	/**
405	* Internal: Update dynamic disk header from VHDIMAGE.
406	*/
407	static int vhdDynamicHeaderUpdate(PVHDIMAGE pImage)
408	{
409	VHDDynamicDiskHeader ddh;
410	int rc, i;
411
412	if (!pImage)
413	return VERR_VD_NOT_OPENED;
414
415	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
416	pImage->u64DataOffset, &ddh, sizeof(ddh));
417	if (RT_FAILURE(rc))
418	return rc;
419	if (memcmp(ddh.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE) != 0)
420	return VERR_VD_VHD_INVALID_HEADER;
421
422	uint32_t u32Checksum = RT_BE2H_U32(ddh.Checksum);
423	ddh.Checksum = 0;
424	if (u32Checksum != vhdChecksum(&ddh, sizeof(ddh)))
425	return VERR_VD_VHD_INVALID_HEADER;
426
427	/* Update parent's timestamp. */
428	ddh.ParentTimeStamp = RT_H2BE_U32(pImage->u32ParentTimeStamp);
429	/* Update parent's filename. */
430	if (pImage->pszParentFilename)
431	{
432	rc = vhdFilenameToUtf16(RTPathFilename(pImage->pszParentFilename),
433	ddh.ParentUnicodeName, sizeof(ddh.ParentUnicodeName) - 1, NULL, true);
434	if (RT_FAILURE(rc))
435	return rc;
436	}
437
438	/* Update parent's locators. */
439	for (i = 0; i < VHD_MAX_LOCATOR_ENTRIES; i++)
440	{
441	/* Skip empty locators */
442	if (ddh.ParentLocatorEntry[i].u32Code != RT_H2BE_U32(VHD_PLATFORM_CODE_NONE))
443	{
444	if (pImage->pszParentFilename)
445	{
446	rc = vhdLocatorUpdate(pImage, &ddh.ParentLocatorEntry[i], pImage->pszParentFilename);
447	if (RT_FAILURE(rc))
448	return rc;
449	}
450	else
451	{
452	/* The parent was deleted. */
453	ddh.ParentLocatorEntry[i].u32Code = RT_H2BE_U32(VHD_PLATFORM_CODE_NONE);
454	}
455	}
456	}
457	/* Update parent's UUID */
458	memcpy(ddh.ParentUuid, pImage->ParentUuid.au8, sizeof(ddh.ParentUuid));
459
460	/* Update data offset and number of table entries. */
461	ddh.MaxTableEntries = RT_H2BE_U32(pImage->cBlockAllocationTableEntries);
462
463	ddh.Checksum = 0;
464	ddh.Checksum = RT_H2BE_U32(vhdChecksum(&ddh, sizeof(ddh)));
465	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
466	pImage->u64DataOffset, &ddh, sizeof(ddh));
467	return rc;
468	}
469
470	/**
471	* Internal: Update the VHD footer.
472	*/
473	static int vhdUpdateFooter(PVHDIMAGE pImage)
474	{
475	int rc = VINF_SUCCESS;
476
477	/* Update fields which can change. */
478	pImage->vhdFooterCopy.CurSize = RT_H2BE_U64(pImage->cbSize);
479	pImage->vhdFooterCopy.DiskGeometryCylinder = RT_H2BE_U16(pImage->PCHSGeometry.cCylinders);
480	pImage->vhdFooterCopy.DiskGeometryHeads = pImage->PCHSGeometry.cHeads;
481	pImage->vhdFooterCopy.DiskGeometrySectors = pImage->PCHSGeometry.cSectors;
482
483	pImage->vhdFooterCopy.Checksum = 0;
484	pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
485
486	if (pImage->pBlockAllocationTable)
487	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0,
488	&pImage->vhdFooterCopy, sizeof(VHDFooter));
489
490	if (RT_SUCCESS(rc))
491	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
492	pImage->uCurrentEndOfFile, &pImage->vhdFooterCopy,
493	sizeof(VHDFooter));
494
495	return rc;
496	}
497
498	/**
499	* Internal. Flush image data to disk.
500	*/
501	static int vhdFlushImage(PVHDIMAGE pImage)
502	{
503	int rc = VINF_SUCCESS;
504
505	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
506	return VINF_SUCCESS;
507
508	if (pImage->pBlockAllocationTable)
509	{
510	/*
511	* This is an expanding image. Write the BAT and copy of the disk footer.
512	*/
513	size_t cbBlockAllocationTableToWrite = pImage->cBlockAllocationTableEntries * sizeof(uint32_t);
514	uint32_t pBlockAllocationTableToWrite = (uint32_t )RTMemAllocZ(cbBlockAllocationTableToWrite);
515
516	if (!pBlockAllocationTableToWrite)
517	return VERR_NO_MEMORY;
518
519	/*
520	* The BAT entries have to be stored in big endian format.
521	*/
522	for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
523	pBlockAllocationTableToWrite[i] = RT_H2BE_U32(pImage->pBlockAllocationTable[i]);
524
525	/*
526	* Write the block allocation table after the copy of the disk footer and the dynamic disk header.
527	*/
528	vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uBlockAllocationTableOffset,
529	pBlockAllocationTableToWrite, cbBlockAllocationTableToWrite);
530	if (pImage->fDynHdrNeedsUpdate)
531	rc = vhdDynamicHeaderUpdate(pImage);
532	RTMemFree(pBlockAllocationTableToWrite);
533	}
534
535	if (RT_SUCCESS(rc))
536	rc = vhdUpdateFooter(pImage);
537
538	if (RT_SUCCESS(rc))
539	rc = vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
540
541	return rc;
542	}
543
544	/**
545	* Internal. Free all allocated space for representing an image except pImage,
546	* and optionally delete the image from disk.
547	*/
548	static int vhdFreeImage(PVHDIMAGE pImage, bool fDelete)
549	{
550	int rc = VINF_SUCCESS;
551
552	/* Freeing a never allocated image (e.g. because the open failed) is
553	* not signalled as an error. After all nothing bad happens. */
554	if (pImage)
555	{
556	if (pImage->pStorage)
557	{
558	/* No point updating the file that is deleted anyway. */
559	if (!fDelete)
560	vhdFlushImage(pImage);
561
562	rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
563	pImage->pStorage = NULL;
564	}
565
566	if (pImage->pszParentFilename)
567	{
568	RTStrFree(pImage->pszParentFilename);
569	pImage->pszParentFilename = NULL;
570	}
571	if (pImage->pBlockAllocationTable)
572	{
573	RTMemFree(pImage->pBlockAllocationTable);
574	pImage->pBlockAllocationTable = NULL;
575	}
576	if (pImage->pu8Bitmap)
577	{
578	RTMemFree(pImage->pu8Bitmap);
579	pImage->pu8Bitmap = NULL;
580	}
581
582	if (fDelete && pImage->pszFilename)
583	vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
584	}
585
586	LogFlowFunc(("returns %Rrc\n", rc));
587	return rc;
588	}
589
590	/* 946684800 is the number of seconds between 1/1/1970 and 1/1/2000 */
591	#define VHD_TO_UNIX_EPOCH_SECONDS UINT64_C(946684800)
592
593	static uint32_t vhdRtTime2VhdTime(PCRTTIMESPEC pRtTimeStamp)
594	{
595	uint64_t u64Seconds = RTTimeSpecGetSeconds(pRtTimeStamp);
596	return (uint32_t)(u64Seconds - VHD_TO_UNIX_EPOCH_SECONDS);
597	}
598
599	static void vhdTime2RtTime(PRTTIMESPEC pRtTimeStamp, uint32_t u32VhdTimeStamp)
600	{
601	RTTimeSpecSetSeconds(pRtTimeStamp, VHD_TO_UNIX_EPOCH_SECONDS + u32VhdTimeStamp);
602	}
603
604	/**
605	* Internal: Allocates the block bitmap rounding up to the next 32bit or 64bit boundary.
606	* Can be freed with RTMemFree. The memory is zeroed.
607	*/
608	DECLINLINE(uint8_t *)vhdBlockBitmapAllocate(PVHDIMAGE pImage)
609	{
610	#ifdef RT_ARCH_AMD64
611	return (uint8_t *)RTMemAllocZ(pImage->cbDataBlockBitmap + 8);
612	#else
613	return (uint8_t *)RTMemAllocZ(pImage->cbDataBlockBitmap + 4);
614	#endif
615	}
616
617	/**
618	* Internal: called when the async expansion process completed (failure or success).
619	* Will do the necessary rollback if an error occurred.
620	*/
621	static int vhdAsyncExpansionComplete(PVHDIMAGE pImage, PVDIOCTX pIoCtx, PVHDIMAGEEXPAND pExpand)
622	{
623	int rc = VINF_SUCCESS;
624	uint32_t fFlags = ASMAtomicReadU32(&pExpand->fFlags);
625	bool fIoInProgress = false;
626
627	/* Quick path, check if everything succeeded. */
628	if (fFlags == VHDIMAGEEXPAND_ALL_SUCCESS)
629	{
630	RTMemFree(pExpand);
631	}
632	else
633	{
634	uint32_t uStatus;
635
636	uStatus = VHDIMAGEEXPAND_STATUS_GET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT);
637	if ( uStatus == VHDIMAGEEXPAND_STEP_FAILED
638	\|\| uStatus == VHDIMAGEEXPAND_STEP_SUCCESS)
639	{
640	/* Undo and restore the old value. */
641	pImage->pBlockAllocationTable[pExpand->idxBatAllocated] = ~0U;
642
643	/* Restore the old value on the disk.
644	* No need for a completion callback because we can't
645	* do anything if this fails. */
646	if (uStatus == VHDIMAGEEXPAND_STEP_SUCCESS)
647	{
648	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
649	pImage->uBlockAllocationTableOffset
650	+ pExpand->idxBatAllocated * sizeof(uint32_t),
651	&pImage->pBlockAllocationTable[pExpand->idxBatAllocated],
652	sizeof(uint32_t), pIoCtx, NULL, NULL);
653	fIoInProgress \|= rc == VERR_VD_ASYNC_IO_IN_PROGRESS;
654	}
655	}
656
657	/* Restore old size (including the footer because another application might
658	* fill up the free space making it impossible to add the footer)
659	* and add the footer at the right place again. */
660	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
661	pExpand->cbEofOld + sizeof(VHDFooter));
662	AssertRC(rc);
663
664	pImage->uCurrentEndOfFile = pExpand->cbEofOld;
665	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
666	pImage->uCurrentEndOfFile,
667	&pImage->vhdFooterCopy, sizeof(VHDFooter),
668	pIoCtx, NULL, NULL);
669	fIoInProgress \|= rc == VERR_VD_ASYNC_IO_IN_PROGRESS;
670	}
671
672	return fIoInProgress ? VERR_VD_ASYNC_IO_IN_PROGRESS : rc;
673	}
674
675	static int vhdAsyncExpansionStepCompleted(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq, unsigned iStep)
676	{
677	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
678	PVHDIMAGEEXPAND pExpand = (PVHDIMAGEEXPAND)pvUser;
679
680	LogFlowFunc(("pBackendData=%#p pIoCtx=%#p pvUser=%#p rcReq=%Rrc iStep=%u\n",
681	pBackendData, pIoCtx, pvUser, rcReq, iStep));
682
683	if (RT_SUCCESS(rcReq))
684	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, iStep, VHDIMAGEEXPAND_STEP_SUCCESS);
685	else
686	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, iStep, VHDIMAGEEXPAND_STEP_FAILED);
687
688	if ((pExpand->fFlags & VHDIMAGEEXPAND_ALL_COMPLETE) == VHDIMAGEEXPAND_ALL_COMPLETE)
689	return vhdAsyncExpansionComplete(pImage, pIoCtx, pExpand);
690
691	return VERR_VD_ASYNC_IO_IN_PROGRESS;
692	}
693
694	static int vhdAsyncExpansionDataBlockBitmapComplete(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq)
695	{
696	return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT);
697	}
698
699	static int vhdAsyncExpansionDataComplete(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq)
700	{
701	return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT);
702	}
703
704	static int vhdAsyncExpansionBatUpdateComplete(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq)
705	{
706	return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_BAT_STATUS_SHIFT);
707	}
708
709	static int vhdAsyncExpansionFooterUpdateComplete(void pBackendData, PVDIOCTX pIoCtx, void pvUser, int rcReq)
710	{
711	return vhdAsyncExpansionStepCompleted(pBackendData, pIoCtx, pvUser, rcReq, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT);
712	}
713
714	static int vhdLoadDynamicDisk(PVHDIMAGE pImage, uint64_t uDynamicDiskHeaderOffset)
715	{
716	VHDDynamicDiskHeader vhdDynamicDiskHeader;
717	int rc = VINF_SUCCESS;
718	uint32_t *pBlockAllocationTable;
719	uint64_t uBlockAllocationTableOffset;
720	unsigned i = 0;
721
722	Log(("Open a dynamic disk.\n"));
723
724	/*
725	* Read the dynamic disk header.
726	*/
727	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, uDynamicDiskHeaderOffset,
728	&vhdDynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
729	if (memcmp(vhdDynamicDiskHeader.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, VHD_DYNAMIC_DISK_HEADER_COOKIE_SIZE))
730	return VERR_INVALID_PARAMETER;
731
732	pImage->cbDataBlock = RT_BE2H_U32(vhdDynamicDiskHeader.BlockSize);
733	LogFlowFunc(("BlockSize=%u\n", pImage->cbDataBlock));
734	pImage->cBlockAllocationTableEntries = RT_BE2H_U32(vhdDynamicDiskHeader.MaxTableEntries);
735	LogFlowFunc(("MaxTableEntries=%lu\n", pImage->cBlockAllocationTableEntries));
736	AssertMsg(!(pImage->cbDataBlock % VHD_SECTOR_SIZE), ("%s: Data block size is not a multiple of %!\n", __FUNCTION__, VHD_SECTOR_SIZE));
737
738	pImage->cSectorsPerDataBlock = pImage->cbDataBlock / VHD_SECTOR_SIZE;
739	LogFlowFunc(("SectorsPerDataBlock=%u\n", pImage->cSectorsPerDataBlock));
740
741	/*
742	* Every block starts with a bitmap indicating which sectors are valid and which are not.
743	* We store the size of it to be able to calculate the real offset.
744	*/
745	pImage->cbDataBlockBitmap = pImage->cSectorsPerDataBlock / 8;
746	pImage->cDataBlockBitmapSectors = pImage->cbDataBlockBitmap / VHD_SECTOR_SIZE;
747	/* Round up to full sector size */
748	if (pImage->cbDataBlockBitmap % VHD_SECTOR_SIZE > 0)
749	pImage->cDataBlockBitmapSectors++;
750	LogFlowFunc(("cbDataBlockBitmap=%u\n", pImage->cbDataBlockBitmap));
751	LogFlowFunc(("cDataBlockBitmapSectors=%u\n", pImage->cDataBlockBitmapSectors));
752
753	pImage->pu8Bitmap = vhdBlockBitmapAllocate(pImage);
754	if (!pImage->pu8Bitmap)
755	return VERR_NO_MEMORY;
756
757	pBlockAllocationTable = (uint32_t )RTMemAllocZ(pImage->cBlockAllocationTableEntries sizeof(uint32_t));
758	if (!pBlockAllocationTable)
759	return VERR_NO_MEMORY;
760
761	/*
762	* Read the table.
763	*/
764	uBlockAllocationTableOffset = RT_BE2H_U64(vhdDynamicDiskHeader.TableOffset);
765	LogFlowFunc(("uBlockAllocationTableOffset=%llu\n", uBlockAllocationTableOffset));
766	pImage->uBlockAllocationTableOffset = uBlockAllocationTableOffset;
767	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
768	uBlockAllocationTableOffset, pBlockAllocationTable,
769	pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
770
771	/*
772	* Because the offset entries inside the allocation table are stored big endian
773	* we need to convert them into host endian.
774	*/
775	pImage->pBlockAllocationTable = (uint32_t )RTMemAllocZ(pImage->cBlockAllocationTableEntries sizeof(uint32_t));
776	if (!pImage->pBlockAllocationTable)
777	{
778	RTMemFree(pBlockAllocationTable);
779	return VERR_NO_MEMORY;
780	}
781
782	for (i = 0; i < pImage->cBlockAllocationTableEntries; i++)
783	pImage->pBlockAllocationTable[i] = RT_BE2H_U32(pBlockAllocationTable[i]);
784
785	RTMemFree(pBlockAllocationTable);
786
787	if (pImage->uImageFlags & VD_IMAGE_FLAGS_DIFF)
788	memcpy(pImage->ParentUuid.au8, vhdDynamicDiskHeader.ParentUuid, sizeof(pImage->ParentUuid));
789
790	return rc;
791	}
792
793	static int vhdOpenImage(PVHDIMAGE pImage, unsigned uOpenFlags)
794	{
795	uint64_t FileSize;
796	VHDFooter vhdFooter;
797
798	pImage->uOpenFlags = uOpenFlags;
799
800	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
801	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
802	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
803
804	/*
805	* Open the image.
806	*/
807	int rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
808	VDOpenFlagsToFileOpenFlags(uOpenFlags,
809	false /* fCreate */),
810	&pImage->pStorage);
811	if (RT_FAILURE(rc))
812	{
813	/* Do NOT signal an appropriate error here, as the VD layer has the
814	* choice of retrying the open if it failed. */
815	return rc;
816	}
817
818	rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &FileSize);
819	pImage->uCurrentEndOfFile = FileSize - sizeof(VHDFooter);
820
821	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, pImage->uCurrentEndOfFile,
822	&vhdFooter, sizeof(VHDFooter));
823	if (RT_SUCCESS(rc))
824	{
825	if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
826	{
827	/*
828	* There is also a backup header at the beginning in case the image got corrupted.
829	* Such corrupted images are detected here to let the open handler repair it later.
830	*/
831	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage, 0,
832	&vhdFooter, sizeof(VHDFooter));
833	if (RT_SUCCESS(rc))
834	{
835	if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
836	rc = VERR_VD_VHD_INVALID_HEADER;
837	else
838	rc = VERR_VD_IMAGE_CORRUPTED;
839	}
840	}
841	}
842
843	if (RT_FAILURE(rc))
844	return rc;
845
846	switch (RT_BE2H_U32(vhdFooter.DiskType))
847	{
848	case VHD_FOOTER_DISK_TYPE_FIXED:
849	pImage->uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
850	break;
851	case VHD_FOOTER_DISK_TYPE_DYNAMIC:
852	pImage->uImageFlags &= ~VD_IMAGE_FLAGS_FIXED;
853	break;
854	case VHD_FOOTER_DISK_TYPE_DIFFERENCING:
855	pImage->uImageFlags \|= VD_IMAGE_FLAGS_DIFF;
856	pImage->uImageFlags &= ~VD_IMAGE_FLAGS_FIXED;
857	break;
858	default:
859	return VERR_NOT_IMPLEMENTED;
860	}
861
862	pImage->cbSize = RT_BE2H_U64(vhdFooter.CurSize);
863	pImage->LCHSGeometry.cCylinders = 0;
864	pImage->LCHSGeometry.cHeads = 0;
865	pImage->LCHSGeometry.cSectors = 0;
866	pImage->PCHSGeometry.cCylinders = RT_BE2H_U16(vhdFooter.DiskGeometryCylinder);
867	pImage->PCHSGeometry.cHeads = vhdFooter.DiskGeometryHeads;
868	pImage->PCHSGeometry.cSectors = vhdFooter.DiskGeometrySectors;
869
870	/*
871	* Copy of the disk footer.
872	* If we allocate new blocks in differencing disks on write access
873	* the footer is overwritten. We need to write it at the end of the file.
874	*/
875	memcpy(&pImage->vhdFooterCopy, &vhdFooter, sizeof(VHDFooter));
876
877	/*
878	* Is there a better way?
879	*/
880	memcpy(&pImage->ImageUuid, &vhdFooter.UniqueID, 16);
881
882	pImage->u64DataOffset = RT_BE2H_U64(vhdFooter.DataOffset);
883	LogFlowFunc(("DataOffset=%llu\n", pImage->u64DataOffset));
884
885	if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
886	rc = vhdLoadDynamicDisk(pImage, pImage->u64DataOffset);
887
888	if (RT_FAILURE(rc))
889	vhdFreeImage(pImage, false);
890	return rc;
891	}
892
893	/**
894	* Internal: Checks if a sector in the block bitmap is set
895	*/
896	DECLINLINE(bool) vhdBlockBitmapSectorContainsData(PVHDIMAGE pImage, uint32_t cBlockBitmapEntry)
897	{
898	uint32_t iBitmap = (cBlockBitmapEntry / 8); /* Byte in the block bitmap. */
899
900	/*
901	* The index of the bit in the byte of the data block bitmap.
902	* The most significant bit stands for a lower sector number.
903	*/
904	uint8_t iBitInByte = (8-1) - (cBlockBitmapEntry % 8);
905	uint8_t *puBitmap = pImage->pu8Bitmap + iBitmap;
906
907	AssertMsg(puBitmap < (pImage->pu8Bitmap + pImage->cbDataBlockBitmap),
908	("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
909
910	return ASMBitTest(puBitmap, iBitInByte);
911	}
912
913	/**
914	* Internal: Sets the given sector in the sector bitmap.
915	*/
916	DECLINLINE(bool) vhdBlockBitmapSectorSet(PVHDIMAGE pImage, uint8_t *pu8Bitmap, uint32_t cBlockBitmapEntry)
917	{
918	uint32_t iBitmap = (cBlockBitmapEntry / 8); /* Byte in the block bitmap. */
919
920	/*
921	* The index of the bit in the byte of the data block bitmap.
922	* The most significant bit stands for a lower sector number.
923	*/
924	uint8_t iBitInByte = (8-1) - (cBlockBitmapEntry % 8);
925	uint8_t *puBitmap = pu8Bitmap + iBitmap;
926
927	AssertMsg(puBitmap < (pu8Bitmap + pImage->cbDataBlockBitmap),
928	("VHD: Current bitmap position exceeds maximum size of the bitmap\n"));
929
930	return !ASMBitTestAndSet(puBitmap, iBitInByte);
931	}
932
933	/**
934	* Internal: Derive drive geometry from its size.
935	*/
936	static void vhdSetDiskGeometry(PVHDIMAGE pImage, uint64_t cbSize)
937	{
938	uint64_t u64TotalSectors = cbSize / VHD_SECTOR_SIZE;
939	uint32_t u32CylinderTimesHeads, u32Heads, u32SectorsPerTrack;
940
941	if (u64TotalSectors > 65535 * 16 * 255)
942	{
943	/* ATA disks limited to 127 GB. */
944	u64TotalSectors = 65535 * 16 * 255;
945	}
946
947	if (u64TotalSectors >= 65535 * 16 * 63)
948	{
949	u32SectorsPerTrack = 255;
950	u32Heads = 16;
951	u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
952	}
953	else
954	{
955	u32SectorsPerTrack = 17;
956	u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
957
958	u32Heads = (u32CylinderTimesHeads + 1023) / 1024;
959
960	if (u32Heads < 4)
961	{
962	u32Heads = 4;
963	}
964	if (u32CylinderTimesHeads >= (u32Heads * 1024) \|\| u32Heads > 16)
965	{
966	u32SectorsPerTrack = 31;
967	u32Heads = 16;
968	u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
969	}
970	if (u32CylinderTimesHeads >= (u32Heads * 1024))
971	{
972	u32SectorsPerTrack = 63;
973	u32Heads = 16;
974	u32CylinderTimesHeads = u64TotalSectors / u32SectorsPerTrack;
975	}
976	}
977	pImage->PCHSGeometry.cCylinders = u32CylinderTimesHeads / u32Heads;
978	pImage->PCHSGeometry.cHeads = u32Heads;
979	pImage->PCHSGeometry.cSectors = u32SectorsPerTrack;
980	pImage->LCHSGeometry.cCylinders = 0;
981	pImage->LCHSGeometry.cHeads = 0;
982	pImage->LCHSGeometry.cSectors = 0;
983	}
984
985
986	static uint32_t vhdAllocateParentLocators(PVHDIMAGE pImage, VHDDynamicDiskHeader *pDDH, uint64_t u64Offset)
987	{
988	PVHDPLE pLocator = pDDH->ParentLocatorEntry;
989
990	/*
991	* The VHD spec states that the DataSpace field holds the number of sectors
992	* required to store the parent locator path.
993	* As it turned out VPC and Hyper-V store the amount of bytes reserved for the
994	* path and not the number of sectors.
995	*/
996
997	/* Unicode absolute Windows path. */
998	pLocator->u32Code = RT_H2BE_U32(VHD_PLATFORM_CODE_W2KU);
999	pLocator->u32DataSpace = RT_H2BE_U32(VHD_ABSOLUTE_MAX_PATH * sizeof(RTUTF16));
1000	pLocator->u64DataOffset = RT_H2BE_U64(u64Offset);
1001	pLocator++;
1002	u64Offset += VHD_ABSOLUTE_MAX_PATH * sizeof(RTUTF16);
1003	/* Unicode relative Windows path. */
1004	pLocator->u32Code = RT_H2BE_U32(VHD_PLATFORM_CODE_W2RU);
1005	pLocator->u32DataSpace = RT_H2BE_U32(VHD_RELATIVE_MAX_PATH * sizeof(RTUTF16));
1006	pLocator->u64DataOffset = RT_H2BE_U64(u64Offset);
1007	u64Offset += VHD_RELATIVE_MAX_PATH * sizeof(RTUTF16);
1008	return u64Offset;
1009	}
1010
1011	/**
1012	* Internal: Additional code for dynamic VHD image creation.
1013	*/
1014	static int vhdCreateDynamicImage(PVHDIMAGE pImage, uint64_t cbSize)
1015	{
1016	int rc;
1017	VHDDynamicDiskHeader DynamicDiskHeader;
1018	uint32_t u32BlockAllocationTableSectors;
1019	void *pvTmp = NULL;
1020
1021	memset(&DynamicDiskHeader, 0, sizeof(DynamicDiskHeader));
1022
1023	pImage->u64DataOffset = sizeof(VHDFooter);
1024	pImage->cbDataBlock = VHD_BLOCK_SIZE; /* 2 MB */
1025	pImage->cSectorsPerDataBlock = pImage->cbDataBlock / VHD_SECTOR_SIZE;
1026	pImage->cbDataBlockBitmap = pImage->cSectorsPerDataBlock / 8;
1027	pImage->cDataBlockBitmapSectors = pImage->cbDataBlockBitmap / VHD_SECTOR_SIZE;
1028	/* Align to sector boundary */
1029	if (pImage->cbDataBlockBitmap % VHD_SECTOR_SIZE > 0)
1030	pImage->cDataBlockBitmapSectors++;
1031	pImage->pu8Bitmap = vhdBlockBitmapAllocate(pImage);
1032	if (!pImage->pu8Bitmap)
1033	return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for bitmap storage"));
1034
1035	/* Initialize BAT. */
1036	pImage->uBlockAllocationTableOffset = (uint64_t)sizeof(VHDFooter) + sizeof(VHDDynamicDiskHeader);
1037	pImage->cBlockAllocationTableEntries = (uint32_t)((cbSize + pImage->cbDataBlock - 1) / pImage->cbDataBlock); /* Align table to the block size. */
1038	u32BlockAllocationTableSectors = (pImage->cBlockAllocationTableEntries * sizeof(uint32_t) + VHD_SECTOR_SIZE - 1) / VHD_SECTOR_SIZE;
1039	pImage->pBlockAllocationTable = (uint32_t )RTMemAllocZ(pImage->cBlockAllocationTableEntries sizeof(uint32_t));
1040	if (!pImage->pBlockAllocationTable)
1041	return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot allocate memory for BAT"));
1042
1043	for (unsigned i = 0; i < pImage->cBlockAllocationTableEntries; i++)
1044	{
1045	pImage->pBlockAllocationTable[i] = 0xFFFFFFFF; /* It is actually big endian. */
1046	}
1047
1048	/* Round up to the sector size. */
1049	if (pImage->uImageFlags & VD_IMAGE_FLAGS_DIFF) /* fix hyper-v unreadable error */
1050	pImage->uCurrentEndOfFile = vhdAllocateParentLocators(pImage, &DynamicDiskHeader,
1051	pImage->uBlockAllocationTableOffset + u32BlockAllocationTableSectors * VHD_SECTOR_SIZE);
1052	else
1053	pImage->uCurrentEndOfFile = pImage->uBlockAllocationTableOffset + u32BlockAllocationTableSectors * VHD_SECTOR_SIZE;
1054
1055	/* Set dynamic image size. */
1056	pvTmp = RTMemTmpAllocZ(pImage->uCurrentEndOfFile + sizeof(VHDFooter));
1057	if (!pvTmp)
1058	return vdIfError(pImage->pIfError, VERR_NO_MEMORY, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1059
1060	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, pvTmp,
1061	pImage->uCurrentEndOfFile + sizeof(VHDFooter));
1062	if (RT_FAILURE(rc))
1063	{
1064	RTMemTmpFree(pvTmp);
1065	return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1066	}
1067
1068	RTMemTmpFree(pvTmp);
1069
1070	/* Initialize and write the dynamic disk header. */
1071	memcpy(DynamicDiskHeader.Cookie, VHD_DYNAMIC_DISK_HEADER_COOKIE, sizeof(DynamicDiskHeader.Cookie));
1072	DynamicDiskHeader.DataOffset = UINT64_C(0xFFFFFFFFFFFFFFFF); /* Initially the disk has no data. */
1073	DynamicDiskHeader.TableOffset = RT_H2BE_U64(pImage->uBlockAllocationTableOffset);
1074	DynamicDiskHeader.HeaderVersion = RT_H2BE_U32(VHD_DYNAMIC_DISK_HEADER_VERSION);
1075	DynamicDiskHeader.BlockSize = RT_H2BE_U32(pImage->cbDataBlock);
1076	DynamicDiskHeader.MaxTableEntries = RT_H2BE_U32(pImage->cBlockAllocationTableEntries);
1077	/* Compute and update checksum. */
1078	DynamicDiskHeader.Checksum = 0;
1079	DynamicDiskHeader.Checksum = RT_H2BE_U32(vhdChecksum(&DynamicDiskHeader, sizeof(DynamicDiskHeader)));
1080
1081	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, sizeof(VHDFooter),
1082	&DynamicDiskHeader, sizeof(DynamicDiskHeader));
1083	if (RT_FAILURE(rc))
1084	return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write dynamic disk header to image '%s'"), pImage->pszFilename);
1085
1086	/* Write BAT. */
1087	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uBlockAllocationTableOffset,
1088	pImage->pBlockAllocationTable,
1089	pImage->cBlockAllocationTableEntries * sizeof(uint32_t));
1090	if (RT_FAILURE(rc))
1091	return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write BAT to image '%s'"), pImage->pszFilename);
1092
1093	return rc;
1094	}
1095
1096	/**
1097	* Internal: The actual code for VHD image creation, both fixed and dynamic.
1098	*/
1099	static int vhdCreateImage(PVHDIMAGE pImage, uint64_t cbSize,
1100	unsigned uImageFlags, const char *pszComment,
1101	PCVDGEOMETRY pPCHSGeometry,
1102	PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
1103	unsigned uOpenFlags,
1104	PFNVDPROGRESS pfnProgress, void *pvUser,
1105	unsigned uPercentStart, unsigned uPercentSpan)
1106	{
1107	int rc;
1108	VHDFooter Footer;
1109	RTTIMESPEC now;
1110
1111	pImage->uOpenFlags = uOpenFlags;
1112	pImage->uImageFlags = uImageFlags;
1113
1114	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
1115
1116	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
1117	VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
1118	true /* fCreate */),
1119	&pImage->pStorage);
1120	if (RT_FAILURE(rc))
1121	return vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot create image '%s'"), pImage->pszFilename);
1122
1123
1124	pImage->cbSize = cbSize;
1125	pImage->ImageUuid = *pUuid;
1126	RTUuidClear(&pImage->ParentUuid);
1127	vhdSetDiskGeometry(pImage, cbSize);
1128
1129	/* Initialize the footer. */
1130	memset(&Footer, 0, sizeof(Footer));
1131	memcpy(Footer.Cookie, VHD_FOOTER_COOKIE, sizeof(Footer.Cookie));
1132	Footer.Features = RT_H2BE_U32(0x2);
1133	Footer.Version = RT_H2BE_U32(VHD_FOOTER_FILE_FORMAT_VERSION);
1134	Footer.TimeStamp = RT_H2BE_U32(vhdRtTime2VhdTime(RTTimeNow(&now)));
1135	memcpy(Footer.CreatorApp, "vbox", sizeof(Footer.CreatorApp));
1136	Footer.CreatorVer = RT_H2BE_U32(VBOX_VERSION);
1137	#ifdef RT_OS_DARWIN
1138	Footer.CreatorOS = RT_H2BE_U32(0x4D616320); /* "Mac " */
1139	#else /* Virtual PC supports only two platforms atm, so everything else will be Wi2k. */
1140	Footer.CreatorOS = RT_H2BE_U32(0x5769326B); /* "Wi2k" */
1141	#endif
1142	Footer.OrigSize = RT_H2BE_U64(cbSize);
1143	Footer.CurSize = Footer.OrigSize;
1144	Footer.DiskGeometryCylinder = RT_H2BE_U16(pImage->PCHSGeometry.cCylinders);
1145	Footer.DiskGeometryHeads = pImage->PCHSGeometry.cHeads;
1146	Footer.DiskGeometrySectors = pImage->PCHSGeometry.cSectors;
1147	memcpy(Footer.UniqueID, pImage->ImageUuid.au8, sizeof(Footer.UniqueID));
1148	Footer.SavedState = 0;
1149
1150	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
1151	{
1152	Footer.DiskType = RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_FIXED);
1153	/*
1154	* Initialize fixed image.
1155	* "The size of the entire file is the size of the hard disk in
1156	* the guest operating system plus the size of the footer."
1157	*/
1158	pImage->u64DataOffset = VHD_FOOTER_DATA_OFFSET_FIXED;
1159	pImage->uCurrentEndOfFile = cbSize;
1160	/** @todo r=klaus replace this with actual data writes, see the experience
1161	* with VDI files on Windows, can cause long freezes when writing. */
1162	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
1163	pImage->uCurrentEndOfFile + sizeof(VHDFooter));
1164	if (RT_FAILURE(rc))
1165	{
1166	vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot set the file size for '%s'"), pImage->pszFilename);
1167	goto out;
1168	}
1169	}
1170	else
1171	{
1172	/*
1173	* Initialize dynamic image.
1174	*
1175	* The overall structure of dynamic disk is:
1176	*
1177	* [Copy of hard disk footer (512 bytes)]
1178	* [Dynamic disk header (1024 bytes)]
1179	* [BAT (Block Allocation Table)]
1180	* [Parent Locators]
1181	* [Data block 1]
1182	* [Data block 2]
1183	* ...
1184	* [Data block N]
1185	* [Hard disk footer (512 bytes)]
1186	*/
1187	Footer.DiskType = (uImageFlags & VD_IMAGE_FLAGS_DIFF)
1188	? RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_DIFFERENCING)
1189	: RT_H2BE_U32(VHD_FOOTER_DISK_TYPE_DYNAMIC);
1190	/* We are half way thorough with creation of image, let the caller know. */
1191	if (pfnProgress)
1192	pfnProgress(pvUser, (uPercentStart + uPercentSpan) / 2);
1193
1194	rc = vhdCreateDynamicImage(pImage, cbSize);
1195	if (RT_FAILURE(rc))
1196	goto out;
1197	}
1198
1199	Footer.DataOffset = RT_H2BE_U64(pImage->u64DataOffset);
1200
1201	/* Compute and update the footer checksum. */
1202	Footer.Checksum = 0;
1203	Footer.Checksum = RT_H2BE_U32(vhdChecksum(&Footer, sizeof(Footer)));
1204
1205	pImage->vhdFooterCopy = Footer;
1206
1207	/* Store the footer */
1208	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, pImage->uCurrentEndOfFile,
1209	&Footer, sizeof(Footer));
1210	if (RT_FAILURE(rc))
1211	{
1212	vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write footer to image '%s'"), pImage->pszFilename);
1213	goto out;
1214	}
1215
1216	/* Dynamic images contain a copy of the footer at the very beginning of the file. */
1217	if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
1218	{
1219	/* Write the copy of the footer. */
1220	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, 0, &Footer, sizeof(Footer));
1221	if (RT_FAILURE(rc))
1222	{
1223	vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("VHD: cannot write a copy of footer to image '%s'"), pImage->pszFilename);
1224	goto out;
1225	}
1226	}
1227
1228	out:
1229	if (RT_SUCCESS(rc) && pfnProgress)
1230	pfnProgress(pvUser, uPercentStart + uPercentSpan);
1231
1232	if (RT_FAILURE(rc))
1233	vhdFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
1234	return rc;
1235	}
1236
1237
1238	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
1239	static int vhdCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1240	PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
1241	{
1242	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
1243	int rc;
1244	PVDIOSTORAGE pStorage;
1245	uint64_t cbFile;
1246	VHDFooter vhdFooter;
1247
1248	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
1249	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
1250
1251	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
1252	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
1253	false /* fCreate */),
1254	&pStorage);
1255	if (RT_FAILURE(rc))
1256	goto out;
1257
1258	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
1259	if (RT_FAILURE(rc))
1260	{
1261	vdIfIoIntFileClose(pIfIo, pStorage);
1262	rc = VERR_VD_VHD_INVALID_HEADER;
1263	goto out;
1264	}
1265
1266	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, cbFile - sizeof(VHDFooter),
1267	&vhdFooter, sizeof(VHDFooter));
1268	if (RT_SUCCESS(rc))
1269	{
1270	if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
1271	{
1272	/*
1273	* There is also a backup header at the beginning in case the image got corrupted.
1274	* Such corrupted images are detected here to let the open handler repair it later.
1275	*/
1276	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &vhdFooter, sizeof(VHDFooter));
1277	if ( RT_FAILURE(rc)
1278	\|\| (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0))
1279	rc = VERR_VD_VHD_INVALID_HEADER;
1280	}
1281
1282	if (RT_SUCCESS(rc))
1283	*penmType = VDTYPE_HDD;
1284	}
1285	else
1286	rc = VERR_VD_VHD_INVALID_HEADER;
1287
1288	vdIfIoIntFileClose(pIfIo, pStorage);
1289
1290	out:
1291	LogFlowFunc(("returns %Rrc\n", rc));
1292	return rc;
1293	}
1294
1295	/** @copydoc VBOXHDDBACKEND::pfnOpen */
1296	static int vhdOpen(const char *pszFilename, unsigned uOpenFlags,
1297	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1298	VDTYPE enmType, void **ppBackendData)
1299	{
1300	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
1301	int rc = VINF_SUCCESS;
1302	PVHDIMAGE pImage;
1303
1304	/* Check open flags. All valid flags are supported. */
1305	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1306	{
1307	rc = VERR_INVALID_PARAMETER;
1308	goto out;
1309	}
1310
1311	/* Check remaining arguments. */
1312	if ( !VALID_PTR(pszFilename)
1313	\|\| !*pszFilename)
1314	{
1315	rc = VERR_INVALID_PARAMETER;
1316	goto out;
1317	}
1318
1319	pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
1320	if (!pImage)
1321	{
1322	rc = VERR_NO_MEMORY;
1323	goto out;
1324	}
1325
1326	pImage->pszFilename = pszFilename;
1327	pImage->pStorage = NULL;
1328	pImage->pVDIfsDisk = pVDIfsDisk;
1329	pImage->pVDIfsImage = pVDIfsImage;
1330
1331	rc = vhdOpenImage(pImage, uOpenFlags);
1332	if (RT_SUCCESS(rc))
1333	*ppBackendData = pImage;
1334	else
1335	RTMemFree(pImage);
1336
1337	out:
1338	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1339	return rc;
1340	}
1341
1342	/** @copydoc VBOXHDDBACKEND::pfnCreate */
1343	static int vhdCreate(const char *pszFilename, uint64_t cbSize,
1344	unsigned uImageFlags, const char *pszComment,
1345	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1346	PCRTUUID pUuid, unsigned uOpenFlags,
1347	unsigned uPercentStart, unsigned uPercentSpan,
1348	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1349	PVDINTERFACE pVDIfsOperation, void **ppBackendData)
1350	{
1351	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 ppBackendData=%#p", pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, ppBackendData));
1352	int rc = VINF_SUCCESS;
1353	PVHDIMAGE pImage;
1354
1355	PFNVDPROGRESS pfnProgress = NULL;
1356	void *pvUser = NULL;
1357	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
1358	if (pIfProgress)
1359	{
1360	pfnProgress = pIfProgress->pfnProgress;
1361	pvUser = pIfProgress->Core.pvUser;
1362	}
1363
1364	/* Check open flags. All valid flags are supported. */
1365	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1366	{
1367	rc = VERR_INVALID_PARAMETER;
1368	return rc;
1369	}
1370
1371	/* @todo Check the values of other params */
1372
1373	pImage = (PVHDIMAGE)RTMemAllocZ(sizeof(VHDIMAGE));
1374	if (!pImage)
1375	{
1376	rc = VERR_NO_MEMORY;
1377	return rc;
1378	}
1379	pImage->pszFilename = pszFilename;
1380	pImage->pStorage = NULL;
1381	pImage->pVDIfsDisk = pVDIfsDisk;
1382	pImage->pVDIfsImage = pVDIfsImage;
1383
1384	/* Get I/O interface. */
1385	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
1386	if (RT_UNLIKELY(!VALID_PTR(pImage->pIfIo)))
1387	{
1388	RTMemFree(pImage);
1389	return VERR_INVALID_PARAMETER;
1390	}
1391
1392	rc = vhdCreateImage(pImage, cbSize, uImageFlags, pszComment,
1393	pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags,
1394	pfnProgress, pvUser, uPercentStart, uPercentSpan);
1395
1396	if (RT_SUCCESS(rc))
1397	{
1398	/* So far the image is opened in read/write mode. Make sure the
1399	* image is opened in read-only mode if the caller requested that. */
1400	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1401	{
1402	vhdFreeImage(pImage, false);
1403	rc = vhdOpenImage(pImage, uOpenFlags);
1404	if (RT_FAILURE(rc))
1405	{
1406	RTMemFree(pImage);
1407	goto out;
1408	}
1409	}
1410	*ppBackendData = pImage;
1411	}
1412	else
1413	RTMemFree(pImage);
1414
1415	out:
1416	LogFlowFunc(("returns %Rrc\n", rc));
1417	return rc;
1418	}
1419
1420	/** @copydoc VBOXHDDBACKEND::pfnRename */
1421	static int vhdRename(void pBackendData, const char pszFilename)
1422	{
1423	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1424	int rc = VINF_SUCCESS;
1425	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1426
1427	/* Check arguments. */
1428	if ( !pImage
1429	\|\| !pszFilename
1430	\|\| !*pszFilename)
1431	{
1432	rc = VERR_INVALID_PARAMETER;
1433	goto out;
1434	}
1435
1436	/* Close the image. */
1437	rc = vhdFreeImage(pImage, false);
1438	if (RT_FAILURE(rc))
1439	goto out;
1440
1441	/* Rename the file. */
1442	rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
1443	if (RT_FAILURE(rc))
1444	{
1445	/* The move failed, try to reopen the original image. */
1446	int rc2 = vhdOpenImage(pImage, pImage->uOpenFlags);
1447	if (RT_FAILURE(rc2))
1448	rc = rc2;
1449
1450	goto out;
1451	}
1452
1453	/* Update pImage with the new information. */
1454	pImage->pszFilename = pszFilename;
1455
1456	/* Open the old file with new name. */
1457	rc = vhdOpenImage(pImage, pImage->uOpenFlags);
1458	if (RT_FAILURE(rc))
1459	goto out;
1460
1461	out:
1462	LogFlowFunc(("returns %Rrc\n", rc));
1463	return rc;
1464	}
1465
1466	/** @copydoc VBOXHDDBACKEND::pfnClose */
1467	static int vhdClose(void *pBackendData, bool fDelete)
1468	{
1469	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1470	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1471	int rc;
1472
1473	rc = vhdFreeImage(pImage, fDelete);
1474	RTMemFree(pImage);
1475
1476	LogFlowFunc(("returns %Rrc\n", rc));
1477	return rc;
1478	}
1479
1480	/** @copydoc VBOXHDDBACKEND::pfnRead */
1481	static int vhdRead(void *pBackendData, uint64_t uOffset, size_t cbRead,
1482	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1483	{
1484	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1485	int rc = VINF_SUCCESS;
1486
1487	LogFlowFunc(("pBackendData=%p uOffset=%#llx pIoCtx=%#p cbRead=%u pcbActuallyRead=%p\n", pBackendData, uOffset, pIoCtx, cbRead, pcbActuallyRead));
1488
1489	if (uOffset + cbRead > pImage->cbSize)
1490	return VERR_INVALID_PARAMETER;
1491
1492	/*
1493	* If we have a dynamic disk image, we need to find the data block and sector to read.
1494	*/
1495	if (pImage->pBlockAllocationTable)
1496	{
1497	/*
1498	* Get the data block first.
1499	*/
1500	uint32_t cBlockAllocationTableEntry = (uOffset / VHD_SECTOR_SIZE) / pImage->cSectorsPerDataBlock;
1501	uint32_t cBATEntryIndex = (uOffset / VHD_SECTOR_SIZE) % pImage->cSectorsPerDataBlock;
1502	uint64_t uVhdOffset;
1503
1504	LogFlowFunc(("cBlockAllocationTableEntry=%u cBatEntryIndex=%u\n", cBlockAllocationTableEntry, cBATEntryIndex));
1505	LogFlowFunc(("BlockAllocationEntry=%u\n", pImage->pBlockAllocationTable[cBlockAllocationTableEntry]));
1506
1507	/*
1508	* Clip read range to remain in this data block.
1509	*/
1510	cbRead = RT_MIN(cbRead, (pImage->cbDataBlock - (cBATEntryIndex * VHD_SECTOR_SIZE)));
1511
1512	/*
1513	* If the block is not allocated the content of the entry is ~0
1514	*/
1515	if (pImage->pBlockAllocationTable[cBlockAllocationTableEntry] == ~0U)
1516	rc = VERR_VD_BLOCK_FREE;
1517	else
1518	{
1519	uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
1520	LogFlowFunc(("uVhdOffset=%llu cbRead=%u\n", uVhdOffset, cbRead));
1521
1522	/* Read in the block's bitmap. */
1523	PVDMETAXFER pMetaXfer;
1524	rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
1525	((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1526	pImage->pu8Bitmap, pImage->cbDataBlockBitmap,
1527	pIoCtx, &pMetaXfer, NULL, NULL);
1528
1529	if (RT_SUCCESS(rc))
1530	{
1531	uint32_t cSectors = 0;
1532
1533	vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
1534	if (vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1535	{
1536	cBATEntryIndex++;
1537	cSectors = 1;
1538
1539	/*
1540	* The first sector being read is marked dirty, read as much as we
1541	* can from child. Note that only sectors that are marked dirty
1542	* must be read from child.
1543	*/
1544	while ( (cSectors < (cbRead / VHD_SECTOR_SIZE))
1545	&& vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1546	{
1547	cBATEntryIndex++;
1548	cSectors++;
1549	}
1550
1551	cbRead = cSectors * VHD_SECTOR_SIZE;
1552
1553	LogFlowFunc(("uVhdOffset=%llu cbRead=%u\n", uVhdOffset, cbRead));
1554	rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage,
1555	uVhdOffset, pIoCtx, cbRead);
1556	}
1557	else
1558	{
1559	/*
1560	* The first sector being read is marked clean, so we should read from
1561	* our parent instead, but only as much as there are the following
1562	* clean sectors, because the block may still contain dirty sectors
1563	* further on. We just need to compute the number of clean sectors
1564	* and pass it to our caller along with the notification that they
1565	* should be read from the parent.
1566	*/
1567	cBATEntryIndex++;
1568	cSectors = 1;
1569
1570	while ( (cSectors < (cbRead / VHD_SECTOR_SIZE))
1571	&& !vhdBlockBitmapSectorContainsData(pImage, cBATEntryIndex))
1572	{
1573	cBATEntryIndex++;
1574	cSectors++;
1575	}
1576
1577	cbRead = cSectors * VHD_SECTOR_SIZE;
1578	LogFunc(("Sectors free: uVhdOffset=%llu cbRead=%u\n", uVhdOffset, cbRead));
1579	rc = VERR_VD_BLOCK_FREE;
1580	}
1581	}
1582	else
1583	AssertMsg(rc == VERR_VD_NOT_ENOUGH_METADATA, ("Reading block bitmap failed rc=%Rrc\n", rc));
1584	}
1585	}
1586	else
1587	rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, uOffset, pIoCtx, cbRead);
1588
1589	if (pcbActuallyRead)
1590	*pcbActuallyRead = cbRead;
1591
1592	LogFlowFunc(("returns rc=%Rrc\n", rc));
1593	return rc;
1594	}
1595
1596	/** @copydoc VBOXHDDBACKEND::pfnWrite */
1597	static int vhdWrite(void *pBackendData, uint64_t uOffset, size_t cbWrite,
1598	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
1599	size_t *pcbPostRead, unsigned fWrite)
1600	{
1601	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1602	int rc = VINF_SUCCESS;
1603
1604	LogFlowFunc(("pBackendData=%p uOffset=%llu pIoCtx=%#p cbWrite=%u pcbWriteProcess=%p pcbPreRead=%p pcbPostRead=%p fWrite=%u\n",
1605	pBackendData, uOffset, pIoCtx, cbWrite, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite));
1606
1607	AssertPtr(pImage);
1608	Assert(uOffset % VHD_SECTOR_SIZE == 0);
1609	Assert(cbWrite % VHD_SECTOR_SIZE == 0);
1610
1611	if (pImage->pBlockAllocationTable)
1612	{
1613	/*
1614	* Get the data block first.
1615	*/
1616	uint32_t cSector = uOffset / VHD_SECTOR_SIZE;
1617	uint32_t cBlockAllocationTableEntry = cSector / pImage->cSectorsPerDataBlock;
1618	uint32_t cBATEntryIndex = cSector % pImage->cSectorsPerDataBlock;
1619	uint64_t uVhdOffset;
1620
1621	/*
1622	* Clip write range.
1623	*/
1624	cbWrite = RT_MIN(cbWrite, (pImage->cbDataBlock - (cBATEntryIndex * VHD_SECTOR_SIZE)));
1625
1626	/*
1627	* If the block is not allocated the content of the entry is ~0
1628	* and we need to allocate a new block. Note that while blocks are
1629	* allocated with a relatively big granularity, each sector has its
1630	* own bitmap entry, indicating whether it has been written or not.
1631	* So that means for the purposes of the higher level that the
1632	* granularity is invisible. This means there's no need to return
1633	* VERR_VD_BLOCK_FREE unless the block hasn't been allocated yet.
1634	*/
1635	if (pImage->pBlockAllocationTable[cBlockAllocationTableEntry] == ~0U)
1636	{
1637	/* Check if the block allocation should be suppressed. */
1638	if (fWrite & VD_WRITE_NO_ALLOC)
1639	{
1640	pcbPreRead = cBATEntryIndex VHD_SECTOR_SIZE;
1641	pcbPostRead = pImage->cSectorsPerDataBlock VHD_SECTOR_SIZE - cbWrite - *pcbPreRead;
1642
1643	if (pcbWriteProcess)
1644	*pcbWriteProcess = cbWrite;
1645	return VERR_VD_BLOCK_FREE;
1646	}
1647
1648	PVHDIMAGEEXPAND pExpand = (PVHDIMAGEEXPAND)RTMemAllocZ(RT_OFFSETOF(VHDIMAGEEXPAND, au8Bitmap[pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE]));
1649	bool fIoInProgress = false;
1650
1651	if (!pExpand)
1652	return VERR_NO_MEMORY;
1653
1654	pExpand->cbEofOld = pImage->uCurrentEndOfFile;
1655	pExpand->idxBatAllocated = cBlockAllocationTableEntry;
1656	pExpand->idxBlockBe = RT_H2BE_U32(pImage->uCurrentEndOfFile / VHD_SECTOR_SIZE);
1657
1658	/* Set the bits for all sectors having been written. */
1659	for (uint32_t iSector = 0; iSector < (cbWrite / VHD_SECTOR_SIZE); iSector++)
1660	{
1661	/* No need to check for a changed value because this is an initial write. */
1662	vhdBlockBitmapSectorSet(pImage, pExpand->au8Bitmap, cBATEntryIndex);
1663	cBATEntryIndex++;
1664	}
1665
1666	do
1667	{
1668	/*
1669	* Start with the sector bitmap.
1670	*/
1671	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1672	pImage->uCurrentEndOfFile,
1673	pExpand->au8Bitmap,
1674	pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE, pIoCtx,
1675	vhdAsyncExpansionDataBlockBitmapComplete,
1676	pExpand);
1677	if (RT_SUCCESS(rc))
1678	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1679	else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1680	fIoInProgress = true;
1681	else
1682	{
1683	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BLOCKBITMAP_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1684	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1685	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1686	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1687	break;
1688	}
1689
1690
1691	/*
1692	* Write the new block at the current end of the file.
1693	*/
1694	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1695	pImage->uCurrentEndOfFile + pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE,
1696	pIoCtx, cbWrite,
1697	vhdAsyncExpansionDataComplete,
1698	pExpand);
1699	if (RT_SUCCESS(rc))
1700	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1701	else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1702	fIoInProgress = true;
1703	else
1704	{
1705	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_USERBLOCK_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1706	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1707	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1708	break;
1709	}
1710
1711	/*
1712	* Write entry in the BAT.
1713	*/
1714	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1715	pImage->uBlockAllocationTableOffset + cBlockAllocationTableEntry * sizeof(uint32_t),
1716	&pExpand->idxBlockBe, sizeof(uint32_t), pIoCtx,
1717	vhdAsyncExpansionBatUpdateComplete,
1718	pExpand);
1719	if (RT_SUCCESS(rc))
1720	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1721	else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1722	fIoInProgress = true;
1723	else
1724	{
1725	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_BAT_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1726	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1727	break;
1728	}
1729
1730	/*
1731	* Set the new end of the file and link the new block into the BAT.
1732	*/
1733	pImage->pBlockAllocationTable[cBlockAllocationTableEntry] = pImage->uCurrentEndOfFile / VHD_SECTOR_SIZE;
1734	pImage->uCurrentEndOfFile += pImage->cDataBlockBitmapSectors * VHD_SECTOR_SIZE + pImage->cbDataBlock;
1735
1736	/* Update the footer. */
1737	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1738	pImage->uCurrentEndOfFile,
1739	&pImage->vhdFooterCopy,
1740	sizeof(VHDFooter), pIoCtx,
1741	vhdAsyncExpansionFooterUpdateComplete,
1742	pExpand);
1743	if (RT_SUCCESS(rc))
1744	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_SUCCESS);
1745	else if (rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1746	fIoInProgress = true;
1747	else
1748	{
1749	VHDIMAGEEXPAND_STATUS_SET(pExpand->fFlags, VHDIMAGEEXPAND_FOOTER_STATUS_SHIFT, VHDIMAGEEXPAND_STEP_FAILED);
1750	break;
1751	}
1752
1753	} while (0);
1754
1755	if (!fIoInProgress)
1756	vhdAsyncExpansionComplete(pImage, pIoCtx, pExpand);
1757	else
1758	rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
1759	}
1760	else
1761	{
1762	/*
1763	* Calculate the real offset in the file.
1764	*/
1765	uVhdOffset = ((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry] + pImage->cDataBlockBitmapSectors + cBATEntryIndex) * VHD_SECTOR_SIZE;
1766
1767	/* Read in the block's bitmap. */
1768	PVDMETAXFER pMetaXfer;
1769	rc = vdIfIoIntFileReadMeta(pImage->pIfIo, pImage->pStorage,
1770	((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1771	pImage->pu8Bitmap,
1772	pImage->cbDataBlockBitmap, pIoCtx,
1773	&pMetaXfer, NULL, NULL);
1774	if (RT_SUCCESS(rc))
1775	{
1776	vdIfIoIntMetaXferRelease(pImage->pIfIo, pMetaXfer);
1777
1778	/* Write data. */
1779	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1780	uVhdOffset, pIoCtx, cbWrite,
1781	NULL, NULL);
1782	if (RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
1783	{
1784	bool fChanged = false;
1785
1786	/* Set the bits for all sectors having been written. */
1787	for (uint32_t iSector = 0; iSector < (cbWrite / VHD_SECTOR_SIZE); iSector++)
1788	{
1789	fChanged \|= vhdBlockBitmapSectorSet(pImage, pImage->pu8Bitmap, cBATEntryIndex);
1790	cBATEntryIndex++;
1791	}
1792
1793	/* Only write the bitmap if it was changed. */
1794	if (fChanged)
1795	{
1796	/*
1797	* Write the bitmap back.
1798	*
1799	* @note We don't have a completion callback here because we
1800	* can't do anything if the write fails for some reason.
1801	* The error will propagated to the device/guest
1802	* by the generic VD layer already and we don't need
1803	* to rollback anything here.
1804	*/
1805	rc = vdIfIoIntFileWriteMeta(pImage->pIfIo, pImage->pStorage,
1806	((uint64_t)pImage->pBlockAllocationTable[cBlockAllocationTableEntry]) * VHD_SECTOR_SIZE,
1807	pImage->pu8Bitmap,
1808	pImage->cbDataBlockBitmap,
1809	pIoCtx, NULL, NULL);
1810	}
1811	}
1812	}
1813	}
1814	}
1815	else
1816	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage,
1817	uOffset, pIoCtx, cbWrite, NULL, NULL);
1818
1819	if (pcbWriteProcess)
1820	*pcbWriteProcess = cbWrite;
1821
1822	/* Stay on the safe side. Do not run the risk of confusing the higher
1823	* level, as that can be pretty lethal to image consistency. */
1824	*pcbPreRead = 0;
1825	*pcbPostRead = 0;
1826
1827	return rc;
1828	}
1829
1830	/** @copydoc VBOXHDDBACKEND::pfnFlush */
1831	static int vhdFlush(void *pBackendData, PVDIOCTX pIoCtx)
1832	{
1833	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1834
1835	/* No need to write anything here. Data is always updated on a write. */
1836	return vdIfIoIntFileFlush(pImage->pIfIo, pImage->pStorage, pIoCtx, NULL, NULL);
1837	}
1838
1839	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
1840	static unsigned vhdGetVersion(void *pBackendData)
1841	{
1842	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1843	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1844	unsigned ver = 0;
1845
1846	AssertPtr(pImage);
1847
1848	if (pImage)
1849	ver = 1; /*< @todo use correct version /
1850
1851	LogFlowFunc(("returns %u\n", ver));
1852	return ver;
1853	}
1854
1855	/** @copydoc VBOXHDDBACKEND::pfnGetSectorSize */
1856	static uint32_t vhdGetSectorSize(void *pBackendData)
1857	{
1858	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1859	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1860	uint32_t cb = 0;
1861
1862	AssertPtr(pImage);
1863
1864	if (pImage)
1865	cb = 512;
1866
1867	LogFlowFunc(("returns %zu\n", cb));
1868	return cb;
1869	}
1870
1871	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
1872	static uint64_t vhdGetSize(void *pBackendData)
1873	{
1874	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1875	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1876	uint64_t cb = 0;
1877
1878	AssertPtr(pImage);
1879
1880	if (pImage && pImage->pStorage)
1881	cb = pImage->cbSize;
1882
1883	LogFlowFunc(("returns %llu\n", cb));
1884	return cb;
1885	}
1886
1887	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
1888	static uint64_t vhdGetFileSize(void *pBackendData)
1889	{
1890	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1891	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1892	uint64_t cb = 0;
1893
1894	AssertPtr(pImage);
1895
1896	if (pImage && pImage->pStorage)
1897	cb = pImage->uCurrentEndOfFile + sizeof(VHDFooter);
1898
1899	LogFlowFunc(("returns %lld\n", cb));
1900	return cb;
1901	}
1902
1903	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
1904	static int vhdGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
1905	{
1906	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1907	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1908	int rc;
1909
1910	AssertPtr(pImage);
1911
1912	if (pImage)
1913	{
1914	if (pImage->PCHSGeometry.cCylinders)
1915	{
1916	*pPCHSGeometry = pImage->PCHSGeometry;
1917	rc = VINF_SUCCESS;
1918	}
1919	else
1920	rc = VERR_VD_GEOMETRY_NOT_SET;
1921	}
1922	else
1923	rc = VERR_VD_NOT_OPENED;
1924
1925	LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors));
1926	return rc;
1927	}
1928
1929	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
1930	static int vhdSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
1931	{
1932	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1933	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1934	int rc;
1935
1936	AssertPtr(pImage);
1937
1938	if (pImage)
1939	{
1940	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1941	{
1942	rc = VERR_VD_IMAGE_READ_ONLY;
1943	goto out;
1944	}
1945
1946	pImage->PCHSGeometry = *pPCHSGeometry;
1947	rc = VINF_SUCCESS;
1948	}
1949	else
1950	rc = VERR_VD_NOT_OPENED;
1951
1952	out:
1953	LogFlowFunc(("returns %Rrc\n", rc));
1954	return rc;
1955	}
1956
1957	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
1958	static int vhdGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
1959	{
1960	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1961	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1962	int rc;
1963
1964	AssertPtr(pImage);
1965
1966	if (pImage)
1967	{
1968	if (pImage->LCHSGeometry.cCylinders)
1969	{
1970	*pLCHSGeometry = pImage->LCHSGeometry;
1971	rc = VINF_SUCCESS;
1972	}
1973	else
1974	rc = VERR_VD_GEOMETRY_NOT_SET;
1975	}
1976	else
1977	rc = VERR_VD_NOT_OPENED;
1978
1979	LogFlowFunc(("returns %Rrc (CHS=%u/%u/%u)\n", rc, pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors));
1980	return rc;
1981	}
1982
1983	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
1984	static int vhdSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
1985	{
1986	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
1987	int rc;
1988
1989	AssertPtr(pImage);
1990
1991	if (pImage)
1992	{
1993	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1994	{
1995	rc = VERR_VD_IMAGE_READ_ONLY;
1996	goto out;
1997	}
1998
1999	pImage->LCHSGeometry = *pLCHSGeometry;
2000	rc = VINF_SUCCESS;
2001	}
2002	else
2003	rc = VERR_VD_NOT_OPENED;
2004
2005	out:
2006	LogFlowFunc(("returns %Rrc\n", rc));
2007	return rc;
2008	}
2009
2010	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
2011	static unsigned vhdGetImageFlags(void *pBackendData)
2012	{
2013	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2014	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2015	unsigned uImageFlags;
2016
2017	AssertPtr(pImage);
2018
2019	if (pImage)
2020	uImageFlags = pImage->uImageFlags;
2021	else
2022	uImageFlags = 0;
2023
2024	LogFlowFunc(("returns %#x\n", uImageFlags));
2025	return uImageFlags;
2026	}
2027
2028	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
2029	static unsigned vhdGetOpenFlags(void *pBackendData)
2030	{
2031	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2032	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2033	unsigned uOpenFlags;
2034
2035	AssertPtr(pImage);
2036
2037	if (pImage)
2038	uOpenFlags = pImage->uOpenFlags;
2039	else
2040	uOpenFlags = 0;
2041
2042	LogFlowFunc(("returns %#x\n", uOpenFlags));
2043	return uOpenFlags;
2044	}
2045
2046	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
2047	static int vhdSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
2048	{
2049	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
2050	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2051	int rc;
2052
2053	/* Image must be opened and the new flags must be valid. */
2054	if (!pImage \|\| (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
2055	\| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE
2056	\| VD_OPEN_FLAGS_SEQUENTIAL \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
2057	{
2058	rc = VERR_INVALID_PARAMETER;
2059	goto out;
2060	}
2061
2062	/* Implement this operation via reopening the image. */
2063	rc = vhdFreeImage(pImage, false);
2064	if (RT_FAILURE(rc))
2065	goto out;
2066	rc = vhdOpenImage(pImage, uOpenFlags);
2067
2068	out:
2069	LogFlowFunc(("returns %Rrc\n", rc));
2070	return rc;
2071	}
2072
2073	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
2074	static int vhdGetComment(void pBackendData, char pszComment,
2075	size_t cbComment)
2076	{
2077	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
2078	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2079	int rc;
2080
2081	AssertPtr(pImage);
2082
2083	if (pImage)
2084	rc = VERR_NOT_SUPPORTED;
2085	else
2086	rc = VERR_VD_NOT_OPENED;
2087
2088	LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
2089	return rc;
2090	}
2091
2092	/** @copydoc VBOXHDDBACKEND::pfnSetComment */
2093	static int vhdSetComment(void pBackendData, const char pszComment)
2094	{
2095	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
2096	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2097	int rc;
2098
2099	AssertPtr(pImage);
2100
2101	if (pImage)
2102	{
2103	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2104	rc = VERR_VD_IMAGE_READ_ONLY;
2105	else
2106	rc = VERR_NOT_SUPPORTED;
2107	}
2108	else
2109	rc = VERR_VD_NOT_OPENED;
2110
2111	LogFlowFunc(("returns %Rrc\n", rc));
2112	return rc;
2113	}
2114
2115	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
2116	static int vhdGetUuid(void *pBackendData, PRTUUID pUuid)
2117	{
2118	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2119	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2120	int rc;
2121
2122	AssertPtr(pImage);
2123
2124	if (pImage)
2125	{
2126	*pUuid = pImage->ImageUuid;
2127	rc = VINF_SUCCESS;
2128	}
2129	else
2130	rc = VERR_VD_NOT_OPENED;
2131
2132	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2133	return rc;
2134	}
2135
2136	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
2137	static int vhdSetUuid(void *pBackendData, PCRTUUID pUuid)
2138	{
2139	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2140	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2141	int rc;
2142
2143	AssertPtr(pImage);
2144
2145	if (pImage)
2146	{
2147	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2148	{
2149	pImage->ImageUuid = *pUuid;
2150	/* Update the footer copy. It will get written to disk when the image is closed. */
2151	memcpy(&pImage->vhdFooterCopy.UniqueID, pUuid, 16);
2152	/* Update checksum. */
2153	pImage->vhdFooterCopy.Checksum = 0;
2154	pImage->vhdFooterCopy.Checksum = RT_H2BE_U32(vhdChecksum(&pImage->vhdFooterCopy, sizeof(VHDFooter)));
2155
2156	/* Need to update the dynamic disk header to update the disk footer copy at the beginning. */
2157	if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
2158	pImage->fDynHdrNeedsUpdate = true;
2159	rc = VINF_SUCCESS;
2160	}
2161	else
2162	rc = VERR_VD_IMAGE_READ_ONLY;
2163	}
2164	else
2165	rc = VERR_VD_NOT_OPENED;
2166
2167	LogFlowFunc(("returns %Rrc\n", rc));
2168	return rc;
2169	}
2170
2171	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
2172	static int vhdGetModificationUuid(void *pBackendData, PRTUUID pUuid)
2173	{
2174	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2175	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2176	int rc;
2177
2178	AssertPtr(pImage);
2179
2180	if (pImage)
2181	rc = VERR_NOT_SUPPORTED;
2182	else
2183	rc = VERR_VD_NOT_OPENED;
2184
2185	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2186	return rc;
2187	}
2188
2189	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
2190	static int vhdSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
2191	{
2192	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2193	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2194	int rc;
2195
2196	AssertPtr(pImage);
2197
2198	if (pImage)
2199	{
2200	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2201	rc = VERR_NOT_SUPPORTED;
2202	else
2203	rc = VERR_VD_IMAGE_READ_ONLY;
2204	}
2205	else
2206	rc = VERR_VD_NOT_OPENED;
2207
2208	LogFlowFunc(("returns %Rrc\n", rc));
2209	return rc;
2210	}
2211
2212	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
2213	static int vhdGetParentUuid(void *pBackendData, PRTUUID pUuid)
2214	{
2215	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2216	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2217	int rc;
2218
2219	AssertPtr(pImage);
2220
2221	if (pImage)
2222	{
2223	*pUuid = pImage->ParentUuid;
2224	rc = VINF_SUCCESS;
2225	}
2226	else
2227	rc = VERR_VD_NOT_OPENED;
2228
2229	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2230	return rc;
2231	}
2232
2233	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
2234	static int vhdSetParentUuid(void *pBackendData, PCRTUUID pUuid)
2235	{
2236	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2237	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2238	int rc = VINF_SUCCESS;
2239
2240	AssertPtr(pImage);
2241
2242	if (pImage && pImage->pStorage)
2243	{
2244	if (!(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED))
2245	{
2246	pImage->ParentUuid = *pUuid;
2247	pImage->fDynHdrNeedsUpdate = true;
2248	}
2249	else
2250	rc = VERR_VD_IMAGE_READ_ONLY;
2251	}
2252	else
2253	rc = VERR_VD_NOT_OPENED;
2254
2255	LogFlowFunc(("returns %Rrc\n", rc));
2256	return rc;
2257	}
2258
2259	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
2260	static int vhdGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
2261	{
2262	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
2263	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2264	int rc;
2265
2266	AssertPtr(pImage);
2267
2268	if (pImage)
2269	rc = VERR_NOT_SUPPORTED;
2270	else
2271	rc = VERR_VD_NOT_OPENED;
2272
2273	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
2274	return rc;
2275	}
2276
2277	/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
2278	static int vhdSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
2279	{
2280	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
2281	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2282	int rc;
2283
2284	AssertPtr(pImage);
2285
2286	if (pImage)
2287	{
2288	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2289	rc = VERR_NOT_SUPPORTED;
2290	else
2291	rc = VERR_VD_IMAGE_READ_ONLY;
2292	}
2293	else
2294	rc = VERR_VD_NOT_OPENED;
2295
2296	LogFlowFunc(("returns %Rrc\n", rc));
2297	return rc;
2298	}
2299
2300	/** @copydoc VBOXHDDBACKEND::pfnDump */
2301	static void vhdDump(void *pBackendData)
2302	{
2303	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2304
2305	AssertPtr(pImage);
2306	if (pImage)
2307	{
2308	vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%u\n",
2309	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
2310	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
2311	VHD_SECTOR_SIZE);
2312	vdIfErrorMessage(pImage->pIfError, "Header: uuidCreation={%RTuuid}\n", &pImage->ImageUuid);
2313	vdIfErrorMessage(pImage->pIfError, "Header: uuidParent={%RTuuid}\n", &pImage->ParentUuid);
2314	}
2315	}
2316
2317	/** @copydoc VBOXHDDBACKEND::pfnGetTimestamp */
2318	static int vhdGetTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
2319	{
2320	int rc = VINF_SUCCESS;
2321	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2322
2323	AssertPtr(pImage);
2324
2325	if (pImage)
2326	rc = vdIfIoIntFileGetModificationTime(pImage->pIfIo, pImage->pszFilename, pTimeStamp);
2327	else
2328	rc = VERR_VD_NOT_OPENED;
2329
2330	LogFlowFunc(("returns %Rrc\n", rc));
2331	return rc;
2332	}
2333
2334	/** @copydoc VBOXHDDBACKEND::pfnGetParentTimeStamp */
2335	static int vhdGetParentTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
2336	{
2337	int rc = VINF_SUCCESS;
2338	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2339
2340	AssertPtr(pImage);
2341
2342	if (pImage)
2343	vhdTime2RtTime(pTimeStamp, pImage->u32ParentTimeStamp);
2344	else
2345	rc = VERR_VD_NOT_OPENED;
2346
2347	LogFlowFunc(("returns %Rrc\n", rc));
2348	return rc;
2349	}
2350
2351	/** @copydoc VBOXHDDBACKEND::pfnSetParentTimeStamp */
2352	static int vhdSetParentTimeStamp(void *pBackendData, PCRTTIMESPEC pTimeStamp)
2353	{
2354	int rc = VINF_SUCCESS;
2355	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2356
2357	AssertPtr(pImage);
2358	if (pImage)
2359	{
2360	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2361	rc = VERR_VD_IMAGE_READ_ONLY;
2362	else
2363	{
2364	pImage->u32ParentTimeStamp = vhdRtTime2VhdTime(pTimeStamp);
2365	pImage->fDynHdrNeedsUpdate = true;
2366	}
2367	}
2368	else
2369	rc = VERR_VD_NOT_OPENED;
2370
2371	LogFlowFunc(("returns %Rrc\n", rc));
2372	return rc;
2373	}
2374
2375	/** @copydoc VBOXHDDBACKEND::pfnGetParentFilename */
2376	static int vhdGetParentFilename(void pBackendData, char *ppszParentFilename)
2377	{
2378	int rc = VINF_SUCCESS;
2379	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2380
2381	AssertPtr(pImage);
2382	if (pImage)
2383	*ppszParentFilename = RTStrDup(pImage->pszParentFilename);
2384	else
2385	rc = VERR_VD_NOT_OPENED;
2386
2387	LogFlowFunc(("returns %Rrc\n", rc));
2388	return rc;
2389	}
2390
2391	/** @copydoc VBOXHDDBACKEND::pfnSetParentFilename */
2392	static int vhdSetParentFilename(void pBackendData, const char pszParentFilename)
2393	{
2394	int rc = VINF_SUCCESS;
2395	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2396
2397	AssertPtr(pImage);
2398	if (pImage)
2399	{
2400	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2401	rc = VERR_VD_IMAGE_READ_ONLY;
2402	else
2403	{
2404	if (pImage->pszParentFilename)
2405	RTStrFree(pImage->pszParentFilename);
2406	pImage->pszParentFilename = RTStrDup(pszParentFilename);
2407	if (!pImage->pszParentFilename)
2408	rc = VERR_NO_MEMORY;
2409	else
2410	pImage->fDynHdrNeedsUpdate = true;
2411	}
2412	}
2413	else
2414	rc = VERR_VD_NOT_OPENED;
2415
2416	LogFlowFunc(("returns %Rrc\n", rc));
2417	return rc;
2418	}
2419
2420	/** @copydoc VBOXHDDBACKEND::pfnCompact */
2421	static int vhdCompact(void *pBackendData, unsigned uPercentStart,
2422	unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
2423	PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
2424	{
2425	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2426	int rc = VINF_SUCCESS;
2427	void pvBuf = NULL, pvReplace = NULL;
2428	uint32_t *paBlocks = NULL;
2429
2430	int (pfnParentRead)(void , uint64_t, void *, size_t) = NULL;
2431	void *pvParent = NULL;
2432	PVDINTERFACEPARENTSTATE pIfParentState = VDIfParentStateGet(pVDIfsOperation);
2433	if (pIfParentState)
2434	{
2435	pfnParentRead = pIfParentState->pfnParentRead;
2436	pvParent = pIfParentState->Core.pvUser;
2437	}
2438
2439	PFNVDPROGRESS pfnProgress = NULL;
2440	void *pvUser = NULL;
2441	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
2442	if (pIfProgress)
2443	{
2444	pfnProgress = pIfProgress->pfnProgress;
2445	pvUser = pIfProgress->Core.pvUser;
2446	}
2447
2448	do
2449	{
2450	AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
2451
2452	AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2453	rc = VERR_VD_IMAGE_READ_ONLY);
2454
2455	/* Reject fixed images as they don't have a BAT. */
2456	if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2457	{
2458	rc = VERR_NOT_SUPPORTED;
2459	break;
2460	}
2461
2462	if (pfnParentRead)
2463	{
2464	pvParent = RTMemTmpAlloc(pImage->cbDataBlock);
2465	AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2466	}
2467	pvBuf = RTMemTmpAlloc(pImage->cbDataBlock);
2468	AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2469
2470	unsigned cBlocksAllocated = 0;
2471	unsigned cBlocksToMove = 0;
2472	unsigned cBlocks = pImage->cBlockAllocationTableEntries;
2473	uint32_t offBlocksStart = ~0U; /* Start offset of data blocks in sectors. */
2474	uint32_t *paBat = pImage->pBlockAllocationTable;
2475
2476	/* Count the number of allocated blocks and find the start offset for the data blocks. */
2477	for (unsigned i = 0; i < cBlocks; i++)
2478	if (paBat[i] != ~0U)
2479	{
2480	cBlocksAllocated++;
2481	if (paBat[i] < offBlocksStart)
2482	offBlocksStart = paBat[i];
2483	}
2484
2485	if (!cBlocksAllocated)
2486	{
2487	/* Nothing to do. */
2488	rc = VINF_SUCCESS;
2489	break;
2490	}
2491
2492	paBlocks = (uint32_t )RTMemTmpAllocZ(cBlocksAllocated sizeof(uint32_t));
2493	AssertBreakStmt(VALID_PTR(paBlocks), rc = VERR_NO_MEMORY);
2494
2495	/* Invalidate the back resolving array. */
2496	for (unsigned i = 0; i < cBlocksAllocated; i++)
2497	paBlocks[i] = ~0U;
2498
2499	/* Fill the back resolving table. */
2500	for (unsigned i = 0; i < cBlocks; i++)
2501	if (paBat[i] != ~0U)
2502	{
2503	unsigned idxBlock = (paBat[i] - offBlocksStart) / pImage->cSectorsPerDataBlock;
2504	if ( idxBlock < cBlocksAllocated
2505	&& paBlocks[idxBlock] == ~0U)
2506	paBlocks[idxBlock] = i;
2507	else
2508	{
2509	/* The image is in an inconsistent state. Don't go further. */
2510	rc = VERR_INVALID_STATE;
2511	break;
2512	}
2513	}
2514
2515	if (RT_FAILURE(rc))
2516	break;
2517
2518	/* Find redundant information and update the block pointers
2519	* accordingly, creating bubbles. Keep disk up to date, as this
2520	* enables cancelling. */
2521	for (unsigned i = 0; i < cBlocks; i++)
2522	{
2523	if (paBat[i] != ~0U)
2524	{
2525	unsigned idxBlock = (paBat[i] - offBlocksStart) / pImage->cSectorsPerDataBlock;
2526
2527	/* Block present in image file, read relevant data. */
2528	uint64_t u64Offset = ((uint64_t)paBat[i] + pImage->cDataBlockBitmapSectors) * VHD_SECTOR_SIZE;
2529	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2530	u64Offset, pvBuf, pImage->cbDataBlock);
2531	if (RT_FAILURE(rc))
2532	break;
2533
2534	if (ASMBitFirstSet((volatile void )pvBuf, (uint32_t)pImage->cbDataBlock 8) == -1)
2535	{
2536	paBat[i] = ~0;
2537	paBlocks[idxBlock] = ~0U;
2538	/* Adjust progress info, one block to be relocated. */
2539	cBlocksToMove++;
2540	}
2541	else if (pfnParentRead)
2542	{
2543	rc = pfnParentRead(pvParent, (uint64_t)i * pImage->cbDataBlock, pvParent, pImage->cbDataBlock);
2544	if (RT_FAILURE(rc))
2545	break;
2546	if (!memcmp(pvParent, pvBuf, pImage->cbDataBlock))
2547	{
2548	paBat[i] = ~0U;
2549	paBlocks[idxBlock] = ~0U;
2550	/* Adjust progress info, one block to be relocated. */
2551	cBlocksToMove++;
2552	}
2553	}
2554	}
2555
2556	if (pIfProgress && pIfProgress->pfnProgress)
2557	{
2558	rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2559	(uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2560	if (RT_FAILURE(rc))
2561	break;
2562	}
2563	}
2564
2565	if (RT_SUCCESS(rc))
2566	{
2567	/* Fill bubbles with other data (if available). */
2568	unsigned cBlocksMoved = 0;
2569	unsigned uBlockUsedPos = cBlocksAllocated;
2570	size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of whole block containing the bitmap and the user data. */
2571
2572	/* Allocate data buffer to hold the data block and allocation bitmap in front of the actual data. */
2573	RTMemTmpFree(pvBuf);
2574	pvBuf = RTMemTmpAllocZ(cbBlock);
2575	AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2576
2577	for (unsigned i = 0; i < cBlocksAllocated; i++)
2578	{
2579	unsigned uBlock = paBlocks[i];
2580	if (uBlock == ~0U)
2581	{
2582	unsigned uBlockData = ~0U;
2583	while (uBlockUsedPos > i && uBlockData == ~0U)
2584	{
2585	uBlockUsedPos--;
2586	uBlockData = paBlocks[uBlockUsedPos];
2587	}
2588	/* Terminate early if there is no block which needs copying. */
2589	if (uBlockUsedPos == i)
2590	break;
2591	uint64_t u64Offset = (uint64_t)uBlockUsedPos * cbBlock
2592	+ (offBlocksStart * VHD_SECTOR_SIZE);
2593	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2594	u64Offset, pvBuf, cbBlock);
2595	if (RT_FAILURE(rc))
2596	break;
2597
2598	u64Offset = (uint64_t)i * cbBlock
2599	+ (offBlocksStart * VHD_SECTOR_SIZE);
2600	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2601	u64Offset, pvBuf, cbBlock);
2602	if (RT_FAILURE(rc))
2603	break;
2604
2605	paBat[uBlockData] = i*(pImage->cSectorsPerDataBlock + pImage->cDataBlockBitmapSectors) + offBlocksStart;
2606
2607	/* Truncate the file but leave enough room for the footer to avoid
2608	* races if other processes fill the whole harddisk. */
2609	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage,
2610	pImage->uCurrentEndOfFile - cbBlock + VHD_SECTOR_SIZE);
2611	if (RT_FAILURE(rc))
2612	break;
2613
2614	/* Update pointers and write footer. */
2615	pImage->uCurrentEndOfFile -= cbBlock;
2616
2617	/* We're kinda screwed if this failes. */
2618	rc = vhdUpdateFooter(pImage);
2619	if (RT_FAILURE(rc))
2620	break;
2621
2622	paBlocks[i] = uBlockData;
2623	paBlocks[uBlockUsedPos] = ~0U;
2624	cBlocksMoved++;
2625	}
2626
2627	if (pIfProgress && pIfProgress->pfnProgress)
2628	{
2629	rc = pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2630	(uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2631
2632	if (RT_FAILURE(rc))
2633	break;
2634	}
2635	}
2636	}
2637
2638	/* Write the new BAT in any case. */
2639	rc = vhdFlushImage(pImage);
2640	} while (0);
2641
2642	if (paBlocks)
2643	RTMemTmpFree(paBlocks);
2644	if (pvParent)
2645	RTMemTmpFree(pvParent);
2646	if (pvBuf)
2647	RTMemTmpFree(pvBuf);
2648
2649	if (RT_SUCCESS(rc) && pIfProgress && pIfProgress->pfnProgress)
2650	{
2651	pIfProgress->pfnProgress(pIfProgress->Core.pvUser,
2652	uPercentStart + uPercentSpan);
2653	}
2654
2655	LogFlowFunc(("returns %Rrc\n", rc));
2656	return rc;
2657	}
2658
2659	/** @copydoc VBOXHDDBACKEND::pfnResize */
2660	static int vhdResize(void *pBackendData, uint64_t cbSize,
2661	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
2662	unsigned uPercentStart, unsigned uPercentSpan,
2663	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
2664	PVDINTERFACE pVDIfsOperation)
2665	{
2666	PVHDIMAGE pImage = (PVHDIMAGE)pBackendData;
2667	int rc = VINF_SUCCESS;
2668
2669	PFNVDPROGRESS pfnProgress = NULL;
2670	void *pvUser = NULL;
2671	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
2672	if (pIfProgress)
2673	{
2674	pfnProgress = pIfProgress->pfnProgress;
2675	pvUser = pIfProgress->Core.pvUser;
2676	}
2677
2678	/* Making the image smaller is not supported at the moment. */
2679	if ( cbSize < pImage->cbSize
2680	\|\| pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2681	rc = VERR_NOT_SUPPORTED;
2682	else if (cbSize > pImage->cbSize)
2683	{
2684	unsigned cBlocksAllocated = 0;
2685	size_t cbBlock = pImage->cbDataBlock + pImage->cbDataBlockBitmap; /** < Size of a block including the sector bitmap. */
2686	uint32_t cBlocksNew = cbSize / pImage->cbDataBlock; /** < New number of blocks in the image after the resize */
2687	if (cbSize % pImage->cbDataBlock)
2688	cBlocksNew++;
2689
2690	uint32_t cBlocksOld = pImage->cBlockAllocationTableEntries; /** < Number of blocks before the resize. */
2691	uint64_t cbBlockspaceNew = RT_ALIGN_32(cBlocksNew * sizeof(uint32_t), VHD_SECTOR_SIZE); /** < Required space for the block array after the resize. */
2692	uint64_t offStartDataNew = RT_ALIGN_32(pImage->uBlockAllocationTableOffset + cbBlockspaceNew, VHD_SECTOR_SIZE); /** < New start offset for block data after the resize */
2693	uint64_t offStartDataOld = ~0ULL;
2694
2695	/* Go through the BAT and find the data start offset. */
2696	for (unsigned idxBlock = 0; idxBlock < pImage->cBlockAllocationTableEntries; idxBlock++)
2697	{
2698	if (pImage->pBlockAllocationTable[idxBlock] != ~0U)
2699	{
2700	uint64_t offStartBlock = pImage->pBlockAllocationTable[idxBlock] * VHD_SECTOR_SIZE;
2701	if (offStartBlock < offStartDataOld)
2702	offStartDataOld = offStartBlock;
2703	cBlocksAllocated++;
2704	}
2705	}
2706
2707	if ( offStartDataOld != offStartDataNew
2708	&& cBlocksAllocated > 0)
2709	{
2710	/* Calculate how many sectors nee to be relocated. */
2711	uint64_t cbOverlapping = offStartDataNew - offStartDataOld;
2712	unsigned cBlocksReloc = (unsigned)(cbOverlapping / cbBlock);
2713	if (cbOverlapping % cbBlock)
2714	cBlocksReloc++;
2715
2716	cBlocksReloc = RT_MIN(cBlocksReloc, cBlocksAllocated);
2717	offStartDataNew = offStartDataOld;
2718
2719	/* Do the relocation. */
2720	LogFlow(("Relocating %u blocks\n", cBlocksReloc));
2721
2722	/*
2723	* Get the blocks we need to relocate first, they are appended to the end
2724	* of the image.
2725	*/
2726	void pvBuf = NULL, pvZero = NULL;
2727	do
2728	{
2729	/* Allocate data buffer. */
2730	pvBuf = RTMemAllocZ(cbBlock);
2731	if (!pvBuf)
2732	{
2733	rc = VERR_NO_MEMORY;
2734	break;
2735	}
2736
2737	/* Allocate buffer for overwriting with zeroes. */
2738	pvZero = RTMemAllocZ(cbBlock);
2739	if (!pvZero)
2740	{
2741	rc = VERR_NO_MEMORY;
2742	break;
2743	}
2744
2745	for (unsigned i = 0; i < cBlocksReloc; i++)
2746	{
2747	uint32_t uBlock = offStartDataNew / VHD_SECTOR_SIZE;
2748
2749	/* Search the index in the block table. */
2750	for (unsigned idxBlock = 0; idxBlock < cBlocksOld; idxBlock++)
2751	{
2752	if (pImage->pBlockAllocationTable[idxBlock] == uBlock)
2753	{
2754	/* Read data and append to the end of the image. */
2755	rc = vdIfIoIntFileReadSync(pImage->pIfIo, pImage->pStorage,
2756	offStartDataNew, pvBuf, cbBlock);
2757	if (RT_FAILURE(rc))
2758	break;
2759
2760	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2761	pImage->uCurrentEndOfFile, pvBuf, cbBlock);
2762	if (RT_FAILURE(rc))
2763	break;
2764
2765	/* Zero out the old block area. */
2766	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2767	offStartDataNew, pvZero, cbBlock);
2768	if (RT_FAILURE(rc))
2769	break;
2770
2771	/* Update block counter. */
2772	pImage->pBlockAllocationTable[idxBlock] = pImage->uCurrentEndOfFile / VHD_SECTOR_SIZE;
2773
2774	pImage->uCurrentEndOfFile += cbBlock;
2775
2776	/* Continue with the next block. */
2777	break;
2778	}
2779	}
2780
2781	if (RT_FAILURE(rc))
2782	break;
2783
2784	offStartDataNew += cbBlock;
2785	}
2786	} while (0);
2787
2788	if (pvBuf)
2789	RTMemFree(pvBuf);
2790	if (pvZero)
2791	RTMemFree(pvZero);
2792	}
2793
2794	/*
2795	* Relocation done, expand the block array and update the header with
2796	* the new data.
2797	*/
2798	if (RT_SUCCESS(rc))
2799	{
2800	uint32_t paBlocksNew = (uint32_t )RTMemRealloc(pImage->pBlockAllocationTable, cBlocksNew * sizeof(uint32_t));
2801	if (paBlocksNew)
2802	{
2803	pImage->pBlockAllocationTable = paBlocksNew;
2804
2805	/* Mark the new blocks as unallocated. */
2806	for (unsigned idxBlock = cBlocksOld; idxBlock < cBlocksNew; idxBlock++)
2807	pImage->pBlockAllocationTable[idxBlock] = ~0U;
2808	}
2809	else
2810	rc = VERR_NO_MEMORY;
2811
2812	if (RT_SUCCESS(rc))
2813	{
2814	/* Write the block array before updating the rest. */
2815	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
2816	pImage->uBlockAllocationTableOffset,
2817	pImage->pBlockAllocationTable,
2818	cBlocksNew * sizeof(uint32_t));
2819	}
2820
2821	if (RT_SUCCESS(rc))
2822	{
2823	/* Update size and new block count. */
2824	pImage->cBlockAllocationTableEntries = cBlocksNew;
2825	pImage->cbSize = cbSize;
2826
2827	/* Update geometry. */
2828	pImage->PCHSGeometry = *pPCHSGeometry;
2829	pImage->LCHSGeometry = *pLCHSGeometry;
2830	}
2831	}
2832
2833	/* Update header information in base image file. */
2834	pImage->fDynHdrNeedsUpdate = true;
2835	vhdFlushImage(pImage);
2836	}
2837	/* Same size doesn't change the image at all. */
2838
2839	LogFlowFunc(("returns %Rrc\n", rc));
2840	return rc;
2841	}
2842
2843	/** @copydoc VBOXHDDBACKEND::pfnRepair */
2844	static DECLCALLBACK(int) vhdRepair(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
2845	PVDINTERFACE pVDIfsImage, uint32_t fFlags)
2846	{
2847	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
2848	int rc;
2849	PVDINTERFACEERROR pIfError;
2850	PVDINTERFACEIOINT pIfIo;
2851	PVDIOSTORAGE pStorage;
2852	uint64_t cbFile;
2853	VHDFooter vhdFooter;
2854	VHDDynamicDiskHeader dynamicDiskHeader;
2855	uint32_t *paBat = NULL;
2856	uint32_t *pu32BlockBitmap = NULL;
2857
2858	pIfIo = VDIfIoIntGet(pVDIfsImage);
2859	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
2860
2861	pIfError = VDIfErrorGet(pVDIfsDisk);
2862
2863	do
2864	{
2865	uint64_t offDynamicDiskHeader = 0;
2866	uint64_t offBat = 0;
2867	uint64_t offFooter = 0;
2868	uint32_t cBatEntries = 0;
2869	bool fDynamic = false;
2870	bool fRepairFooter = false;
2871	bool fRepairBat = false;
2872	bool fRepairDynHeader = false;
2873
2874	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
2875	VDOpenFlagsToFileOpenFlags( fFlags & VD_REPAIR_DRY_RUN
2876	? VD_OPEN_FLAGS_READONLY
2877	: 0,
2878	false /* fCreate */),
2879	&pStorage);
2880	if (RT_FAILURE(rc))
2881	{
2882	rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to open image \"%s\"", pszFilename);
2883	break;
2884	}
2885
2886	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
2887	if (RT_FAILURE(rc))
2888	{
2889	rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to query image size");
2890	break;
2891	}
2892
2893	if (cbFile < sizeof(VHDFooter))
2894	{
2895	rc = vdIfError(pIfError, VERR_VD_INVALID_SIZE, RT_SRC_POS,
2896	"Image must be at least %u bytes (got %llu)",
2897	sizeof(VHDFooter), cbFile);
2898	break;
2899	}
2900
2901	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, cbFile - sizeof(VHDFooter),
2902	&vhdFooter, sizeof(VHDFooter));
2903	if (RT_FAILURE(rc))
2904	{
2905	rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to read footer of image");
2906	break;
2907	}
2908
2909	if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
2910	{
2911	/* Dynamic images have a backup at the beginning of the image. */
2912	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0,
2913	&vhdFooter, sizeof(VHDFooter));
2914	if (RT_FAILURE(rc))
2915	{
2916	rc = vdIfError(pIfError, rc, RT_SRC_POS, "Failed to read header of image");
2917	break;
2918	}
2919
2920	/*
2921	* Check for the header, if this fails the image is either completely corrupted
2922	* and impossible to repair or in another format.
2923	*/
2924	if (memcmp(vhdFooter.Cookie, VHD_FOOTER_COOKIE, VHD_FOOTER_COOKIE_SIZE) != 0)
2925	{
2926	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2927	"No valid VHD structures found");
2928	break;
2929	}
2930	else
2931	vdIfErrorMessage(pIfError, "Missing footer structure, using backup\n");
2932
2933	/* Remember to fix the footer structure. */
2934	fRepairFooter = true;
2935	}
2936
2937	offFooter = cbFile - sizeof(VHDFooter);
2938
2939	/* Verify that checksums match. */
2940	uint32_t u32ChkSumOld = RT_BE2H_U32(vhdFooter.Checksum);
2941	vhdFooter.Checksum = 0;
2942	uint32_t u32ChkSum = vhdChecksum(&vhdFooter, sizeof(VHDFooter));
2943
2944	vhdFooter.Checksum = RT_H2BE_U32(u32ChkSum);
2945
2946	if (u32ChkSumOld != u32ChkSum)
2947	{
2948	vdIfErrorMessage(pIfError, "Checksum is invalid (should be %u got %u), repairing\n",
2949	u32ChkSum, u32ChkSumOld);
2950	fRepairFooter = true;
2951	break;
2952	}
2953
2954	switch (RT_BE2H_U32(vhdFooter.DiskType))
2955	{
2956	case VHD_FOOTER_DISK_TYPE_FIXED:
2957	fDynamic = false;
2958	break;
2959	case VHD_FOOTER_DISK_TYPE_DYNAMIC:
2960	fDynamic = true;
2961	break;
2962	case VHD_FOOTER_DISK_TYPE_DIFFERENCING:
2963	fDynamic = true;
2964	break;
2965	default:
2966	{
2967	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2968	"VHD image type %u is not supported",
2969	RT_BE2H_U32(vhdFooter.DiskType));
2970	break;
2971	}
2972	}
2973
2974	/* Load and check dynamic disk header if required. */
2975	if (fDynamic)
2976	{
2977	size_t cbBlock;
2978
2979	offDynamicDiskHeader = RT_BE2H_U64(vhdFooter.DataOffset);
2980	if (offDynamicDiskHeader + sizeof(VHDDynamicDiskHeader) > cbFile)
2981	{
2982	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2983	"VHD image type is not supported");
2984	break;
2985	}
2986
2987	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offDynamicDiskHeader,
2988	&dynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
2989	if (RT_FAILURE(rc))
2990	{
2991	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
2992	"Failed to read dynamic disk header (at %llu), %Rrc",
2993	offDynamicDiskHeader, rc);
2994	break;
2995	}
2996
2997	/* Verify that checksums match. */
2998	u32ChkSumOld = RT_BE2H_U32(dynamicDiskHeader.Checksum);
2999	dynamicDiskHeader.Checksum = 0;
3000	u32ChkSum = vhdChecksum(&dynamicDiskHeader, sizeof(VHDDynamicDiskHeader));
3001
3002	dynamicDiskHeader.Checksum = RT_H2BE_U32(u32ChkSum);
3003
3004	if (u32ChkSumOld != u32ChkSum)
3005	{
3006	vdIfErrorMessage(pIfError, "Checksum of dynamic disk header is invalid (should be %u got %u), repairing\n",
3007	u32ChkSum, u32ChkSumOld);
3008	fRepairDynHeader = true;
3009	break;
3010	}
3011
3012	/* Read the block allocation table and fix any inconsistencies. */
3013	offBat = RT_BE2H_U64(dynamicDiskHeader.TableOffset);
3014	cBatEntries = RT_BE2H_U32(dynamicDiskHeader.MaxTableEntries);
3015	cbBlock = RT_BE2H_U32(dynamicDiskHeader.BlockSize);
3016	cbBlock += cbBlock / VHD_SECTOR_SIZE / 8;
3017
3018	if (offBat + cBatEntries * sizeof(uint32_t) > cbFile)
3019	{
3020	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3021	"Block allocation table is not inside the image");
3022	break;
3023	}
3024
3025	paBat = (uint32_t )RTMemAllocZ(cBatEntries sizeof(uint32_t));
3026	if (!paBat)
3027	{
3028	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3029	"Could not allocate memory for the block allocation table (%u bytes)",
3030	cBatEntries * sizeof(uint32_t));
3031	break;
3032	}
3033
3034	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offBat, paBat,
3035	cBatEntries * sizeof(uint32_t));
3036	if (RT_FAILURE(rc))
3037	{
3038	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3039	"Could not read block allocation table (at %llu), %Rrc",
3040	offBat, rc);
3041	break;
3042	}
3043
3044	pu32BlockBitmap = (uint32_t *)RTMemAllocZ(RT_ALIGN_Z(cBatEntries / 8, 4));
3045	if (!pu32BlockBitmap)
3046	{
3047	rc = vdIfError(pIfError, VERR_NO_MEMORY, RT_SRC_POS,
3048	"Failed to allocate memory for block bitmap");
3049	break;
3050	}
3051
3052	uint32_t idxMinBlock = UINT32_C(0xffffffff);
3053	for (uint32_t i = 0; i < cBatEntries; i++)
3054	{
3055	paBat[i] = RT_BE2H_U32(paBat[i]);
3056	if (paBat[i] < idxMinBlock)
3057	idxMinBlock = paBat[i];
3058	}
3059
3060	vdIfErrorMessage(pIfError, "First data block at sector %u\n", idxMinBlock);
3061
3062	for (uint32_t i = 0; i < cBatEntries; i++)
3063	{
3064	if (paBat[i] != UINT32_C(0xffffffff))
3065	{
3066	uint64_t offBlock =(uint64_t)paBat[i] * VHD_SECTOR_SIZE;
3067
3068	/*
3069	* Check that the offsets are valid (inside of the image) and
3070	* that there are no double references.
3071	*/
3072	if (offBlock + cbBlock > cbFile)
3073	{
3074	vdIfErrorMessage(pIfError, "Entry %u points to invalid offset %llu, clearing\n",
3075	i, offBlock);
3076	paBat[i] = UINT32_C(0xffffffff);
3077	fRepairBat = true;
3078	}
3079	else if (offBlock + cbBlock > offFooter)
3080	{
3081	vdIfErrorMessage(pIfError, "Entry %u intersects with footer, aligning footer\n",
3082	i);
3083	offFooter = offBlock + cbBlock;
3084	fRepairBat = true;
3085	}
3086
3087	if ( paBat[i] != UINT32_C(0xffffffff)
3088	&& ASMBitTestAndSet(pu32BlockBitmap, (uint32_t)((paBat[i] - idxMinBlock) / (cbBlock / VHD_SECTOR_SIZE))))
3089	{
3090	vdIfErrorMessage(pIfError, "Entry %u points to an already referenced data block, clearing\n",
3091	i);
3092	paBat[i] = UINT32_C(0xffffffff);
3093	fRepairBat = true;
3094	}
3095	}
3096	}
3097	}
3098
3099	/* Write repaired structures now. */
3100	if (!(fRepairBat \|\| fRepairDynHeader \|\| fRepairFooter))
3101	vdIfErrorMessage(pIfError, "VHD image is in a consistent state, no repair required\n");
3102	else if (!(fFlags & VD_REPAIR_DRY_RUN))
3103	{
3104	if (fRepairBat)
3105	{
3106	for (uint32_t i = 0; i < cBatEntries; i++)
3107	paBat[i] = RT_H2BE_U32(paBat[i]);
3108
3109	vdIfErrorMessage(pIfError, "Writing repaired block allocation table...\n");
3110
3111	rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offBat, paBat,
3112	cBatEntries * sizeof(uint32_t));
3113	if (RT_FAILURE(rc))
3114	{
3115	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3116	"Could not write repaired block allocation table (at %llu), %Rrc",
3117	offBat, rc);
3118	break;
3119	}
3120	}
3121
3122	if (fRepairDynHeader)
3123	{
3124	Assert(fDynamic);
3125
3126	vdIfErrorMessage(pIfError, "Writing repaired dynamic disk header...\n");
3127	rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offDynamicDiskHeader, &dynamicDiskHeader,
3128	sizeof(VHDDynamicDiskHeader));
3129	if (RT_FAILURE(rc))
3130	{
3131	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3132	"Could not write repaired dynamic disk header (at %llu), %Rrc",
3133	offDynamicDiskHeader, rc);
3134	break;
3135	}
3136	}
3137
3138	if (fRepairFooter)
3139	{
3140	vdIfErrorMessage(pIfError, "Writing repaired Footer...\n");
3141
3142	if (fDynamic)
3143	{
3144	/* Write backup at image beginning. */
3145	rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, 0, &vhdFooter,
3146	sizeof(VHDFooter));
3147	if (RT_FAILURE(rc))
3148	{
3149	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3150	"Could not write repaired backup footer (at %llu), %Rrc",
3151	0, rc);
3152	break;
3153	}
3154	}
3155
3156	rc = vdIfIoIntFileWriteSync(pIfIo, pStorage, offFooter, &vhdFooter,
3157	sizeof(VHDFooter));
3158	if (RT_FAILURE(rc))
3159	{
3160	rc = vdIfError(pIfError, VERR_VD_IMAGE_REPAIR_IMPOSSIBLE, RT_SRC_POS,
3161	"Could not write repaired footer (at %llu), %Rrc",
3162	cbFile - sizeof(VHDFooter), rc);
3163	break;
3164	}
3165	}
3166
3167	vdIfErrorMessage(pIfError, "Corrupted VHD image repaired successfully\n");
3168	}
3169	} while(0);
3170
3171	if (paBat)
3172	RTMemFree(paBat);
3173
3174	if (pu32BlockBitmap)
3175	RTMemFree(pu32BlockBitmap);
3176
3177	if (pStorage)
3178	{
3179	int rc2 = vdIfIoIntFileClose(pIfIo, pStorage);
3180	if (RT_SUCCESS(rc))
3181	rc = rc2; /* Propagate status code only when repairing the image was successful. */
3182	}
3183
3184	LogFlowFunc(("returns %Rrc\n", rc));
3185	return rc;
3186	}
3187
3188
3189	VBOXHDDBACKEND g_VhdBackend =
3190	{
3191	/* pszBackendName */
3192	"VHD",
3193	/* cbSize */
3194	sizeof(VBOXHDDBACKEND),
3195	/* uBackendCaps */
3196	VD_CAP_UUID \| VD_CAP_DIFF \| VD_CAP_FILE \|
3197	VD_CAP_CREATE_FIXED \| VD_CAP_CREATE_DYNAMIC \|
3198	VD_CAP_ASYNC \| VD_CAP_VFS,
3199	/* paFileExtensions */
3200	s_aVhdFileExtensions,
3201	/* paConfigInfo */
3202	NULL,
3203	/* hPlugin */
3204	NIL_RTLDRMOD,
3205	/* pfnCheckIfValid */
3206	vhdCheckIfValid,
3207	/* pfnOpen */
3208	vhdOpen,
3209	/* pfnCreate */
3210	vhdCreate,
3211	/* pfnRename */
3212	vhdRename,
3213	/* pfnClose */
3214	vhdClose,
3215	/* pfnRead */
3216	vhdRead,
3217	/* pfnWrite */
3218	vhdWrite,
3219	/* pfnFlush */
3220	vhdFlush,
3221	/* pfnDiscard */
3222	NULL,
3223	/* pfnGetVersion */
3224	vhdGetVersion,
3225	/* pfnGetSectorSize */
3226	vhdGetSectorSize,
3227	/* pfnGetSize */
3228	vhdGetSize,
3229	/* pfnGetFileSize */
3230	vhdGetFileSize,
3231	/* pfnGetPCHSGeometry */
3232	vhdGetPCHSGeometry,
3233	/* pfnSetPCHSGeometry */
3234	vhdSetPCHSGeometry,
3235	/* pfnGetLCHSGeometry */
3236	vhdGetLCHSGeometry,
3237	/* pfnSetLCHSGeometry */
3238	vhdSetLCHSGeometry,
3239	/* pfnGetImageFlags */
3240	vhdGetImageFlags,
3241	/* pfnGetOpenFlags */
3242	vhdGetOpenFlags,
3243	/* pfnSetOpenFlags */
3244	vhdSetOpenFlags,
3245	/* pfnGetComment */
3246	vhdGetComment,
3247	/* pfnSetComment */
3248	vhdSetComment,
3249	/* pfnGetUuid */
3250	vhdGetUuid,
3251	/* pfnSetUuid */
3252	vhdSetUuid,
3253	/* pfnGetModificationUuid */
3254	vhdGetModificationUuid,
3255	/* pfnSetModificationUuid */
3256	vhdSetModificationUuid,
3257	/* pfnGetParentUuid */
3258	vhdGetParentUuid,
3259	/* pfnSetParentUuid */
3260	vhdSetParentUuid,
3261	/* pfnGetParentModificationUuid */
3262	vhdGetParentModificationUuid,
3263	/* pfnSetParentModificationUuid */
3264	vhdSetParentModificationUuid,
3265	/* pfnDump */
3266	vhdDump,
3267	/* pfnGetTimeStamp */
3268	vhdGetTimeStamp,
3269	/* pfnGetParentTimeStamp */
3270	vhdGetParentTimeStamp,
3271	/* pfnSetParentTimeStamp */
3272	vhdSetParentTimeStamp,
3273	/* pfnGetParentFilename */
3274	vhdGetParentFilename,
3275	/* pfnSetParentFilename */
3276	vhdSetParentFilename,
3277	/* pfnComposeLocation */
3278	genericFileComposeLocation,
3279	/* pfnComposeName */
3280	genericFileComposeName,
3281	/* pfnCompact */
3282	vhdCompact,
3283	/* pfnResize */
3284	vhdResize,
3285	/* pfnRepair */
3286	vhdRepair
3287	};

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

source: vbox/trunk/src/VBox/Storage/VHD.cpp@ 49439

Download in other formats: