VDI.cpp@ 33567

Last change on this file since 33567 was 33567, checked in by vboxsync, 14 years ago
VD: Move the generic virtual disk framework + backends to src/VBox/Storage and rename the files to get rid of the HDD part because it supports floppy and DVD images too
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 95.5 KB

Line
1	/** @file
2	* Virtual Disk Image (VDI), Core Code.
3	*/
4
5	/*
6	* Copyright (C) 2006-2010 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*/
16
17	/*******************************************************************************
18	* Header Files *
19	*******************************************************************************/
20	#define LOG_GROUP LOG_GROUP_VD_VDI
21	#include <VBox/vd-plugin.h>
22	#define VBOX_VDICORE_VD /* Signal that the header is included from here. */
23	#include "VDICore.h"
24	#include <VBox/err.h>
25
26	#include <VBox/log.h>
27	#include <iprt/alloc.h>
28	#include <iprt/assert.h>
29	#include <iprt/uuid.h>
30	#include <iprt/string.h>
31	#include <iprt/asm.h>
32
33	#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
34
35	/*******************************************************************************
36	* Static Variables *
37	*******************************************************************************/
38
39	/** NULL-terminated array of supported file extensions. */
40	static const VDFILEEXTENSION s_aVdiFileExtensions[] =
41	{
42	{"vdi", VDTYPE_HDD},
43	{NULL, VDTYPE_INVALID}
44	};
45
46	/*******************************************************************************
47	* Internal Functions *
48	*******************************************************************************/
49	static unsigned getPowerOfTwo(unsigned uNumber);
50	static void vdiInitPreHeader(PVDIPREHEADER pPreHdr);
51	static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr);
52	static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
53	const char *pszComment, uint64_t cbDisk,
54	uint32_t cbBlock, uint32_t cbBlockExtra);
55	static int vdiValidateHeader(PVDIHEADER pHeader);
56	static void vdiSetupImageDesc(PVDIIMAGEDESC pImage);
57	static int vdiUpdateHeader(PVDIIMAGEDESC pImage);
58	static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock);
59	static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx);
60	static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock, PVDIOCTX pIoCtx);
61
62	/**
63	* Internal: signal an error to the frontend.
64	*/
65	DECLINLINE(int) vdiError(PVDIIMAGEDESC pImage, int rc, RT_SRC_POS_DECL,
66	const char *pszFormat, ...)
67	{
68	va_list va;
69	va_start(va, pszFormat);
70	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
71	pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser,
72	rc, RT_SRC_POS_ARGS,
73	pszFormat, va);
74	va_end(va);
75	return rc;
76	}
77
78	/**
79	* Internal: signal an informational message to the frontend.
80	*/
81	DECLINLINE(int) vdiMessage(PVDIIMAGEDESC pImage, const char *pszFormat, ...)
82	{
83	int rc = VINF_SUCCESS;
84	va_list va;
85	va_start(va, pszFormat);
86	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
87	rc = pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser,
88	pszFormat, va);
89	va_end(va);
90	return rc;
91	}
92
93
94	DECLINLINE(int) vdiFileOpen(PVDIIMAGEDESC pImage, const char *pszFilename,
95	uint32_t fOpen)
96	{
97	return pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
98	pszFilename, fOpen,
99	&pImage->pStorage);
100	}
101
102	DECLINLINE(int) vdiFileClose(PVDIIMAGEDESC pImage)
103	{
104	return pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
105	pImage->pStorage);
106	}
107
108	DECLINLINE(int) vdiFileDelete(PVDIIMAGEDESC pImage, const char *pszFilename)
109	{
110	return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
111	pszFilename);
112	}
113
114	DECLINLINE(int) vdiFileMove(PVDIIMAGEDESC pImage, const char *pszSrc,
115	const char *pszDst, unsigned fMove)
116	{
117	return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
118	pszSrc, pszDst, fMove);
119	}
120
121	DECLINLINE(int) vdiFileGetFreeSpace(PVDIIMAGEDESC pImage, const char *pszFilename,
122	int64_t *pcbFree)
123	{
124	return pImage->pInterfaceIOCallbacks->pfnGetFreeSpace(pImage->pInterfaceIO->pvUser,
125	pszFilename, pcbFree);
126	}
127
128	DECLINLINE(int) vdiFileGetSize(PVDIIMAGEDESC pImage, uint64_t *pcbSize)
129	{
130	return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
131	pImage->pStorage, pcbSize);
132	}
133
134	DECLINLINE(int) vdiFileSetSize(PVDIIMAGEDESC pImage, uint64_t cbSize)
135	{
136	return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
137	pImage->pStorage, cbSize);
138	}
139
140	DECLINLINE(int) vdiFileWriteSync(PVDIIMAGEDESC pImage, uint64_t uOffset,
141	const void *pvBuffer, size_t cbBuffer,
142	size_t *pcbWritten)
143	{
144	return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
145	pImage->pStorage, uOffset,
146	pvBuffer, cbBuffer, pcbWritten);
147	}
148
149	DECLINLINE(int) vdiFileReadSync(PVDIIMAGEDESC pImage, uint64_t uOffset,
150	void pvBuffer, size_t cbBuffer, size_t pcbRead)
151	{
152	return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
153	pImage->pStorage, uOffset,
154	pvBuffer, cbBuffer, pcbRead);
155	}
156
157	DECLINLINE(int) vdiFileFlushSync(PVDIIMAGEDESC pImage)
158	{
159	return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
160	pImage->pStorage);
161	}
162
163	DECLINLINE(int) vdiFileReadUserAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
164	PVDIOCTX pIoCtx, size_t cbRead)
165	{
166	return pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
167	pImage->pStorage,
168	uOffset, pIoCtx,
169	cbRead);
170	}
171
172	DECLINLINE(int) vdiFileWriteUserAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
173	PVDIOCTX pIoCtx, size_t cbWrite,
174	PFNVDXFERCOMPLETED pfnComplete,
175	void *pvCompleteUser)
176	{
177	return pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
178	pImage->pStorage,
179	uOffset, pIoCtx,
180	cbWrite,
181	pfnComplete,
182	pvCompleteUser);
183	}
184
185	DECLINLINE(int) vdiFileWriteMetaAsync(PVDIIMAGEDESC pImage, uint64_t uOffset,
186	void *pvBuffer, size_t cbBuffer,
187	PVDIOCTX pIoCtx,
188	PFNVDXFERCOMPLETED pfnComplete,
189	void *pvCompleteUser)
190	{
191	return pImage->pInterfaceIOCallbacks->pfnWriteMetaAsync(pImage->pInterfaceIO->pvUser,
192	pImage->pStorage,
193	uOffset, pvBuffer,
194	cbBuffer, pIoCtx,
195	pfnComplete,
196	pvCompleteUser);
197	}
198
199	DECLINLINE(int) vdiFileFlushAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
200	PFNVDXFERCOMPLETED pfnComplete,
201	void *pvCompleteUser)
202	{
203	return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
204	pImage->pStorage,
205	pIoCtx, pfnComplete,
206	pvCompleteUser);
207	}
208
209	DECLINLINE(size_t) vdiFileIoCtxSet(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx,
210	int ch, size_t cbSet)
211	{
212	return pImage->pInterfaceIOCallbacks->pfnIoCtxSet(pImage->pInterfaceIO->pvUser,
213	pIoCtx, ch, cbSet);
214	}
215
216
217	/**
218	* Internal: Flush the image file to disk.
219	*/
220	static void vdiFlushImage(PVDIIMAGEDESC pImage)
221	{
222	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
223	{
224	/* Save header. */
225	int rc = vdiUpdateHeader(pImage);
226	AssertMsgRC(rc, ("vdiUpdateHeader() failed, filename=\"%s\", rc=%Rrc\n",
227	pImage->pszFilename, rc));
228	vdiFileFlushSync(pImage);
229	}
230	}
231
232	/**
233	* Internal: Free all allocated space for representing an image, and optionally
234	* delete the image from disk.
235	*/
236	static int vdiFreeImage(PVDIIMAGEDESC pImage, bool fDelete)
237	{
238	int rc = VINF_SUCCESS;
239
240	/* Freeing a never allocated image (e.g. because the open failed) is
241	* not signalled as an error. After all nothing bad happens. */
242	if (pImage)
243	{
244	if (pImage->pStorage)
245	{
246	/* No point updating the file that is deleted anyway. */
247	if (!fDelete)
248	vdiFlushImage(pImage);
249
250	vdiFileClose(pImage);
251	pImage->pStorage = NULL;
252	}
253
254	if (pImage->paBlocks)
255	{
256	RTMemFree(pImage->paBlocks);
257	pImage->paBlocks = NULL;
258	}
259
260	if (fDelete && pImage->pszFilename)
261	vdiFileDelete(pImage, pImage->pszFilename);
262	}
263
264	LogFlowFunc(("returns %Rrc\n", rc));
265	return rc;
266	}
267
268	/**
269	* internal: return power of 2 or 0 if num error.
270	*/
271	static unsigned getPowerOfTwo(unsigned uNumber)
272	{
273	if (uNumber == 0)
274	return 0;
275	unsigned uPower2 = 0;
276	while ((uNumber & 1) == 0)
277	{
278	uNumber >>= 1;
279	uPower2++;
280	}
281	return uNumber == 1 ? uPower2 : 0;
282	}
283
284	/**
285	* Internal: Init VDI preheader.
286	*/
287	static void vdiInitPreHeader(PVDIPREHEADER pPreHdr)
288	{
289	pPreHdr->u32Signature = VDI_IMAGE_SIGNATURE;
290	pPreHdr->u32Version = VDI_IMAGE_VERSION;
291	memset(pPreHdr->szFileInfo, 0, sizeof(pPreHdr->szFileInfo));
292	strncat(pPreHdr->szFileInfo, VDI_IMAGE_FILE_INFO, sizeof(pPreHdr->szFileInfo)-1);
293	}
294
295	/**
296	* Internal: check VDI preheader.
297	*/
298	static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr)
299	{
300	if (pPreHdr->u32Signature != VDI_IMAGE_SIGNATURE)
301	return VERR_VD_VDI_INVALID_HEADER;
302
303	if ( VDI_GET_VERSION_MAJOR(pPreHdr->u32Version) != VDI_IMAGE_VERSION_MAJOR
304	&& pPreHdr->u32Version != 0x00000002) /* old version. */
305	return VERR_VD_VDI_UNSUPPORTED_VERSION;
306
307	return VINF_SUCCESS;
308	}
309
310	/**
311	* Internal: translate VD image flags to VDI image type enum.
312	*/
313	static VDIIMAGETYPE vdiTranslateImageFlags2VDI(unsigned uImageFlags)
314	{
315	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
316	return VDI_IMAGE_TYPE_FIXED;
317	else if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
318	return VDI_IMAGE_TYPE_DIFF;
319	else
320	return VDI_IMAGE_TYPE_NORMAL;
321	}
322
323	/**
324	* Internal: translate VDI image type enum to VD image type enum.
325	*/
326	static unsigned vdiTranslateVDI2ImageFlags(VDIIMAGETYPE enmType)
327	{
328	switch (enmType)
329	{
330	case VDI_IMAGE_TYPE_NORMAL:
331	return VD_IMAGE_FLAGS_NONE;
332	case VDI_IMAGE_TYPE_FIXED:
333	return VD_IMAGE_FLAGS_FIXED;
334	case VDI_IMAGE_TYPE_DIFF:
335	return VD_IMAGE_FLAGS_DIFF;
336	default:
337	AssertMsgFailed(("invalid VDIIMAGETYPE enmType=%d\n", (int)enmType));
338	return VD_IMAGE_FLAGS_NONE;
339	}
340	}
341
342	/**
343	* Internal: Init VDI header. Always use latest header version.
344	* @param pHeader Assumes it was initially initialized to all zeros.
345	*/
346	static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
347	const char *pszComment, uint64_t cbDisk,
348	uint32_t cbBlock, uint32_t cbBlockExtra)
349	{
350	pHeader->uVersion = VDI_IMAGE_VERSION;
351	pHeader->u.v1plus.cbHeader = sizeof(VDIHEADER1PLUS);
352	pHeader->u.v1plus.u32Type = (uint32_t)vdiTranslateImageFlags2VDI(uImageFlags);
353	pHeader->u.v1plus.fFlags = (uImageFlags & VD_VDI_IMAGE_FLAGS_ZERO_EXPAND) ? 1 : 0;
354	#ifdef VBOX_STRICT
355	char achZero[VDI_IMAGE_COMMENT_SIZE] = {0};
356	Assert(!memcmp(pHeader->u.v1plus.szComment, achZero, VDI_IMAGE_COMMENT_SIZE));
357	#endif
358	pHeader->u.v1plus.szComment[0] = '\0';
359	if (pszComment)
360	{
361	AssertMsg(strlen(pszComment) < sizeof(pHeader->u.v1plus.szComment),
362	("HDD Comment is too long, cb=%d\n", strlen(pszComment)));
363	strncat(pHeader->u.v1plus.szComment, pszComment, sizeof(pHeader->u.v1plus.szComment)-1);
364	}
365
366	/* Mark the legacy geometry not-calculated. */
367	pHeader->u.v1plus.LegacyGeometry.cCylinders = 0;
368	pHeader->u.v1plus.LegacyGeometry.cHeads = 0;
369	pHeader->u.v1plus.LegacyGeometry.cSectors = 0;
370	pHeader->u.v1plus.LegacyGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
371	pHeader->u.v1plus.u32Dummy = 0; /* used to be the translation value */
372
373	pHeader->u.v1plus.cbDisk = cbDisk;
374	pHeader->u.v1plus.cbBlock = cbBlock;
375	pHeader->u.v1plus.cBlocks = (uint32_t)(cbDisk / cbBlock);
376	if (cbDisk % cbBlock)
377	pHeader->u.v1plus.cBlocks++;
378	pHeader->u.v1plus.cbBlockExtra = cbBlockExtra;
379	pHeader->u.v1plus.cBlocksAllocated = 0;
380
381	/* Init offsets. */
382	pHeader->u.v1plus.offBlocks = RT_ALIGN_32(sizeof(VDIPREHEADER) + sizeof(VDIHEADER1PLUS), VDI_DATA_ALIGN);
383	pHeader->u.v1plus.offData = RT_ALIGN_32(pHeader->u.v1plus.offBlocks + (pHeader->u.v1plus.cBlocks * sizeof(VDIIMAGEBLOCKPOINTER)), VDI_DATA_ALIGN);
384
385	/* Init uuids. */
386	RTUuidCreate(&pHeader->u.v1plus.uuidCreate);
387	RTUuidClear(&pHeader->u.v1plus.uuidModify);
388	RTUuidClear(&pHeader->u.v1plus.uuidLinkage);
389	RTUuidClear(&pHeader->u.v1plus.uuidParentModify);
390
391	/* Mark LCHS geometry not-calculated. */
392	pHeader->u.v1plus.LCHSGeometry.cCylinders = 0;
393	pHeader->u.v1plus.LCHSGeometry.cHeads = 0;
394	pHeader->u.v1plus.LCHSGeometry.cSectors = 0;
395	pHeader->u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
396	}
397
398	/**
399	* Internal: Check VDI header.
400	*/
401	static int vdiValidateHeader(PVDIHEADER pHeader)
402	{
403	/* Check version-dependent header parameters. */
404	switch (GET_MAJOR_HEADER_VERSION(pHeader))
405	{
406	case 0:
407	{
408	/* Old header version. */
409	break;
410	}
411	case 1:
412	{
413	/* Current header version. */
414
415	if (pHeader->u.v1.cbHeader < sizeof(VDIHEADER1))
416	{
417	LogRel(("VDI: v1 header size wrong (%d < %d)\n",
418	pHeader->u.v1.cbHeader, sizeof(VDIHEADER1)));
419	return VERR_VD_VDI_INVALID_HEADER;
420	}
421
422	if (getImageBlocksOffset(pHeader) < (sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)))
423	{
424	LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
425	getImageBlocksOffset(pHeader), sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)));
426	return VERR_VD_VDI_INVALID_HEADER;
427	}
428
429	if (getImageDataOffset(pHeader) < (getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)))
430	{
431	LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
432	getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
433	return VERR_VD_VDI_INVALID_HEADER;
434	}
435
436	break;
437	}
438	default:
439	/* Unsupported. */
440	return VERR_VD_VDI_UNSUPPORTED_VERSION;
441	}
442
443	/* Check common header parameters. */
444
445	bool fFailed = false;
446
447	if ( getImageType(pHeader) < VDI_IMAGE_TYPE_FIRST
448	\|\| getImageType(pHeader) > VDI_IMAGE_TYPE_LAST)
449	{
450	LogRel(("VDI: bad image type %d\n", getImageType(pHeader)));
451	fFailed = true;
452	}
453
454	if (getImageFlags(pHeader) & ~VD_VDI_IMAGE_FLAGS_MASK)
455	{
456	LogRel(("VDI: bad image flags %08x\n", getImageFlags(pHeader)));
457	fFailed = true;
458	}
459
460	if ( getImageLCHSGeometry(pHeader)
461	&& (getImageLCHSGeometry(pHeader))->cbSector != VDI_GEOMETRY_SECTOR_SIZE)
462	{
463	LogRel(("VDI: wrong sector size (%d != %d)\n",
464	(getImageLCHSGeometry(pHeader))->cbSector, VDI_GEOMETRY_SECTOR_SIZE));
465	fFailed = true;
466	}
467
468	if ( getImageDiskSize(pHeader) == 0
469	\|\| getImageBlockSize(pHeader) == 0
470	\|\| getImageBlocks(pHeader) == 0
471	\|\| getPowerOfTwo(getImageBlockSize(pHeader)) == 0)
472	{
473	LogRel(("VDI: wrong size (%lld, %d, %d, %d)\n",
474	getImageDiskSize(pHeader), getImageBlockSize(pHeader),
475	getImageBlocks(pHeader), getPowerOfTwo(getImageBlockSize(pHeader))));
476	fFailed = true;
477	}
478
479	if (getImageBlocksAllocated(pHeader) > getImageBlocks(pHeader))
480	{
481	LogRel(("VDI: too many blocks allocated (%d > %d)\n"
482	" blocksize=%d disksize=%lld\n",
483	getImageBlocksAllocated(pHeader), getImageBlocks(pHeader),
484	getImageBlockSize(pHeader), getImageDiskSize(pHeader)));
485	fFailed = true;
486	}
487
488	if ( getImageExtraBlockSize(pHeader) != 0
489	&& getPowerOfTwo(getImageExtraBlockSize(pHeader)) == 0)
490	{
491	LogRel(("VDI: wrong extra size (%d, %d)\n",
492	getImageExtraBlockSize(pHeader), getPowerOfTwo(getImageExtraBlockSize(pHeader))));
493	fFailed = true;
494	}
495
496	if ((uint64_t)getImageBlockSize(pHeader) * getImageBlocks(pHeader) < getImageDiskSize(pHeader))
497	{
498	LogRel(("VDI: wrong disk size (%d, %d, %lld)\n",
499	getImageBlockSize(pHeader), getImageBlocks(pHeader), getImageDiskSize(pHeader)));
500	fFailed = true;
501	}
502
503	if (RTUuidIsNull(getImageCreationUUID(pHeader)))
504	{
505	LogRel(("VDI: uuid of creator is 0\n"));
506	fFailed = true;
507	}
508
509	if (RTUuidIsNull(getImageModificationUUID(pHeader)))
510	{
511	LogRel(("VDI: uuid of modificator is 0\n"));
512	fFailed = true;
513	}
514
515	return fFailed ? VERR_VD_VDI_INVALID_HEADER : VINF_SUCCESS;
516	}
517
518	/**
519	* Internal: Set up VDIIMAGEDESC structure by image header.
520	*/
521	static void vdiSetupImageDesc(PVDIIMAGEDESC pImage)
522	{
523	pImage->uImageFlags = getImageFlags(&pImage->Header);
524	pImage->uImageFlags \|= vdiTranslateVDI2ImageFlags(getImageType(&pImage->Header));
525	pImage->offStartBlocks = getImageBlocksOffset(&pImage->Header);
526	pImage->offStartData = getImageDataOffset(&pImage->Header);
527	pImage->uBlockMask = getImageBlockSize(&pImage->Header) - 1;
528	pImage->uShiftOffset2Index = getPowerOfTwo(getImageBlockSize(&pImage->Header));
529	pImage->offStartBlockData = getImageExtraBlockSize(&pImage->Header);
530	pImage->cbTotalBlockData = pImage->offStartBlockData
531	+ getImageBlockSize(&pImage->Header);
532	}
533
534	/**
535	* Internal: Create VDI image file.
536	*/
537	static int vdiCreateImage(PVDIIMAGEDESC pImage, uint64_t cbSize,
538	unsigned uImageFlags, const char *pszComment,
539	PCVDGEOMETRY pPCHSGeometry,
540	PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
541	unsigned uOpenFlags, PFNVDPROGRESS pfnProgress,
542	void *pvUser, unsigned uPercentStart,
543	unsigned uPercentSpan)
544	{
545	int rc;
546	uint64_t cbTotal;
547	uint64_t cbFill;
548	uint64_t uOff;
549
550	/* Special check for comment length. */
551	if ( VALID_PTR(pszComment)
552	&& strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
553	{
554	rc = vdiError(pImage, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
555	goto out;
556	}
557	AssertPtr(pPCHSGeometry);
558	AssertPtr(pLCHSGeometry);
559
560	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
561	if (pImage->pInterfaceError)
562	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
563
564	/* Get I/O interface. */
565	pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
566	AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
567	pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
568	AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
569
570	vdiInitPreHeader(&pImage->PreHeader);
571	vdiInitHeader(&pImage->Header, uImageFlags, pszComment, cbSize, VDI_IMAGE_DEFAULT_BLOCK_SIZE, 0);
572	/* Save PCHS geometry. Not much work, and makes the flow of information
573	* quite a bit clearer - relying on the higher level isn't obvious. */
574	pImage->PCHSGeometry = *pPCHSGeometry;
575	/* Set LCHS geometry (legacy geometry is ignored for the current 1.1+). */
576	pImage->Header.u.v1plus.LCHSGeometry.cCylinders = pLCHSGeometry->cCylinders;
577	pImage->Header.u.v1plus.LCHSGeometry.cHeads = pLCHSGeometry->cHeads;
578	pImage->Header.u.v1plus.LCHSGeometry.cSectors = pLCHSGeometry->cSectors;
579	pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
580
581	pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
582	if (!pImage->paBlocks)
583	{
584	rc = VERR_NO_MEMORY;
585	goto out;
586	}
587
588	if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
589	{
590	/* for growing images mark all blocks in paBlocks as free. */
591	for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
592	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
593	}
594	else
595	{
596	/* for fixed images mark all blocks in paBlocks as allocated */
597	for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
598	pImage->paBlocks[i] = i;
599	pImage->Header.u.v1.cBlocksAllocated = pImage->Header.u.v1.cBlocks;
600	}
601
602	/* Setup image parameters. */
603	vdiSetupImageDesc(pImage);
604
605	/* Create image file. */
606	rc = vdiFileOpen(pImage, pImage->pszFilename,
607	VDOpenFlagsToFileOpenFlags(uOpenFlags & ~VD_OPEN_FLAGS_READONLY,
608	true /* fCreate */));
609	if (RT_FAILURE(rc))
610	{
611	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: cannot create image '%s'"), pImage->pszFilename);
612	goto out;
613	}
614
615	cbTotal = pImage->offStartData
616	+ (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
617
618	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
619	{
620	/* Check the free space on the disk and leave early if there is not
621	* sufficient space available. */
622	int64_t cbFree = 0;
623	rc = vdiFileGetFreeSpace(pImage, pImage->pszFilename, &cbFree);
624	if (RT_SUCCESS(rc) /* ignore errors */ && ((uint64_t)cbFree < cbTotal))
625	{
626	rc = vdiError(pImage, VERR_DISK_FULL, RT_SRC_POS, N_("VDI: disk would overflow creating image '%s'"), pImage->pszFilename);
627	goto out;
628	}
629	}
630
631	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
632	{
633	/*
634	* Allocate & commit whole file if fixed image, it must be more
635	* effective than expanding file by write operations.
636	*/
637	rc = vdiFileSetSize(pImage, cbTotal);
638	}
639	else
640	{
641	/* Set file size to hold header and blocks array. */
642	rc = vdiFileSetSize(pImage, pImage->offStartData);
643	}
644	if (RT_FAILURE(rc))
645	{
646	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: setting image size failed for '%s'"), pImage->pszFilename);
647	goto out;
648	}
649
650	/* Use specified image uuid */
651	getImageCreationUUID(&pImage->Header) = pUuid;
652
653	/* Generate image last-modify uuid */
654	RTUuidCreate(getImageModificationUUID(&pImage->Header));
655
656	/* Write pre-header. */
657	rc = vdiFileWriteSync(pImage, 0, &pImage->PreHeader, sizeof(pImage->PreHeader), NULL);
658	if (RT_FAILURE(rc))
659	{
660	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing pre-header failed for '%s'"), pImage->pszFilename);
661	goto out;
662	}
663
664	/* Write header. */
665	rc = vdiFileWriteSync(pImage, sizeof(pImage->PreHeader),
666	&pImage->Header.u.v1plus,
667	sizeof(pImage->Header.u.v1plus), NULL);
668	if (RT_FAILURE(rc))
669	{
670	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing header failed for '%s'"), pImage->pszFilename);
671	goto out;
672	}
673
674	rc = vdiFileWriteSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
675	getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
676	NULL);
677	if (RT_FAILURE(rc))
678	{
679	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block pointers failed for '%s'"), pImage->pszFilename);
680	goto out;
681	}
682
683	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
684	{
685	/* Fill image with zeroes. We do this for every fixed-size image since on some systems
686	* (for example Windows Vista), it takes ages to write a block near the end of a sparse
687	* file and the guest could complain about an ATA timeout. */
688
689	/** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
690	* Currently supported file systems are ext4 and ocfs2. */
691
692	/* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
693	const size_t cbBuf = 128 * _1K;
694	void *pvBuf = RTMemTmpAllocZ(cbBuf);
695	if (!pvBuf)
696	{
697	rc = VERR_NO_MEMORY;
698	goto out;
699	}
700
701	cbFill = (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
702	uOff = 0;
703	/* Write data to all image blocks. */
704	while (uOff < cbFill)
705	{
706	unsigned cbChunk = (unsigned)RT_MIN(cbFill, cbBuf);
707
708	rc = vdiFileWriteSync(pImage, pImage->offStartData + uOff,
709	pvBuf, cbChunk, NULL);
710	if (RT_FAILURE(rc))
711	{
712	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block failed for '%s'"), pImage->pszFilename);
713	RTMemTmpFree(pvBuf);
714	goto out;
715	}
716
717	uOff += cbChunk;
718
719	if (pfnProgress)
720	{
721	rc = pfnProgress(pvUser,
722	uPercentStart + uOff * uPercentSpan / cbFill);
723	if (RT_FAILURE(rc))
724	goto out;
725	}
726	}
727	RTMemTmpFree(pvBuf);
728	}
729
730	out:
731	if (RT_SUCCESS(rc) && pfnProgress)
732	pfnProgress(pvUser, uPercentStart + uPercentSpan);
733
734	if (RT_FAILURE(rc))
735	vdiFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
736	return rc;
737	}
738
739	/**
740	* Internal: Open a VDI image.
741	*/
742	static int vdiOpenImage(PVDIIMAGEDESC pImage, unsigned uOpenFlags)
743	{
744	int rc;
745
746	pImage->uOpenFlags = uOpenFlags;
747
748	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
749	if (pImage->pInterfaceError)
750	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
751
752	/* Get I/O interface. */
753	pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
754	AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
755	pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
756	AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
757
758	/*
759	* Open the image.
760	*/
761	rc = vdiFileOpen(pImage, pImage->pszFilename,
762	VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */));
763	if (RT_FAILURE(rc))
764	{
765	/* Do NOT signal an appropriate error here, as the VD layer has the
766	* choice of retrying the open if it failed. */
767	goto out;
768	}
769
770	/* Read pre-header. */
771	rc = vdiFileReadSync(pImage, 0, &pImage->PreHeader, sizeof(pImage->PreHeader), NULL);
772	if (RT_FAILURE(rc))
773	{
774	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading pre-header in '%s'"), pImage->pszFilename);
775	goto out;
776	}
777	rc = vdiValidatePreHeader(&pImage->PreHeader);
778	if (RT_FAILURE(rc))
779	{
780	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: invalid pre-header in '%s'"), pImage->pszFilename);
781	goto out;
782	}
783
784	/* Read header. */
785	pImage->Header.uVersion = pImage->PreHeader.u32Version;
786	switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
787	{
788	case 0:
789	rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
790	&pImage->Header.u.v0, sizeof(pImage->Header.u.v0),
791	NULL);
792	if (RT_FAILURE(rc))
793	{
794	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"), pImage->pszFilename);
795	goto out;
796	}
797	break;
798	case 1:
799	rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
800	&pImage->Header.u.v1, sizeof(pImage->Header.u.v1),
801	NULL);
802	if (RT_FAILURE(rc))
803	{
804	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"), pImage->pszFilename);
805	goto out;
806	}
807	/* Convert VDI 1.1 images to VDI 1.1+ on open in read/write mode.
808	* Conversion is harmless, as any VirtualBox version supporting VDI
809	* 1.1 doesn't touch fields it doesn't know about. */
810	if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
811	&& GET_MINOR_HEADER_VERSION(&pImage->Header) == 1
812	&& pImage->Header.u.v1.cbHeader < sizeof(pImage->Header.u.v1plus))
813	{
814	pImage->Header.u.v1plus.cbHeader = sizeof(pImage->Header.u.v1plus);
815	/* Mark LCHS geometry not-calculated. */
816	pImage->Header.u.v1plus.LCHSGeometry.cCylinders = 0;
817	pImage->Header.u.v1plus.LCHSGeometry.cHeads = 0;
818	pImage->Header.u.v1plus.LCHSGeometry.cSectors = 0;
819	pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
820	}
821	else if (pImage->Header.u.v1.cbHeader >= sizeof(pImage->Header.u.v1plus))
822	{
823	/* Read the actual VDI 1.1+ header completely. */
824	rc = vdiFileReadSync(pImage, sizeof(pImage->PreHeader),
825	&pImage->Header.u.v1plus,
826	sizeof(pImage->Header.u.v1plus), NULL);
827	if (RT_FAILURE(rc))
828	{
829	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"), pImage->pszFilename);
830	goto out;
831	}
832	}
833	break;
834	default:
835	rc = vdiError(pImage, VERR_VD_VDI_UNSUPPORTED_VERSION, RT_SRC_POS, N_("VDI: unsupported major version %u in '%s'"), GET_MAJOR_HEADER_VERSION(&pImage->Header), pImage->pszFilename);
836	goto out;
837	}
838
839	rc = vdiValidateHeader(&pImage->Header);
840	if (RT_FAILURE(rc))
841	{
842	rc = vdiError(pImage, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
843	goto out;
844	}
845
846	/* Setup image parameters by header. */
847	vdiSetupImageDesc(pImage);
848
849	/* Allocate memory for blocks array. */
850	pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
851	if (!pImage->paBlocks)
852	{
853	rc = VERR_NO_MEMORY;
854	goto out;
855	}
856
857	/* Read blocks array. */
858	rc = vdiFileReadSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
859	getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
860	NULL);
861
862	out:
863	if (RT_FAILURE(rc))
864	vdiFreeImage(pImage, false);
865	return rc;
866	}
867
868	/**
869	* Internal: Save header to file.
870	*/
871	static int vdiUpdateHeader(PVDIIMAGEDESC pImage)
872	{
873	int rc;
874	switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
875	{
876	case 0:
877	rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
878	&pImage->Header.u.v0, sizeof(pImage->Header.u.v0),
879	NULL);
880	break;
881	case 1:
882	if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
883	rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
884	&pImage->Header.u.v1, sizeof(pImage->Header.u.v1),
885	NULL);
886	else
887	rc = vdiFileWriteSync(pImage, sizeof(VDIPREHEADER),
888	&pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus),
889	NULL);
890	break;
891	default:
892	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
893	break;
894	}
895	AssertMsgRC(rc, ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
896	return rc;
897	}
898
899	/**
900	* Internal: Save header to file - async version.
901	*/
902	static int vdiUpdateHeaderAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
903	{
904	int rc;
905	switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
906	{
907	case 0:
908	rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
909	&pImage->Header.u.v0,
910	sizeof(pImage->Header.u.v0),
911	pIoCtx, NULL, NULL);
912	break;
913	case 1:
914	if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
915	rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
916	&pImage->Header.u.v1,
917	sizeof(pImage->Header.u.v1),
918	pIoCtx, NULL, NULL);
919	else
920	rc = vdiFileWriteMetaAsync(pImage, sizeof(VDIPREHEADER),
921	&pImage->Header.u.v1plus,
922	sizeof(pImage->Header.u.v1plus),
923	pIoCtx, NULL, NULL);
924	break;
925	default:
926	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
927	break;
928	}
929	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
930	("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
931	return rc;
932	}
933
934	/**
935	* Internal: Save block pointer to file, save header to file.
936	*/
937	static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock)
938	{
939	/* Update image header. */
940	int rc = vdiUpdateHeader(pImage);
941	if (RT_SUCCESS(rc))
942	{
943	/* write only one block pointer. */
944	rc = vdiFileWriteSync(pImage, pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
945	&pImage->paBlocks[uBlock], sizeof(VDIIMAGEBLOCKPOINTER),
946	NULL);
947	AssertMsgRC(rc, ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
948	uBlock, pImage->pszFilename, rc));
949	}
950	return rc;
951	}
952
953	/**
954	* Internal: Save block pointer to file, save header to file - async version.
955	*/
956	static int vdiUpdateBlockInfoAsync(PVDIIMAGEDESC pImage, unsigned uBlock,
957	PVDIOCTX pIoCtx)
958	{
959	/* Update image header. */
960	int rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
961	if (RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
962	{
963	/* write only one block pointer. */
964	rc = vdiFileWriteMetaAsync(pImage,
965	pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
966	&pImage->paBlocks[uBlock],
967	sizeof(VDIIMAGEBLOCKPOINTER),
968	pIoCtx, NULL, NULL);
969	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
970	("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
971	uBlock, pImage->pszFilename, rc));
972	}
973	return rc;
974	}
975
976	/**
977	* Internal: Flush the image file to disk - async version.
978	*/
979	static int vdiFlushImageAsync(PVDIIMAGEDESC pImage, PVDIOCTX pIoCtx)
980	{
981	int rc = VINF_SUCCESS;
982
983	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
984	{
985	/* Save header. */
986	rc = vdiUpdateHeaderAsync(pImage, pIoCtx);
987	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
988	("vdiUpdateHeaderAsync() failed, filename=\"%s\", rc=%Rrc\n",
989	pImage->pszFilename, rc));
990	rc = vdiFileFlushAsync(pImage, pIoCtx, NULL, NULL);
991	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_VD_ASYNC_IO_IN_PROGRESS,
992	("Flushing data to disk failed rc=%Rrc\n", rc));
993	}
994
995	return rc;
996	}
997
998
999	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
1000	static int vdiCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1001	PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
1002	{
1003	LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
1004	int rc = VINF_SUCCESS;
1005	PVDIIMAGEDESC pImage;
1006
1007	if ( !VALID_PTR(pszFilename)
1008	\|\| !*pszFilename)
1009	{
1010	rc = VERR_INVALID_PARAMETER;
1011	goto out;
1012	}
1013
1014	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1015	if (!pImage)
1016	{
1017	rc = VERR_NO_MEMORY;
1018	goto out;
1019	}
1020	pImage->pszFilename = pszFilename;
1021	pImage->pStorage = NULL;
1022	pImage->paBlocks = NULL;
1023	pImage->pVDIfsDisk = pVDIfsDisk;
1024	pImage->pVDIfsImage = pVDIfsImage;
1025
1026	rc = vdiOpenImage(pImage, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY);
1027	vdiFreeImage(pImage, false);
1028	RTMemFree(pImage);
1029
1030	if (RT_SUCCESS(rc))
1031	*penmType = VDTYPE_HDD;
1032
1033	out:
1034	LogFlowFunc(("returns %Rrc\n", rc));
1035	return rc;
1036	}
1037
1038	/** @copydoc VBOXHDDBACKEND::pfnOpen */
1039	static int vdiOpen(const char *pszFilename, unsigned uOpenFlags,
1040	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1041	VDTYPE enmType, void **ppBackendData)
1042	{
1043	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
1044	int rc;
1045	PVDIIMAGEDESC pImage;
1046
1047	/* Check open flags. All valid flags are supported. */
1048	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1049	{
1050	rc = VERR_INVALID_PARAMETER;
1051	goto out;
1052	}
1053
1054	/* Check remaining arguments. */
1055	if ( !VALID_PTR(pszFilename)
1056	\|\| !*pszFilename)
1057	{
1058	rc = VERR_INVALID_PARAMETER;
1059	goto out;
1060	}
1061
1062	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1063	if (!pImage)
1064	{
1065	rc = VERR_NO_MEMORY;
1066	goto out;
1067	}
1068	pImage->pszFilename = pszFilename;
1069	pImage->pStorage = NULL;
1070	pImage->paBlocks = NULL;
1071	pImage->pVDIfsDisk = pVDIfsDisk;
1072	pImage->pVDIfsImage = pVDIfsImage;
1073
1074	rc = vdiOpenImage(pImage, uOpenFlags);
1075	if (RT_SUCCESS(rc))
1076	*ppBackendData = pImage;
1077
1078	out:
1079	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1080	return rc;
1081	}
1082
1083	/** @copydoc VBOXHDDBACKEND::pfnCreate */
1084	static int vdiCreate(const char *pszFilename, uint64_t cbSize,
1085	unsigned uImageFlags, const char *pszComment,
1086	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1087	PCRTUUID pUuid, unsigned uOpenFlags,
1088	unsigned uPercentStart, unsigned uPercentSpan,
1089	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1090	PVDINTERFACE pVDIfsOperation, void **ppBackendData)
1091	{
1092	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));
1093	int rc;
1094	PVDIIMAGEDESC pImage;
1095
1096	PFNVDPROGRESS pfnProgress = NULL;
1097	void *pvUser = NULL;
1098	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
1099	VDINTERFACETYPE_PROGRESS);
1100	PVDINTERFACEPROGRESS pCbProgress = NULL;
1101	if (pIfProgress)
1102	{
1103	pCbProgress = VDGetInterfaceProgress(pIfProgress);
1104	if (pCbProgress)
1105	pfnProgress = pCbProgress->pfnProgress;
1106	pvUser = pIfProgress->pvUser;
1107	}
1108
1109	/* Check open flags. All valid flags are supported. */
1110	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
1111	{
1112	rc = VERR_INVALID_PARAMETER;
1113	goto out;
1114	}
1115
1116	/* Check size. Maximum 4PB-3M. No tricks with adjusting the 1M block size
1117	* so far, which would extend the size. */
1118	cbSize = RT_ALIGN_64(cbSize, _1M);
1119	if ( !cbSize
1120	\|\| cbSize >= _1P * 2 - _1M * 3)
1121	{
1122	rc = VERR_VD_INVALID_SIZE;
1123	goto out;
1124	}
1125
1126	/* Check remaining arguments. */
1127	if ( !VALID_PTR(pszFilename)
1128	\|\| !*pszFilename
1129	\|\| cbSize < VDI_IMAGE_DEFAULT_BLOCK_SIZE
1130	\|\| !VALID_PTR(pPCHSGeometry)
1131	\|\| !VALID_PTR(pLCHSGeometry))
1132	{
1133	rc = VERR_INVALID_PARAMETER;
1134	goto out;
1135	}
1136
1137	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
1138	if (!pImage)
1139	{
1140	rc = VERR_NO_MEMORY;
1141	goto out;
1142	}
1143	pImage->pszFilename = pszFilename;
1144	pImage->pStorage = NULL;
1145	pImage->paBlocks = NULL;
1146	pImage->pVDIfsDisk = pVDIfsDisk;
1147	pImage->pVDIfsImage = pVDIfsImage;
1148
1149	rc = vdiCreateImage(pImage, cbSize, uImageFlags, pszComment,
1150	pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags,
1151	pfnProgress, pvUser, uPercentStart, uPercentSpan);
1152	if (RT_SUCCESS(rc))
1153	{
1154	/* So far the image is opened in read/write mode. Make sure the
1155	* image is opened in read-only mode if the caller requested that. */
1156	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
1157	{
1158	vdiFreeImage(pImage, false);
1159	rc = vdiOpenImage(pImage, uOpenFlags);
1160	if (RT_FAILURE(rc))
1161	{
1162	RTMemFree(pImage);
1163	goto out;
1164	}
1165	}
1166	*ppBackendData = pImage;
1167	}
1168	else
1169	RTMemFree(pImage);
1170
1171	out:
1172	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1173	return rc;
1174	}
1175
1176	/** @copydoc VBOXHDDBACKEND::pfnRename */
1177	static int vdiRename(void pBackendData, const char pszFilename)
1178	{
1179	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1180
1181	int rc = VINF_SUCCESS;
1182	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1183
1184	/* Check arguments. */
1185	if ( !pImage
1186	\|\| !pszFilename
1187	\|\| !*pszFilename)
1188	{
1189	rc = VERR_INVALID_PARAMETER;
1190	goto out;
1191	}
1192
1193	/* Close the image. */
1194	vdiFreeImage(pImage, false);
1195
1196	/* Rename the file. */
1197	rc = vdiFileMove(pImage, pImage->pszFilename, pszFilename, 0);
1198	if (RT_FAILURE(rc))
1199	{
1200	/* The move failed, try to reopen the original image. */
1201	int rc2 = vdiOpenImage(pImage, pImage->uOpenFlags);
1202	if (RT_FAILURE(rc2))
1203	rc = rc2;
1204
1205	goto out;
1206	}
1207
1208	/* Update pImage with the new information. */
1209	pImage->pszFilename = pszFilename;
1210
1211	/* Open the new image. */
1212	rc = vdiOpenImage(pImage, pImage->uOpenFlags);
1213	if (RT_FAILURE(rc))
1214	goto out;
1215
1216	out:
1217	LogFlowFunc(("returns %Rrc\n", rc));
1218	return rc;
1219	}
1220
1221	/** @copydoc VBOXHDDBACKEND::pfnClose */
1222	static int vdiClose(void *pBackendData, bool fDelete)
1223	{
1224	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1225	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1226	int rc;
1227
1228	rc = vdiFreeImage(pImage, fDelete);
1229	RTMemFree(pImage);
1230
1231	LogFlowFunc(("returns %Rrc\n", rc));
1232	return rc;
1233	}
1234
1235	/** @copydoc VBOXHDDBACKEND::pfnRead */
1236	static int vdiRead(void pBackendData, uint64_t uOffset, void pvBuf,
1237	size_t cbToRead, size_t *pcbActuallyRead)
1238	{
1239	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
1240	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1241	unsigned uBlock;
1242	unsigned offRead;
1243	int rc;
1244
1245	AssertPtr(pImage);
1246	Assert(!(uOffset % 512));
1247	Assert(!(cbToRead % 512));
1248
1249	if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
1250	\|\| !VALID_PTR(pvBuf)
1251	\|\| !cbToRead)
1252	{
1253	rc = VERR_INVALID_PARAMETER;
1254	goto out;
1255	}
1256
1257	/* Calculate starting block number and offset inside it. */
1258	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1259	offRead = (unsigned)uOffset & pImage->uBlockMask;
1260
1261	/* Clip read range to at most the rest of the block. */
1262	cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
1263	Assert(!(cbToRead % 512));
1264
1265	if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
1266	rc = VERR_VD_BLOCK_FREE;
1267	else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
1268	{
1269	memset(pvBuf, 0, cbToRead);
1270	rc = VINF_SUCCESS;
1271	}
1272	else
1273	{
1274	/* Block present in image file, read relevant data. */
1275	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1276	+ (pImage->offStartData + pImage->offStartBlockData + offRead);
1277	rc = vdiFileReadSync(pImage, u64Offset, pvBuf, cbToRead, NULL);
1278	}
1279
1280	if (pcbActuallyRead)
1281	*pcbActuallyRead = cbToRead;
1282
1283	out:
1284	LogFlowFunc(("returns %Rrc\n", rc));
1285	return rc;
1286	}
1287
1288	/*@copydoc VBOXHDDBACKEND::pfnWrite /
1289	static int vdiWrite(void pBackendData, uint64_t uOffset, const void pvBuf,
1290	size_t cbToWrite, size_t *pcbWriteProcess,
1291	size_t pcbPreRead, size_t pcbPostRead, unsigned fWrite)
1292	{
1293	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
1294	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1295	unsigned uBlock;
1296	unsigned offWrite;
1297	int rc = VINF_SUCCESS;
1298
1299	AssertPtr(pImage);
1300	Assert(!(uOffset % 512));
1301	Assert(!(cbToWrite % 512));
1302
1303	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1304	{
1305	rc = VERR_VD_IMAGE_READ_ONLY;
1306	goto out;
1307	}
1308
1309	if (!VALID_PTR(pvBuf) \|\| !cbToWrite)
1310	{
1311	rc = VERR_INVALID_PARAMETER;
1312	goto out;
1313	}
1314
1315	/* No size check here, will do that later. For dynamic images which are
1316	* not multiples of the block size in length, this would prevent writing to
1317	* the last block. */
1318
1319	/* Calculate starting block number and offset inside it. */
1320	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1321	offWrite = (unsigned)uOffset & pImage->uBlockMask;
1322
1323	/* Clip write range to at most the rest of the block. */
1324	cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
1325	Assert(!(cbToWrite % 512));
1326
1327	do
1328	{
1329	if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
1330	{
1331	/* Block is either free or zero. */
1332	if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
1333	&& ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
1334	\|\| cbToWrite == getImageBlockSize(&pImage->Header)))
1335	{
1336	/* If the destination block is unallocated at this point, it's
1337	* either a zero block or a block which hasn't been used so far
1338	* (which also means that it's a zero block. Don't need to write
1339	* anything to this block if the data consists of just zeroes. */
1340	Assert(!(cbToWrite % 4));
1341	Assert(cbToWrite * 8 <= UINT32_MAX);
1342	if (ASMBitFirstSet((volatile void )pvBuf, (uint32_t)cbToWrite 8) == -1)
1343	{
1344	pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
1345	break;
1346	}
1347	}
1348
1349	if (cbToWrite == getImageBlockSize(&pImage->Header))
1350	{
1351	/* Full block write to previously unallocated block.
1352	* Allocate block and write data. */
1353	Assert(!offWrite);
1354	unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
1355	uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
1356	+ (pImage->offStartData + pImage->offStartBlockData);
1357	rc = vdiFileWriteSync(pImage, u64Offset, pvBuf, cbToWrite, NULL);
1358	if (RT_FAILURE(rc))
1359	goto out;
1360	pImage->paBlocks[uBlock] = cBlocksAllocated;
1361	setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
1362
1363	rc = vdiUpdateBlockInfo(pImage, uBlock);
1364	if (RT_FAILURE(rc))
1365	goto out;
1366
1367	*pcbPreRead = 0;
1368	*pcbPostRead = 0;
1369	}
1370	else
1371	{
1372	/* Trying to do a partial write to an unallocated block. Don't do
1373	* anything except letting the upper layer know what to do. */
1374	*pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
1375	pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - pcbPreRead;
1376	rc = VERR_VD_BLOCK_FREE;
1377	}
1378	}
1379	else
1380	{
1381	/* Block present in image file, write relevant data. */
1382	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1383	+ (pImage->offStartData + pImage->offStartBlockData + offWrite);
1384	rc = vdiFileWriteSync(pImage, u64Offset, pvBuf, cbToWrite, NULL);
1385	}
1386	} while (0);
1387
1388	if (pcbWriteProcess)
1389	*pcbWriteProcess = cbToWrite;
1390
1391	out:
1392	LogFlowFunc(("returns %Rrc\n", rc));
1393	return rc;
1394	}
1395
1396	/** @copydoc VBOXHDDBACKEND::pfnFlush */
1397	static int vdiFlush(void *pBackendData)
1398	{
1399	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1400	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1401	int rc = VINF_SUCCESS;
1402
1403	Assert(pImage);
1404
1405	vdiFlushImage(pImage);
1406	LogFlowFunc(("returns %Rrc\n", rc));
1407	return rc;
1408	}
1409
1410	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
1411	static unsigned vdiGetVersion(void *pBackendData)
1412	{
1413	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1414	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1415	unsigned uVersion;
1416
1417	AssertPtr(pImage);
1418
1419	if (pImage)
1420	uVersion = pImage->PreHeader.u32Version;
1421	else
1422	uVersion = 0;
1423
1424	LogFlowFunc(("returns %#x\n", uVersion));
1425	return uVersion;
1426	}
1427
1428	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
1429	static uint64_t vdiGetSize(void *pBackendData)
1430	{
1431	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1432	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1433	uint64_t cbSize;
1434
1435	AssertPtr(pImage);
1436
1437	if (pImage)
1438	cbSize = getImageDiskSize(&pImage->Header);
1439	else
1440	cbSize = 0;
1441
1442	LogFlowFunc(("returns %llu\n", cbSize));
1443	return cbSize;
1444	}
1445
1446	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
1447	static uint64_t vdiGetFileSize(void *pBackendData)
1448	{
1449	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1450	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1451	uint64_t cb = 0;
1452
1453	AssertPtr(pImage);
1454
1455	if (pImage)
1456	{
1457	uint64_t cbFile;
1458	if (pImage->pStorage)
1459	{
1460	int rc = vdiFileGetSize(pImage, &cbFile);
1461	if (RT_SUCCESS(rc))
1462	cb += cbFile;
1463	}
1464	}
1465
1466	LogFlowFunc(("returns %lld\n", cb));
1467	return cb;
1468	}
1469
1470	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
1471	static int vdiGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
1472	{
1473	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1474	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1475	int rc;
1476
1477	AssertPtr(pImage);
1478
1479	if (pImage)
1480	{
1481	if (pImage->PCHSGeometry.cCylinders)
1482	{
1483	*pPCHSGeometry = pImage->PCHSGeometry;
1484	rc = VINF_SUCCESS;
1485	}
1486	else
1487	rc = VERR_VD_GEOMETRY_NOT_SET;
1488	}
1489	else
1490	rc = VERR_VD_NOT_OPENED;
1491
1492	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1493	return rc;
1494	}
1495
1496	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
1497	static int vdiSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
1498	{
1499	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1500	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1501	int rc;
1502
1503	AssertPtr(pImage);
1504
1505	if (pImage)
1506	{
1507	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1508	{
1509	rc = VERR_VD_IMAGE_READ_ONLY;
1510	goto out;
1511	}
1512
1513	pImage->PCHSGeometry = *pPCHSGeometry;
1514	rc = VINF_SUCCESS;
1515	}
1516	else
1517	rc = VERR_VD_NOT_OPENED;
1518
1519	out:
1520	LogFlowFunc(("returns %Rrc\n", rc));
1521	return rc;
1522	}
1523
1524	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
1525	static int vdiGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
1526	{
1527	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1528	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1529	int rc;
1530
1531	AssertPtr(pImage);
1532
1533	if (pImage)
1534	{
1535	VDIDISKGEOMETRY DummyGeo = { 0, 0, 0, VDI_GEOMETRY_SECTOR_SIZE };
1536	PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
1537	if (!pGeometry)
1538	pGeometry = &DummyGeo;
1539
1540	if ( pGeometry->cCylinders > 0
1541	&& pGeometry->cHeads > 0
1542	&& pGeometry->cSectors > 0)
1543	{
1544	pLCHSGeometry->cCylinders = pGeometry->cCylinders;
1545	pLCHSGeometry->cHeads = pGeometry->cHeads;
1546	pLCHSGeometry->cSectors = pGeometry->cSectors;
1547	rc = VINF_SUCCESS;
1548	}
1549	else
1550	rc = VERR_VD_GEOMETRY_NOT_SET;
1551	}
1552	else
1553	rc = VERR_VD_NOT_OPENED;
1554
1555	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1556	return rc;
1557	}
1558
1559	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
1560	static int vdiSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
1561	{
1562	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1563	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1564	PVDIDISKGEOMETRY pGeometry;
1565	int rc;
1566
1567	AssertPtr(pImage);
1568
1569	if (pImage)
1570	{
1571	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1572	{
1573	rc = VERR_VD_IMAGE_READ_ONLY;
1574	goto out;
1575	}
1576
1577	pGeometry = getImageLCHSGeometry(&pImage->Header);
1578	if (pGeometry)
1579	{
1580	pGeometry->cCylinders = pLCHSGeometry->cCylinders;
1581	pGeometry->cHeads = pLCHSGeometry->cHeads;
1582	pGeometry->cSectors = pLCHSGeometry->cSectors;
1583	pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
1584
1585	/* Update header information in base image file. */
1586	vdiFlushImage(pImage);
1587	}
1588	rc = VINF_SUCCESS;
1589	}
1590	else
1591	rc = VERR_VD_NOT_OPENED;
1592
1593	out:
1594	LogFlowFunc(("returns %Rrc\n", rc));
1595	return rc;
1596	}
1597
1598	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
1599	static unsigned vdiGetImageFlags(void *pBackendData)
1600	{
1601	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1602	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1603	unsigned uImageFlags;
1604
1605	AssertPtr(pImage);
1606
1607	if (pImage)
1608	uImageFlags = pImage->uImageFlags;
1609	else
1610	uImageFlags = 0;
1611
1612	LogFlowFunc(("returns %#x\n", uImageFlags));
1613	return uImageFlags;
1614	}
1615
1616	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
1617	static unsigned vdiGetOpenFlags(void *pBackendData)
1618	{
1619	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1620	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1621	unsigned uOpenFlags;
1622
1623	AssertPtr(pImage);
1624
1625	if (pImage)
1626	uOpenFlags = pImage->uOpenFlags;
1627	else
1628	uOpenFlags = 0;
1629
1630	LogFlowFunc(("returns %#x\n", uOpenFlags));
1631	return uOpenFlags;
1632	}
1633
1634	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
1635	static int vdiSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1636	{
1637	LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
1638	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1639	int rc;
1640	const char *pszFilename;
1641
1642	/* Image must be opened and the new flags must be valid. */
1643	if (!pImage \|\| (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE \| VD_OPEN_FLAGS_SEQUENTIAL)))
1644	{
1645	rc = VERR_INVALID_PARAMETER;
1646	goto out;
1647	}
1648
1649	/* Implement this operation via reopening the image. */
1650	pszFilename = pImage->pszFilename;
1651	rc = vdiFreeImage(pImage, false);
1652	if (RT_FAILURE(rc))
1653	goto out;
1654	rc = vdiOpenImage(pImage, uOpenFlags);
1655
1656	out:
1657	LogFlowFunc(("returns %Rrc\n", rc));
1658	return rc;
1659	}
1660
1661	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1662	static int vdiGetComment(void pBackendData, char pszComment,
1663	size_t cbComment)
1664	{
1665	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
1666	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1667	int rc = VINF_SUCCESS;
1668
1669	AssertPtr(pImage);
1670
1671	if (pImage)
1672	{
1673	char *pszTmp = getImageComment(&pImage->Header);
1674	/* Make this foolproof even if the image doesn't have the zero
1675	* termination. With some luck the repaired header will be saved. */
1676	size_t cb = RTStrNLen(pszTmp, VDI_IMAGE_COMMENT_SIZE);
1677	if (cb == VDI_IMAGE_COMMENT_SIZE)
1678	{
1679	pszTmp[VDI_IMAGE_COMMENT_SIZE-1] = '\0';
1680	cb--;
1681	}
1682	if (cb < cbComment)
1683	{
1684	/* memcpy is much better than strncpy. */
1685	memcpy(pszComment, pszTmp, cb + 1);
1686	}
1687	else
1688	rc = VERR_BUFFER_OVERFLOW;
1689	}
1690	else
1691	rc = VERR_VD_NOT_OPENED;
1692
1693	LogFlowFunc(("returns %Rrc comment=\"%s\"\n", rc, pszComment));
1694	return rc;
1695	}
1696
1697	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1698	static int vdiSetComment(void pBackendData, const char pszComment)
1699	{
1700	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1701	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1702	int rc;
1703
1704	AssertPtr(pImage);
1705
1706	if (pImage)
1707	{
1708	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1709	rc = VERR_VD_IMAGE_READ_ONLY;
1710	else
1711	{
1712	size_t cchComment = pszComment ? strlen(pszComment) : 0;
1713	if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
1714	{
1715	LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
1716	rc = VERR_VD_VDI_COMMENT_TOO_LONG;
1717	goto out;
1718	}
1719
1720	/* we don't support old style images */
1721	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1722	{
1723	/*
1724	* Update the comment field, making sure to zero out all of the previous comment.
1725	*/
1726	memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
1727	memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
1728
1729	/* write out new the header */
1730	rc = vdiUpdateHeader(pImage);
1731	}
1732	else
1733	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1734	}
1735	}
1736	else
1737	rc = VERR_VD_NOT_OPENED;
1738
1739	out:
1740	LogFlowFunc(("returns %Rrc\n", rc));
1741	return rc;
1742	}
1743
1744	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
1745	static int vdiGetUuid(void *pBackendData, PRTUUID pUuid)
1746	{
1747	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1748	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1749	int rc;
1750
1751	AssertPtr(pImage);
1752
1753	if (pImage)
1754	{
1755	pUuid = getImageCreationUUID(&pImage->Header);
1756	rc = VINF_SUCCESS;
1757	}
1758	else
1759	rc = VERR_VD_NOT_OPENED;
1760
1761	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1762	return rc;
1763	}
1764
1765	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
1766	static int vdiSetUuid(void *pBackendData, PCRTUUID pUuid)
1767	{
1768	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1769	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1770	int rc = VINF_SUCCESS;
1771
1772	AssertPtr(pImage);
1773
1774	if (pImage)
1775	{
1776	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1777	{
1778	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1779	pImage->Header.u.v1.uuidCreate = *pUuid;
1780	/* Make it possible to clone old VDIs. */
1781	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1782	pImage->Header.u.v0.uuidCreate = *pUuid;
1783	else
1784	{
1785	LogFunc(("Version is not supported!\n"));
1786	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1787	}
1788	}
1789	else
1790	rc = VERR_VD_IMAGE_READ_ONLY;
1791	}
1792	else
1793	rc = VERR_VD_NOT_OPENED;
1794
1795	LogFlowFunc(("returns %Rrc\n", rc));
1796	return rc;
1797	}
1798
1799	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
1800	static int vdiGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1801	{
1802	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1803	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1804	int rc;
1805
1806	AssertPtr(pImage);
1807
1808	if (pImage)
1809	{
1810	pUuid = getImageModificationUUID(&pImage->Header);
1811	rc = VINF_SUCCESS;
1812	}
1813	else
1814	rc = VERR_VD_NOT_OPENED;
1815
1816	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1817	return rc;
1818	}
1819
1820	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
1821	static int vdiSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1822	{
1823	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1824	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1825	int rc = VINF_SUCCESS;
1826
1827	AssertPtr(pImage);
1828
1829	if (pImage)
1830	{
1831	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1832	{
1833	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1834	pImage->Header.u.v1.uuidModify = *pUuid;
1835	/* Make it possible to clone old VDIs. */
1836	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1837	pImage->Header.u.v0.uuidModify = *pUuid;
1838	else
1839	{
1840	LogFunc(("Version is not supported!\n"));
1841	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1842	}
1843	}
1844	else
1845	rc = VERR_VD_IMAGE_READ_ONLY;
1846	}
1847	else
1848	rc = VERR_VD_NOT_OPENED;
1849
1850	LogFlowFunc(("returns %Rrc\n", rc));
1851	return rc;
1852	}
1853
1854	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1855	static int vdiGetParentUuid(void *pBackendData, PRTUUID pUuid)
1856	{
1857	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1858	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1859	int rc;
1860
1861	AssertPtr(pImage);
1862
1863	if (pImage)
1864	{
1865	pUuid = getImageParentUUID(&pImage->Header);
1866	rc = VINF_SUCCESS;
1867	}
1868	else
1869	rc = VERR_VD_NOT_OPENED;
1870
1871	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1872	return rc;
1873	}
1874
1875	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1876	static int vdiSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1877	{
1878	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1879	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1880	int rc = VINF_SUCCESS;
1881
1882	AssertPtr(pImage);
1883
1884	if (pImage)
1885	{
1886	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1887	{
1888	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1889	pImage->Header.u.v1.uuidLinkage = *pUuid;
1890	/* Make it possible to clone old VDIs. */
1891	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1892	pImage->Header.u.v0.uuidLinkage = *pUuid;
1893	else
1894	{
1895	LogFunc(("Version is not supported!\n"));
1896	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1897	}
1898	}
1899	else
1900	rc = VERR_VD_IMAGE_READ_ONLY;
1901	}
1902	else
1903	rc = VERR_VD_NOT_OPENED;
1904
1905	LogFlowFunc(("returns %Rrc\n", rc));
1906	return rc;
1907	}
1908
1909	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1910	static int vdiGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1911	{
1912	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1913	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1914	int rc;
1915
1916	AssertPtr(pImage);
1917
1918	if (pImage)
1919	{
1920	pUuid = getImageParentModificationUUID(&pImage->Header);
1921	rc = VINF_SUCCESS;
1922	}
1923	else
1924	rc = VERR_VD_NOT_OPENED;
1925
1926	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1927	return rc;
1928	}
1929
1930	/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
1931	static int vdiSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1932	{
1933	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1934	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1935	int rc = VINF_SUCCESS;
1936
1937	AssertPtr(pImage);
1938
1939	if (pImage)
1940	{
1941	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1942	{
1943	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1944	pImage->Header.u.v1.uuidParentModify = *pUuid;
1945	else
1946	{
1947	LogFunc(("Version is not supported!\n"));
1948	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1949	}
1950	}
1951	else
1952	rc = VERR_VD_IMAGE_READ_ONLY;
1953	}
1954	else
1955	rc = VERR_VD_NOT_OPENED;
1956
1957	LogFlowFunc(("returns %Rrc\n", rc));
1958	return rc;
1959	}
1960
1961	/** @copydoc VBOXHDDBACKEND::pfnDump */
1962	static void vdiDump(void *pBackendData)
1963	{
1964	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1965
1966	vdiMessage(pImage, "Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%#p\n",
1967	pImage->pszFilename,
1968	(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY) ? "r/o" : "r/w",
1969	pImage->uOpenFlags,
1970	pImage->pStorage);
1971	vdiMessage(pImage, "Header: Version=%08X Type=%X Flags=%X Size=%llu\n",
1972	pImage->PreHeader.u32Version,
1973	getImageType(&pImage->Header),
1974	getImageFlags(&pImage->Header),
1975	getImageDiskSize(&pImage->Header));
1976	vdiMessage(pImage, "Header: cbBlock=%u cbBlockExtra=%u cBlocks=%u cBlocksAllocated=%u\n",
1977	getImageBlockSize(&pImage->Header),
1978	getImageExtraBlockSize(&pImage->Header),
1979	getImageBlocks(&pImage->Header),
1980	getImageBlocksAllocated(&pImage->Header));
1981	vdiMessage(pImage, "Header: offBlocks=%u offData=%u\n",
1982	getImageBlocksOffset(&pImage->Header),
1983	getImageDataOffset(&pImage->Header));
1984	PVDIDISKGEOMETRY pg = getImageLCHSGeometry(&pImage->Header);
1985	if (pg)
1986	vdiMessage(pImage, "Header: Geometry: C/H/S=%u/%u/%u cbSector=%u\n",
1987	pg->cCylinders, pg->cHeads, pg->cSectors, pg->cbSector);
1988	vdiMessage(pImage, "Header: uuidCreation={%RTuuid}\n", getImageCreationUUID(&pImage->Header));
1989	vdiMessage(pImage, "Header: uuidModification={%RTuuid}\n", getImageModificationUUID(&pImage->Header));
1990	vdiMessage(pImage, "Header: uuidParent={%RTuuid}\n", getImageParentUUID(&pImage->Header));
1991	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) >= 1)
1992	vdiMessage(pImage, "Header: uuidParentModification={%RTuuid}\n", getImageParentModificationUUID(&pImage->Header));
1993	vdiMessage(pImage, "Image: fFlags=%08X offStartBlocks=%u offStartData=%u\n",
1994	pImage->uImageFlags, pImage->offStartBlocks, pImage->offStartData);
1995	vdiMessage(pImage, "Image: uBlockMask=%08X cbTotalBlockData=%u uShiftOffset2Index=%u offStartBlockData=%u\n",
1996	pImage->uBlockMask,
1997	pImage->cbTotalBlockData,
1998	pImage->uShiftOffset2Index,
1999	pImage->offStartBlockData);
2000
2001	unsigned uBlock, cBlocksNotFree, cBadBlocks, cBlocks = getImageBlocks(&pImage->Header);
2002	for (uBlock=0, cBlocksNotFree=0, cBadBlocks=0; uBlock<cBlocks; uBlock++)
2003	{
2004	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2005	{
2006	cBlocksNotFree++;
2007	if (pImage->paBlocks[uBlock] >= cBlocks)
2008	cBadBlocks++;
2009	}
2010	}
2011	if (cBlocksNotFree != getImageBlocksAllocated(&pImage->Header))
2012	{
2013	vdiMessage(pImage, "!! WARNING: %u blocks actually allocated (cBlocksAllocated=%u) !!\n",
2014	cBlocksNotFree, getImageBlocksAllocated(&pImage->Header));
2015	}
2016	if (cBadBlocks)
2017	{
2018	vdiMessage(pImage, "!! WARNING: %u bad blocks found !!\n",
2019	cBadBlocks);
2020	}
2021	}
2022
2023	static bool vdiIsAsyncIOSupported(void *pBackendData)
2024	{
2025	return true;
2026	}
2027
2028	static int vdiAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
2029	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
2030	{
2031	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
2032	pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
2033	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2034	unsigned uBlock;
2035	unsigned offRead;
2036	int rc;
2037
2038	AssertPtr(pImage);
2039	Assert(!(uOffset % 512));
2040	Assert(!(cbToRead % 512));
2041
2042	if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
2043	\|\| !VALID_PTR(pIoCtx)
2044	\|\| !cbToRead)
2045	{
2046	rc = VERR_INVALID_PARAMETER;
2047	goto out;
2048	}
2049
2050	/* Calculate starting block number and offset inside it. */
2051	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
2052	offRead = (unsigned)uOffset & pImage->uBlockMask;
2053
2054	/* Clip read range to at most the rest of the block. */
2055	cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
2056	Assert(!(cbToRead % 512));
2057
2058	if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
2059	rc = VERR_VD_BLOCK_FREE;
2060	else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
2061	{
2062	size_t cbSet;
2063
2064	cbSet = vdiFileIoCtxSet(pImage, pIoCtx, 0, cbToRead);
2065	Assert(cbSet == cbToRead);
2066
2067	rc = VINF_SUCCESS;
2068	}
2069	else
2070	{
2071	/* Block present in image file, read relevant data. */
2072	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
2073	+ (pImage->offStartData + pImage->offStartBlockData + offRead);
2074	rc = vdiFileReadUserAsync(pImage, u64Offset, pIoCtx, cbToRead);
2075	}
2076
2077	if (pcbActuallyRead)
2078	*pcbActuallyRead = cbToRead;
2079
2080	out:
2081	LogFlowFunc(("returns %Rrc\n", rc));
2082	return rc;
2083	}
2084
2085	static int vdiAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
2086	PVDIOCTX pIoCtx,
2087	size_t pcbWriteProcess, size_t pcbPreRead,
2088	size_t *pcbPostRead, unsigned fWrite)
2089	{
2090	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
2091	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
2092	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2093	unsigned uBlock;
2094	unsigned offWrite;
2095	int rc = VINF_SUCCESS;
2096
2097	AssertPtr(pImage);
2098	Assert(!(uOffset % 512));
2099	Assert(!(cbToWrite % 512));
2100
2101	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2102	{
2103	rc = VERR_VD_IMAGE_READ_ONLY;
2104	goto out;
2105	}
2106
2107	if (!VALID_PTR(pIoCtx) \|\| !cbToWrite)
2108	{
2109	rc = VERR_INVALID_PARAMETER;
2110	goto out;
2111	}
2112
2113	/* No size check here, will do that later. For dynamic images which are
2114	* not multiples of the block size in length, this would prevent writing to
2115	* the last block. */
2116
2117	/* Calculate starting block number and offset inside it. */
2118	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
2119	offWrite = (unsigned)uOffset & pImage->uBlockMask;
2120
2121	/* Clip write range to at most the rest of the block. */
2122	cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
2123	Assert(!(cbToWrite % 512));
2124
2125	do
2126	{
2127	if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
2128	{
2129	/* Block is either free or zero. */
2130	if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
2131	&& ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
2132	\|\| cbToWrite == getImageBlockSize(&pImage->Header)))
2133	{
2134	#if 0 /** @todo Provide interface to check an I/O context for a specific value */
2135	/* If the destination block is unallocated at this point, it's
2136	* either a zero block or a block which hasn't been used so far
2137	* (which also means that it's a zero block. Don't need to write
2138	* anything to this block if the data consists of just zeroes. */
2139	Assert(!(cbToWrite % 4));
2140	Assert(cbToWrite * 8 <= UINT32_MAX);
2141	if (ASMBitFirstSet((volatile void )pvBuf, (uint32_t)cbToWrite 8) == -1)
2142	{
2143	pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
2144	break;
2145	}
2146	#endif
2147	}
2148
2149	if ( cbToWrite == getImageBlockSize(&pImage->Header)
2150	&& !(fWrite & VD_WRITE_NO_ALLOC))
2151	{
2152	/* Full block write to previously unallocated block.
2153	* Allocate block and write data. */
2154	Assert(!offWrite);
2155	unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
2156	uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
2157	+ (pImage->offStartData + pImage->offStartBlockData);
2158	rc = vdiFileWriteUserAsync(pImage, u64Offset, pIoCtx, cbToWrite, NULL, NULL);
2159	if (RT_UNLIKELY(RT_FAILURE_NP(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS)))
2160	goto out;
2161	pImage->paBlocks[uBlock] = cBlocksAllocated;
2162	setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
2163
2164	rc = vdiUpdateBlockInfoAsync(pImage, uBlock, pIoCtx);
2165	if (RT_FAILURE(rc) && (rc != VERR_VD_ASYNC_IO_IN_PROGRESS))
2166	goto out;
2167
2168	*pcbPreRead = 0;
2169	*pcbPostRead = 0;
2170	}
2171	else
2172	{
2173	/* Trying to do a partial write to an unallocated block. Don't do
2174	* anything except letting the upper layer know what to do. */
2175	*pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
2176	pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - pcbPreRead;
2177	rc = VERR_VD_BLOCK_FREE;
2178	}
2179	}
2180	else
2181	{
2182	/* Block present in image file, write relevant data. */
2183	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
2184	+ (pImage->offStartData + pImage->offStartBlockData + offWrite);
2185	rc = vdiFileWriteUserAsync(pImage, u64Offset, pIoCtx, cbToWrite, NULL, NULL);
2186	}
2187	} while (0);
2188
2189	if (pcbWriteProcess)
2190	*pcbWriteProcess = cbToWrite;
2191
2192	out:
2193	LogFlowFunc(("returns %Rrc\n", rc));
2194	return rc;
2195	}
2196
2197	static int vdiAsyncFlush(void *pBackendData, PVDIOCTX pIoCtx)
2198	{
2199	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2200	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2201	int rc = VINF_SUCCESS;
2202
2203	Assert(pImage);
2204
2205	rc = vdiFlushImageAsync(pImage, pIoCtx);
2206	LogFlowFunc(("returns %Rrc\n", rc));
2207	return rc;
2208	}
2209
2210	/** @copydoc VBOXHDDBACKEND::pfnCompact */
2211	static int vdiCompact(void *pBackendData, unsigned uPercentStart,
2212	unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
2213	PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation)
2214	{
2215	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2216	int rc = VINF_SUCCESS;
2217	void pvBuf = NULL, pvTmp = NULL;
2218	unsigned *paBlocks2 = NULL;
2219
2220	int (pfnParentRead)(void , uint64_t, void *, size_t) = NULL;
2221	void *pvParent = NULL;
2222	PVDINTERFACE pIfParentState = VDInterfaceGet(pVDIfsOperation,
2223	VDINTERFACETYPE_PARENTSTATE);
2224	PVDINTERFACEPARENTSTATE pCbParentState = NULL;
2225	if (pIfParentState)
2226	{
2227	pCbParentState = VDGetInterfaceParentState(pIfParentState);
2228	if (pCbParentState)
2229	pfnParentRead = pCbParentState->pfnParentRead;
2230	pvParent = pIfParentState->pvUser;
2231	}
2232
2233	PFNVDPROGRESS pfnProgress = NULL;
2234	void *pvUser = NULL;
2235	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
2236	VDINTERFACETYPE_PROGRESS);
2237	PVDINTERFACEPROGRESS pCbProgress = NULL;
2238	if (pIfProgress)
2239	{
2240	pCbProgress = VDGetInterfaceProgress(pIfProgress);
2241	if (pCbProgress)
2242	pfnProgress = pCbProgress->pfnProgress;
2243	pvUser = pIfProgress->pvUser;
2244	}
2245
2246	do {
2247	AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
2248
2249	AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
2250	rc = VERR_VD_IMAGE_READ_ONLY);
2251
2252	unsigned cBlocks;
2253	unsigned cBlocksToMove = 0;
2254	size_t cbBlock;
2255	cBlocks = getImageBlocks(&pImage->Header);
2256	cbBlock = getImageBlockSize(&pImage->Header);
2257	if (pfnParentRead)
2258	{
2259	pvBuf = RTMemTmpAlloc(cbBlock);
2260	AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
2261	}
2262	pvTmp = RTMemTmpAlloc(cbBlock);
2263	AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
2264
2265	uint64_t cbFile;
2266	rc = vdiFileGetSize(pImage, &cbFile);
2267	AssertRCBreak(rc);
2268	unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
2269	if (cBlocksAllocated == 0)
2270	{
2271	/* No data blocks in this image, no need to compact. */
2272	rc = VINF_SUCCESS;
2273	break;
2274	}
2275
2276	/* Allocate block array for back resolving. */
2277	paBlocks2 = (unsigned )RTMemAlloc(sizeof(unsigned ) * cBlocksAllocated);
2278	AssertBreakStmt(VALID_PTR(paBlocks2), rc = VERR_NO_MEMORY);
2279	/* Fill out back resolving, check/fix allocation errors before
2280	* compacting the image, just to be on the safe side. Update the
2281	* image contents straight away, as this enables cancelling. */
2282	for (unsigned i = 0; i < cBlocksAllocated; i++)
2283	paBlocks2[i] = VDI_IMAGE_BLOCK_FREE;
2284	rc = VINF_SUCCESS;
2285	for (unsigned i = 0; i < cBlocks; i++)
2286	{
2287	VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2288	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2289	{
2290	if (ptrBlock < cBlocksAllocated)
2291	{
2292	if (paBlocks2[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
2293	paBlocks2[ptrBlock] = i;
2294	else
2295	{
2296	LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
2297	i, pImage->pszFilename));
2298	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2299	rc = vdiUpdateBlockInfo(pImage, i);
2300	if (RT_FAILURE(rc))
2301	break;
2302	}
2303	}
2304	else
2305	{
2306	LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
2307	i, pImage->pszFilename));
2308	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2309	rc = vdiUpdateBlockInfo(pImage, i);
2310	if (RT_FAILURE(rc))
2311	break;
2312	}
2313	}
2314	}
2315	if (RT_FAILURE(rc))
2316	break;
2317
2318	/* Find redundant information and update the block pointers
2319	* accordingly, creating bubbles. Keep disk up to date, as this
2320	* enables cancelling. */
2321	for (unsigned i = 0; i < cBlocks; i++)
2322	{
2323	VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
2324	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
2325	{
2326	/* Block present in image file, read relevant data. */
2327	uint64_t u64Offset = (uint64_t)ptrBlock * pImage->cbTotalBlockData
2328	+ (pImage->offStartData + pImage->offStartBlockData);
2329	rc = vdiFileReadSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2330	if (RT_FAILURE(rc))
2331	break;
2332
2333	if (ASMBitFirstSet((volatile void )pvTmp, (uint32_t)cbBlock 8) == -1)
2334	{
2335	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
2336	rc = vdiUpdateBlockInfo(pImage, i);
2337	if (RT_FAILURE(rc))
2338	break;
2339	paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2340	/* Adjust progress info, one block to be relocated. */
2341	cBlocksToMove++;
2342	}
2343	else if (pfnParentRead)
2344	{
2345	rc = pfnParentRead(pvParent, i * cbBlock, pvBuf, cbBlock);
2346	if (RT_FAILURE(rc))
2347	break;
2348	if (!memcmp(pvTmp, pvBuf, cbBlock))
2349	{
2350	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
2351	rc = vdiUpdateBlockInfo(pImage, i);
2352	if (RT_FAILURE(rc))
2353	break;
2354	paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
2355	/* Adjust progress info, one block to be relocated. */
2356	cBlocksToMove++;
2357	}
2358	}
2359	}
2360
2361	if (pCbProgress && pCbProgress->pfnProgress)
2362	{
2363	rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
2364	(uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2365	if (RT_FAILURE(rc))
2366	break;
2367	}
2368	}
2369	if (RT_FAILURE(rc))
2370	break;
2371
2372	/* Fill bubbles with other data (if available). */
2373	unsigned cBlocksMoved = 0;
2374	unsigned uBlockUsedPos = cBlocksAllocated;
2375	for (unsigned i = 0; i < cBlocksAllocated; i++)
2376	{
2377	unsigned uBlock = paBlocks2[i];
2378	if (uBlock == VDI_IMAGE_BLOCK_FREE)
2379	{
2380	unsigned uBlockData = VDI_IMAGE_BLOCK_FREE;
2381	while (uBlockUsedPos > i && uBlockData == VDI_IMAGE_BLOCK_FREE)
2382	{
2383	uBlockUsedPos--;
2384	uBlockData = paBlocks2[uBlockUsedPos];
2385	}
2386	/* Terminate early if there is no block which needs copying. */
2387	if (uBlockUsedPos == i)
2388	break;
2389	uint64_t u64Offset = (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2390	+ (pImage->offStartData + pImage->offStartBlockData);
2391	rc = vdiFileReadSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2392	u64Offset = (uint64_t)i * pImage->cbTotalBlockData
2393	+ (pImage->offStartData + pImage->offStartBlockData);
2394	rc = vdiFileWriteSync(pImage, u64Offset, pvTmp, cbBlock, NULL);
2395	pImage->paBlocks[uBlockData] = i;
2396	setImageBlocksAllocated(&pImage->Header, cBlocksAllocated - cBlocksMoved);
2397	rc = vdiUpdateBlockInfo(pImage, uBlockData);
2398	if (RT_FAILURE(rc))
2399	break;
2400	paBlocks2[i] = uBlockData;
2401	paBlocks2[uBlockUsedPos] = VDI_IMAGE_BLOCK_FREE;
2402	cBlocksMoved++;
2403	}
2404
2405	if (pCbProgress && pCbProgress->pfnProgress)
2406	{
2407	rc = pCbProgress->pfnProgress(pIfProgress->pvUser,
2408	(uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart);
2409
2410	if (RT_FAILURE(rc))
2411	break;
2412	}
2413	}
2414	if (RT_FAILURE(rc))
2415	break;
2416
2417	/* Update image header. */
2418	setImageBlocksAllocated(&pImage->Header, uBlockUsedPos);
2419	vdiUpdateHeader(pImage);
2420
2421	/* Truncate the image to the proper size to finish compacting. */
2422	rc = vdiFileSetSize(pImage,
2423	(uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2424	+ pImage->offStartData + pImage->offStartBlockData);
2425	} while (0);
2426
2427	if (paBlocks2)
2428	RTMemTmpFree(paBlocks2);
2429	if (pvTmp)
2430	RTMemTmpFree(pvTmp);
2431	if (pvBuf)
2432	RTMemTmpFree(pvBuf);
2433
2434	if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
2435	{
2436	pCbProgress->pfnProgress(pIfProgress->pvUser,
2437	uPercentStart + uPercentSpan);
2438	}
2439
2440	LogFlowFunc(("returns %Rrc\n", rc));
2441	return rc;
2442	}
2443
2444
2445	/** @copydoc VBOXHDDBACKEND::pfnResize */
2446	static int vdiResize(void *pBackendData, uint64_t cbSize,
2447	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
2448	unsigned uPercentStart, unsigned uPercentSpan,
2449	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
2450	PVDINTERFACE pVDIfsOperation)
2451	{
2452	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
2453	int rc = VINF_SUCCESS;
2454
2455	PFNVDPROGRESS pfnProgress = NULL;
2456	void *pvUser = NULL;
2457	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
2458	VDINTERFACETYPE_PROGRESS);
2459	PVDINTERFACEPROGRESS pCbProgress = NULL;
2460	if (pIfProgress)
2461	{
2462	pCbProgress = VDGetInterfaceProgress(pIfProgress);
2463	if (pCbProgress)
2464	pfnProgress = pCbProgress->pfnProgress;
2465	pvUser = pIfProgress->pvUser;
2466	}
2467
2468	/*
2469	* Making the image smaller is not supported at the moment.
2470	* Resizing is also not supported for fixed size images and
2471	* very old images.
2472	*/
2473	/** @todo implement making the image smaller, it is the responsibility of
2474	* the user to know what he's doing. */
2475	if ( cbSize < getImageDiskSize(&pImage->Header)
2476	\|\| GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0
2477	\|\| pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
2478	rc = VERR_NOT_SUPPORTED;
2479	else if (cbSize > getImageDiskSize(&pImage->Header))
2480	{
2481	unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header); /** < Blocks currently allocated, doesn't change during resize */
2482	uint32_t cBlocksNew = cbSize / getImageBlockSize(&pImage->Header); /** < New number of blocks in the image after the resize */
2483	if (cbSize % getImageBlockSize(&pImage->Header))
2484	cBlocksNew++;
2485
2486	uint32_t cBlocksOld = getImageBlocks(&pImage->Header); /** < Number of blocks before the resize. */
2487	uint64_t cbBlockspaceNew = cBlocksNew * sizeof(VDIIMAGEBLOCKPOINTER); /** < Required space for the block array after the resize. */
2488	uint64_t offStartDataNew = RT_ALIGN_32(pImage->offStartBlocks + cbBlockspaceNew, VDI_DATA_ALIGN); /** < New start offset for block data after the resize */
2489
2490	if ( pImage->offStartData != offStartDataNew
2491	&& cBlocksAllocated > 0)
2492	{
2493	/* Calculate how many sectors need to be relocated. */
2494	uint64_t cbOverlapping = offStartDataNew - pImage->offStartData;
2495	unsigned cBlocksReloc = cbOverlapping / getImageBlockSize(&pImage->Header);
2496	if (cbOverlapping % getImageBlockSize(&pImage->Header))
2497	cBlocksReloc++;
2498
2499	/* Since only full blocks can be relocated the new data start is
2500	* determined by moving it block by block. */
2501	cBlocksReloc = RT_MIN(cBlocksReloc, cBlocksAllocated);
2502	offStartDataNew = pImage->offStartData;
2503
2504	/* Do the relocation. */
2505	LogFlow(("Relocating %u blocks\n", cBlocksReloc));
2506
2507	/*
2508	* Get the blocks we need to relocate first, they are appended to the end
2509	* of the image.
2510	*/
2511	void pvBuf = NULL, pvZero = NULL;
2512	do
2513	{
2514	VDIIMAGEBLOCKPOINTER uBlock = 0;
2515
2516	/* Allocate data buffer. */
2517	pvBuf = RTMemAllocZ(pImage->cbTotalBlockData);
2518	if (!pvBuf)
2519	{
2520	rc = VERR_NO_MEMORY;
2521	break;
2522	}
2523
2524	/* Allocate buffer for overwriting with zeroes. */
2525	pvZero = RTMemAllocZ(pImage->cbTotalBlockData);
2526	if (!pvZero)
2527	{
2528	rc = VERR_NO_MEMORY;
2529	break;
2530	}
2531
2532	for (unsigned i = 0; i < cBlocksReloc; i++)
2533	{
2534	/* Search the index in the block table. */
2535	for (unsigned idxBlock = 0; idxBlock < cBlocksOld; idxBlock++)
2536	{
2537	if (pImage->paBlocks[idxBlock] == uBlock)
2538	{
2539	/* Read data and append to the end of the image. */
2540	rc = vdiFileReadSync(pImage, offStartDataNew, pvBuf, pImage->cbTotalBlockData, NULL);
2541	if (RT_FAILURE(rc))
2542	break;
2543
2544	uint64_t offBlockAppend;
2545	rc = vdiFileGetSize(pImage, &offBlockAppend);
2546	if (RT_FAILURE(rc))
2547	break;
2548
2549	rc = vdiFileWriteSync(pImage, offBlockAppend, pvBuf, pImage->cbTotalBlockData, NULL);
2550	if (RT_FAILURE(rc))
2551	break;
2552
2553	/* Zero out the old block area. */
2554	rc = vdiFileWriteSync(pImage, offStartDataNew, pvZero, pImage->cbTotalBlockData, NULL);
2555	if (RT_FAILURE(rc))
2556	break;
2557
2558	/* Update block counter. */
2559	pImage->paBlocks[idxBlock] = cBlocksAllocated - 1;
2560
2561	/*
2562	* Decrease the block number of all other entries in the array.
2563	* They were moved one block to the front.
2564	* Doing it as a separate step iterating over the array again
2565	* because an error while relocating the block might end up
2566	* in a corrupted image otherwise.
2567	*/
2568	for (unsigned idxBlock2 = 0; idxBlock2 < cBlocksOld; idxBlock2++)
2569	{
2570	if ( idxBlock2 != idxBlock
2571	&& IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[idxBlock2]))
2572	pImage->paBlocks[idxBlock2]--;
2573	}
2574
2575	/* Continue with the next block. */
2576	break;
2577	}
2578	}
2579
2580	if (RT_FAILURE(rc))
2581	break;
2582
2583	uBlock++;
2584	offStartDataNew += pImage->cbTotalBlockData;
2585	}
2586	} while (0);
2587
2588	if (pvBuf)
2589	RTMemFree(pvBuf);
2590	if (pvZero)
2591	RTMemFree(pvZero);
2592	}
2593
2594	/*
2595	* We need to update the new offsets for the image data in the out of memory
2596	* case too because we relocated the blocks already.
2597	*/
2598	pImage->offStartData = offStartDataNew;
2599	setImageDataOffset(&pImage->Header, offStartDataNew);
2600
2601	/*
2602	* Relocation done, expand the block array and update the header with
2603	* the new data.
2604	*/
2605	if (RT_SUCCESS(rc))
2606	{
2607	PVDIIMAGEBLOCKPOINTER paBlocksNew = (PVDIIMAGEBLOCKPOINTER)RTMemRealloc(pImage->paBlocks, cbBlockspaceNew);
2608	if (paBlocksNew)
2609	{
2610	pImage->paBlocks = paBlocksNew;
2611
2612	/* Mark the new blocks as unallocated. */
2613	for (unsigned idxBlock = cBlocksOld; idxBlock < cBlocksNew; idxBlock++)
2614	pImage->paBlocks[idxBlock] = VDI_IMAGE_BLOCK_FREE;
2615	}
2616	else
2617	rc = VERR_NO_MEMORY;
2618
2619	/* Write the block array before updating the rest. */
2620	rc = vdiFileWriteSync(pImage, pImage->offStartBlocks, pImage->paBlocks,
2621	cbBlockspaceNew, NULL);
2622
2623	if (RT_SUCCESS(rc))
2624	{
2625	/* Update size and new block count. */
2626	setImageDiskSize(&pImage->Header, cbSize);
2627	setImageBlocks(&pImage->Header, cBlocksNew);
2628	/* Update geometry. */
2629	pImage->PCHSGeometry = *pPCHSGeometry;
2630
2631	PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
2632	if (pGeometry)
2633	{
2634	pGeometry->cCylinders = pLCHSGeometry->cCylinders;
2635	pGeometry->cHeads = pLCHSGeometry->cHeads;
2636	pGeometry->cSectors = pLCHSGeometry->cSectors;
2637	pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
2638	}
2639	}
2640	}
2641
2642	/* Update header information in base image file. */
2643	vdiFlushImage(pImage);
2644	}
2645	/* Same size doesn't change the image at all. */
2646
2647	LogFlowFunc(("returns %Rrc\n", rc));
2648	return rc;
2649	}
2650
2651
2652	VBOXHDDBACKEND g_VDIBackend =
2653	{
2654	/* pszBackendName */
2655	"VDI",
2656	/* cbSize */
2657	sizeof(VBOXHDDBACKEND),
2658	/* uBackendCaps */
2659	VD_CAP_UUID \| VD_CAP_CREATE_FIXED \| VD_CAP_CREATE_DYNAMIC
2660	\| VD_CAP_DIFF \| VD_CAP_FILE \| VD_CAP_ASYNC \| VD_CAP_VFS,
2661	/* paFileExtensions */
2662	s_aVdiFileExtensions,
2663	/* paConfigInfo */
2664	NULL,
2665	/* hPlugin */
2666	NIL_RTLDRMOD,
2667	/* pfnCheckIfValid */
2668	vdiCheckIfValid,
2669	/* pfnOpen */
2670	vdiOpen,
2671	/* pfnCreate */
2672	vdiCreate,
2673	/* pfnRename */
2674	vdiRename,
2675	/* pfnClose */
2676	vdiClose,
2677	/* pfnRead */
2678	vdiRead,
2679	/* pfnWrite */
2680	vdiWrite,
2681	/* pfnFlush */
2682	vdiFlush,
2683	/* pfnGetVersion */
2684	vdiGetVersion,
2685	/* pfnGetSize */
2686	vdiGetSize,
2687	/* pfnGetFileSize */
2688	vdiGetFileSize,
2689	/* pfnGetPCHSGeometry */
2690	vdiGetPCHSGeometry,
2691	/* pfnSetPCHSGeometry */
2692	vdiSetPCHSGeometry,
2693	/* pfnGetLCHSGeometry */
2694	vdiGetLCHSGeometry,
2695	/* pfnSetLCHSGeometry */
2696	vdiSetLCHSGeometry,
2697	/* pfnGetImageFlags */
2698	vdiGetImageFlags,
2699	/* pfnGetOpenFlags */
2700	vdiGetOpenFlags,
2701	/* pfnSetOpenFlags */
2702	vdiSetOpenFlags,
2703	/* pfnGetComment */
2704	vdiGetComment,
2705	/* pfnSetComment */
2706	vdiSetComment,
2707	/* pfnGetUuid */
2708	vdiGetUuid,
2709	/* pfnSetUuid */
2710	vdiSetUuid,
2711	/* pfnGetModificationUuid */
2712	vdiGetModificationUuid,
2713	/* pfnSetModificationUuid */
2714	vdiSetModificationUuid,
2715	/* pfnGetParentUuid */
2716	vdiGetParentUuid,
2717	/* pfnSetParentUuid */
2718	vdiSetParentUuid,
2719	/* pfnGetParentModificationUuid */
2720	vdiGetParentModificationUuid,
2721	/* pfnSetParentModificationUuid */
2722	vdiSetParentModificationUuid,
2723	/* pfnDump */
2724	vdiDump,
2725	/* pfnGetTimeStamp */
2726	NULL,
2727	/* pfnGetParentTimeStamp */
2728	NULL,
2729	/* pfnSetParentTimeStamp */
2730	NULL,
2731	/* pfnGetParentFilename */
2732	NULL,
2733	/* pfnSetParentFilename */
2734	NULL,
2735	/* pfnIsAsyncIOSupported */
2736	vdiIsAsyncIOSupported,
2737	/* pfnAsyncRead */
2738	vdiAsyncRead,
2739	/* pfnAsyncWrite */
2740	vdiAsyncWrite,
2741	/* pfnAsyncFlush */
2742	vdiAsyncFlush,
2743	/* pfnComposeLocation */
2744	genericFileComposeLocation,
2745	/* pfnComposeName */
2746	genericFileComposeName,
2747	/* pfnCompact */
2748	vdiCompact,
2749	/* pfnResize */
2750	vdiResize
2751	};

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

source: vbox/trunk/src/VBox/Storage/VDI.cpp@ 33567

Download in other formats: