VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Last change on this file since 67981 was 66486, checked in by vboxsync, 7 years ago
Storage/VD: Convert all backends to use the region list callbacks, remove the pfnGetSize and pfnGetSectorSize callbacks because they are covered by the region lists
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 118.0 KB

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

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use