VHD.cpp@ 49971

Last change on this file since 49971 was 49944, checked in by vboxsync, 11 years ago
Storage,VHD: Fix I/O if VD_OPEN_FLAGS_HONOR_SAME is used
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 115.7 KB

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

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

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

Download in other formats: