VDIHDDCore.cpp@ 19223

Last change on this file since 19223 was 19202, checked in by vboxsync, 16 years ago
Storage/VDI: fix several bugs with compaction, deal with images which have no allocated data blocks, get the same block detection right and terminate the loop searching for a block to move into a bubble
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 71.0 KB

Line
1	/** @file
2	* Virtual Disk Image (VDI), Core Code.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
17	* Clara, CA 95054 USA or visit http://www.sun.com if you need
18	* additional information or have any questions.
19	*/
20
21	/*******************************************************************************
22	* Header Files *
23	*******************************************************************************/
24	#define LOG_GROUP LOG_GROUP_VD_VDI
25	#include "VBoxHDD-Internal.h"
26	#define VBOX_VDICORE_VD /* Signal that the header is included from here. */
27	#include "VDICore.h"
28	#include <VBox/err.h>
29
30	#include <VBox/log.h>
31	#include <iprt/alloc.h>
32	#include <iprt/assert.h>
33	#include <iprt/uuid.h>
34	#include <iprt/file.h>
35	#include <iprt/string.h>
36	#include <iprt/asm.h>
37
38	#define VDI_IMAGE_DEFAULT_BLOCK_SIZE _1M
39
40	/*******************************************************************************
41	* Static Variables *
42	*******************************************************************************/
43
44	/** NULL-terminated array of supported file extensions. */
45	static const char *const s_apszVdiFileExtensions[] =
46	{
47	"vdi",
48	NULL
49	};
50
51	/*******************************************************************************
52	* Internal Functions *
53	*******************************************************************************/
54	static unsigned getPowerOfTwo(unsigned uNumber);
55	static void vdiInitPreHeader(PVDIPREHEADER pPreHdr);
56	static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr);
57	static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
58	const char *pszComment, uint64_t cbDisk,
59	uint32_t cbBlock, uint32_t cbBlockExtra);
60	static int vdiValidateHeader(PVDIHEADER pHeader);
61	static void vdiSetupImageDesc(PVDIIMAGEDESC pImage);
62	static int vdiUpdateHeader(PVDIIMAGEDESC pImage);
63	static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock);
64	static void vdiFreeImage(PVDIIMAGEDESC pImage, bool fDelete);
65
66
67	/**
68	* Internal: signal an error to the frontend.
69	*/
70	DECLINLINE(int) vdiError(PVDIIMAGEDESC pImage, int rc, RT_SRC_POS_DECL,
71	const char *pszFormat, ...)
72	{
73	va_list va;
74	va_start(va, pszFormat);
75	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
76	pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser,
77	rc, RT_SRC_POS_ARGS,
78	pszFormat, va);
79	va_end(va);
80	return rc;
81	}
82
83
84	/**
85	* internal: return power of 2 or 0 if num error.
86	*/
87	static unsigned getPowerOfTwo(unsigned uNumber)
88	{
89	if (uNumber == 0)
90	return 0;
91	unsigned uPower2 = 0;
92	while ((uNumber & 1) == 0)
93	{
94	uNumber >>= 1;
95	uPower2++;
96	}
97	return uNumber == 1 ? uPower2 : 0;
98	}
99
100
101	/**
102	* Internal: Init VDI preheader.
103	*/
104	static void vdiInitPreHeader(PVDIPREHEADER pPreHdr)
105	{
106	pPreHdr->u32Signature = VDI_IMAGE_SIGNATURE;
107	pPreHdr->u32Version = VDI_IMAGE_VERSION;
108	memset(pPreHdr->szFileInfo, 0, sizeof(pPreHdr->szFileInfo));
109	strncat(pPreHdr->szFileInfo, VDI_IMAGE_FILE_INFO, sizeof(pPreHdr->szFileInfo));
110	}
111
112	/**
113	* Internal: check VDI preheader.
114	*/
115	static int vdiValidatePreHeader(PVDIPREHEADER pPreHdr)
116	{
117	if (pPreHdr->u32Signature != VDI_IMAGE_SIGNATURE)
118	return VERR_VD_VDI_INVALID_HEADER;
119
120	if ( VDI_GET_VERSION_MAJOR(pPreHdr->u32Version) != VDI_IMAGE_VERSION_MAJOR
121	&& pPreHdr->u32Version != 0x00000002) /* old version. */
122	return VERR_VD_VDI_UNSUPPORTED_VERSION;
123
124	return VINF_SUCCESS;
125	}
126
127	/**
128	* Internal: translate VD image flags to VDI image type enum.
129	*/
130	static VDIIMAGETYPE vdiTranslateImageFlags2VDI(unsigned uImageFlags)
131	{
132	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
133	return VDI_IMAGE_TYPE_FIXED;
134	else if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
135	return VDI_IMAGE_TYPE_DIFF;
136	else
137	return VDI_IMAGE_TYPE_NORMAL;
138	}
139
140	/**
141	* Internal: translate VDI image type enum to VD image type enum.
142	*/
143	static unsigned vdiTranslateVDI2ImageFlags(VDIIMAGETYPE enmType)
144	{
145	switch (enmType)
146	{
147	case VDI_IMAGE_TYPE_NORMAL:
148	return VD_IMAGE_FLAGS_NONE;
149	case VDI_IMAGE_TYPE_FIXED:
150	return VD_IMAGE_FLAGS_FIXED;
151	case VDI_IMAGE_TYPE_DIFF:
152	return VD_IMAGE_FLAGS_DIFF;
153	default:
154	AssertMsgFailed(("invalid VDIIMAGETYPE enmType=%d\n", (int)enmType));
155	return VD_IMAGE_FLAGS_NONE;
156	}
157	}
158
159	/**
160	* Internal: Init VDI header. Always use latest header version.
161	* @param pHeader Assumes it was initially initialized to all zeros.
162	*/
163	static void vdiInitHeader(PVDIHEADER pHeader, uint32_t uImageFlags,
164	const char *pszComment, uint64_t cbDisk,
165	uint32_t cbBlock, uint32_t cbBlockExtra)
166	{
167	pHeader->uVersion = VDI_IMAGE_VERSION;
168	pHeader->u.v1.cbHeader = sizeof(VDIHEADER1);
169	pHeader->u.v1.u32Type = (uint32_t)vdiTranslateImageFlags2VDI(uImageFlags);
170	pHeader->u.v1.fFlags = (uImageFlags & VD_VDI_IMAGE_FLAGS_ZERO_EXPAND) ? 1 : 0;
171	#ifdef VBOX_STRICT
172	char achZero[VDI_IMAGE_COMMENT_SIZE] = {0};
173	Assert(!memcmp(pHeader->u.v1.szComment, achZero, VDI_IMAGE_COMMENT_SIZE));
174	#endif
175	pHeader->u.v1.szComment[0] = '\0';
176	if (pszComment)
177	{
178	AssertMsg(strlen(pszComment) < sizeof(pHeader->u.v1.szComment),
179	("HDD Comment is too long, cb=%d\n", strlen(pszComment)));
180	strncat(pHeader->u.v1.szComment, pszComment, sizeof(pHeader->u.v1.szComment));
181	}
182
183	/* Mark the legacy geometry not-calculated. */
184	pHeader->u.v1.LegacyGeometry.cCylinders = 0;
185	pHeader->u.v1.LegacyGeometry.cHeads = 0;
186	pHeader->u.v1.LegacyGeometry.cSectors = 0;
187	pHeader->u.v1.LegacyGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
188	pHeader->u.v1.u32Dummy = 0; /* used to be the translation value */
189
190	pHeader->u.v1.cbDisk = cbDisk;
191	pHeader->u.v1.cbBlock = cbBlock;
192	pHeader->u.v1.cBlocks = (uint32_t)(cbDisk / cbBlock);
193	if (cbDisk % cbBlock)
194	pHeader->u.v1.cBlocks++;
195	pHeader->u.v1.cbBlockExtra = cbBlockExtra;
196	pHeader->u.v1.cBlocksAllocated = 0;
197
198	/* Init offsets. */
199	pHeader->u.v1.offBlocks = RT_ALIGN_32(sizeof(VDIPREHEADER) + sizeof(VDIHEADER1), VDI_GEOMETRY_SECTOR_SIZE);
200	pHeader->u.v1.offData = RT_ALIGN_32(pHeader->u.v1.offBlocks + (pHeader->u.v1.cBlocks * sizeof(VDIIMAGEBLOCKPOINTER)), VDI_GEOMETRY_SECTOR_SIZE);
201
202	/* Init uuids. */
203	RTUuidCreate(&pHeader->u.v1.uuidCreate);
204	RTUuidClear(&pHeader->u.v1.uuidModify);
205	RTUuidClear(&pHeader->u.v1.uuidLinkage);
206	RTUuidClear(&pHeader->u.v1.uuidParentModify);
207
208	/* Mark LCHS geometry not-calculated. */
209	pHeader->u.v1plus.LCHSGeometry.cCylinders = 0;
210	pHeader->u.v1plus.LCHSGeometry.cHeads = 0;
211	pHeader->u.v1plus.LCHSGeometry.cSectors = 0;
212	pHeader->u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
213	}
214
215	/**
216	* Internal: Check VDI header.
217	*/
218	static int vdiValidateHeader(PVDIHEADER pHeader)
219	{
220	/* Check version-dependend header parameters. */
221	switch (GET_MAJOR_HEADER_VERSION(pHeader))
222	{
223	case 0:
224	{
225	/* Old header version. */
226	break;
227	}
228	case 1:
229	{
230	/* Current header version. */
231
232	if (pHeader->u.v1.cbHeader < sizeof(VDIHEADER1))
233	{
234	LogRel(("VDI: v1 header size wrong (%d < %d)\n",
235	pHeader->u.v1.cbHeader, sizeof(VDIHEADER1)));
236	return VERR_VD_VDI_INVALID_HEADER;
237	}
238
239	if (getImageBlocksOffset(pHeader) < (sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)))
240	{
241	LogRel(("VDI: v1 blocks offset wrong (%d < %d)\n",
242	getImageBlocksOffset(pHeader), sizeof(VDIPREHEADER) + sizeof(VDIHEADER1)));
243	return VERR_VD_VDI_INVALID_HEADER;
244	}
245
246	if (getImageDataOffset(pHeader) < (getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)))
247	{
248	LogRel(("VDI: v1 image data offset wrong (%d < %d)\n",
249	getImageDataOffset(pHeader), getImageBlocksOffset(pHeader) + getImageBlocks(pHeader) * sizeof(VDIIMAGEBLOCKPOINTER)));
250	return VERR_VD_VDI_INVALID_HEADER;
251	}
252
253	break;
254	}
255	default:
256	/* Unsupported. */
257	return VERR_VD_VDI_UNSUPPORTED_VERSION;
258	}
259
260	/* Check common header parameters. */
261
262	bool fFailed = false;
263
264	if ( getImageType(pHeader) < VDI_IMAGE_TYPE_FIRST
265	\|\| getImageType(pHeader) > VDI_IMAGE_TYPE_LAST)
266	{
267	LogRel(("VDI: bad image type %d\n", getImageType(pHeader)));
268	fFailed = true;
269	}
270
271	if (getImageFlags(pHeader) & ~VD_VDI_IMAGE_FLAGS_MASK)
272	{
273	LogRel(("VDI: bad image flags %08x\n", getImageFlags(pHeader)));
274	fFailed = true;
275	}
276
277	if ( getImageLCHSGeometry(pHeader)
278	&& (getImageLCHSGeometry(pHeader))->cbSector != VDI_GEOMETRY_SECTOR_SIZE)
279	{
280	LogRel(("VDI: wrong sector size (%d != %d)\n",
281	(getImageLCHSGeometry(pHeader))->cbSector, VDI_GEOMETRY_SECTOR_SIZE));
282	fFailed = true;
283	}
284
285	if ( getImageDiskSize(pHeader) == 0
286	\|\| getImageBlockSize(pHeader) == 0
287	\|\| getImageBlocks(pHeader) == 0
288	\|\| getPowerOfTwo(getImageBlockSize(pHeader)) == 0)
289	{
290	LogRel(("VDI: wrong size (%lld, %d, %d, %d)\n",
291	getImageDiskSize(pHeader), getImageBlockSize(pHeader),
292	getImageBlocks(pHeader), getPowerOfTwo(getImageBlockSize(pHeader))));
293	fFailed = true;
294	}
295
296	if (getImageBlocksAllocated(pHeader) > getImageBlocks(pHeader))
297	{
298	LogRel(("VDI: too many blocks allocated (%d > %d)\n"
299	" blocksize=%d disksize=%lld\n",
300	getImageBlocksAllocated(pHeader), getImageBlocks(pHeader),
301	getImageBlockSize(pHeader), getImageDiskSize(pHeader)));
302	fFailed = true;
303	}
304
305	if ( getImageExtraBlockSize(pHeader) != 0
306	&& getPowerOfTwo(getImageExtraBlockSize(pHeader)) == 0)
307	{
308	LogRel(("VDI: wrong extra size (%d, %d)\n",
309	getImageExtraBlockSize(pHeader), getPowerOfTwo(getImageExtraBlockSize(pHeader))));
310	fFailed = true;
311	}
312
313	if ((uint64_t)getImageBlockSize(pHeader) * getImageBlocks(pHeader) < getImageDiskSize(pHeader))
314	{
315	LogRel(("VDI: wrong disk size (%d, %d, %lld)\n",
316	getImageBlockSize(pHeader), getImageBlocks(pHeader), getImageDiskSize(pHeader)));
317	fFailed = true;
318	}
319
320	if (RTUuidIsNull(getImageCreationUUID(pHeader)))
321	{
322	LogRel(("VDI: uuid of creator is 0\n"));
323	fFailed = true;
324	}
325
326	if (RTUuidIsNull(getImageModificationUUID(pHeader)))
327	{
328	LogRel(("VDI: uuid of modificator is 0\n"));
329	fFailed = true;
330	}
331
332	return fFailed ? VERR_VD_VDI_INVALID_HEADER : VINF_SUCCESS;
333	}
334
335	/**
336	* Internal: Set up VDIIMAGEDESC structure by image header.
337	*/
338	static void vdiSetupImageDesc(PVDIIMAGEDESC pImage)
339	{
340	pImage->uImageFlags = getImageFlags(&pImage->Header);
341	pImage->uImageFlags \|= vdiTranslateVDI2ImageFlags(getImageType(&pImage->Header));
342	pImage->offStartBlocks = getImageBlocksOffset(&pImage->Header);
343	pImage->offStartData = getImageDataOffset(&pImage->Header);
344	pImage->uBlockMask = getImageBlockSize(&pImage->Header) - 1;
345	pImage->uShiftOffset2Index = getPowerOfTwo(getImageBlockSize(&pImage->Header));
346	pImage->offStartBlockData = getImageExtraBlockSize(&pImage->Header);
347	pImage->cbTotalBlockData = pImage->offStartBlockData
348	+ getImageBlockSize(&pImage->Header);
349	}
350
351	/**
352	* Internal: Create VDI image file.
353	*/
354	static int vdiCreateImage(PVDIIMAGEDESC pImage, uint64_t cbSize,
355	unsigned uImageFlags, const char *pszComment,
356	PCPDMMEDIAGEOMETRY pPCHSGeometry,
357	PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
358	PFNVMPROGRESS pfnProgress, void *pvUser,
359	unsigned uPercentStart, unsigned uPercentSpan)
360	{
361	int rc;
362	RTFILE File;
363	uint64_t cbTotal;
364	uint64_t cbFill;
365	uint64_t uOff;
366
367	/* Special check for comment length. */
368	if ( VALID_PTR(pszComment)
369	&& strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
370	{
371	rc = vdiError(pImage, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS, N_("VDI: comment is too long for '%s'"), pImage->pszFilename);
372	goto out;
373	}
374	AssertPtr(pPCHSGeometry);
375	AssertPtr(pLCHSGeometry);
376
377	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
378	if (pImage->pInterfaceError)
379	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
380
381	vdiInitPreHeader(&pImage->PreHeader);
382	vdiInitHeader(&pImage->Header, uImageFlags, pszComment, cbSize, VDI_IMAGE_DEFAULT_BLOCK_SIZE, 0);
383	/* Save PCHS geometry. Not much work, and makes the flow of information
384	* quite a bit clearer - relying on the higher level isn't obvious. */
385	pImage->PCHSGeometry = *pPCHSGeometry;
386	/* Set LCHS geometry (legacy geometry is ignored for the current 1.1+). */
387	pImage->Header.u.v1plus.LCHSGeometry.cCylinders = pLCHSGeometry->cCylinders;
388	pImage->Header.u.v1plus.LCHSGeometry.cHeads = pLCHSGeometry->cHeads;
389	pImage->Header.u.v1plus.LCHSGeometry.cSectors = pLCHSGeometry->cSectors;
390	pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
391
392	pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
393	if (!pImage->paBlocks)
394	{
395	rc = VERR_NO_MEMORY;
396	goto out;
397	}
398
399	if (!(uImageFlags & VD_IMAGE_FLAGS_FIXED))
400	{
401	/* for growing images mark all blocks in paBlocks as free. */
402	for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
403	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
404	}
405	else
406	{
407	/* for fixed images mark all blocks in paBlocks as allocated */
408	for (unsigned i = 0; i < pImage->Header.u.v1.cBlocks; i++)
409	pImage->paBlocks[i] = i;
410	pImage->Header.u.v1.cBlocksAllocated = pImage->Header.u.v1.cBlocks;
411	}
412
413	/* Setup image parameters. */
414	vdiSetupImageDesc(pImage);
415
416	/* Create image file. */
417	rc = RTFileOpen(&File, pImage->pszFilename,
418	RTFILE_O_READWRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_ALL);
419	if (RT_FAILURE(rc))
420	{
421	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: cannot create image '%s'"), pImage->pszFilename);
422	goto out;
423	}
424	pImage->File = File;
425
426	cbTotal = pImage->offStartData
427	+ (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
428
429	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
430	{
431	/* Check the free space on the disk and leave early if there is not
432	* sufficient space available. */
433	RTFOFF cbFree = 0;
434	rc = RTFsQuerySizes(pImage->pszFilename, NULL, &cbFree, NULL, NULL);
435	if (RT_SUCCESS(rc) /* ignore errors */ && ((uint64_t)cbFree < cbTotal))
436	{
437	rc = vdiError(pImage, VERR_DISK_FULL, RT_SRC_POS, N_("VDI: disk would overflow creating image '%s'"), pImage->pszFilename);
438	goto out;
439	}
440	}
441
442	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
443	{
444	/*
445	* Allocate & commit whole file if fixed image, it must be more
446	* effective than expanding file by write operations.
447	*/
448	rc = RTFileSetSize(File, cbTotal);
449	}
450	else
451	{
452	/* Set file size to hold header and blocks array. */
453	rc = RTFileSetSize(pImage->File, pImage->offStartData);
454	}
455	if (RT_FAILURE(rc))
456	{
457	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: setting image size failed for '%s'"), pImage->pszFilename);
458	goto out;
459	}
460
461	/* Use specified image uuid */
462	getImageCreationUUID(&pImage->Header) = pUuid;
463
464	/* Generate image last-modify uuid */
465	RTUuidCreate(getImageModificationUUID(&pImage->Header));
466
467	/* Write pre-header. */
468	rc = RTFileWriteAt(File, 0, &pImage->PreHeader, sizeof(pImage->PreHeader), NULL);
469	if (RT_FAILURE(rc))
470	{
471	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing pre-header failed for '%s'"), pImage->pszFilename);
472	goto out;
473	}
474
475	/* Write header. */
476	rc = RTFileWriteAt(File, sizeof(pImage->PreHeader), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
477	if (RT_FAILURE(rc))
478	{
479	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing header failed for '%s'"), pImage->pszFilename);
480	goto out;
481	}
482
483	rc = RTFileWriteAt(File, pImage->offStartBlocks,
484	pImage->paBlocks,
485	getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
486	NULL);
487	if (RT_FAILURE(rc))
488	{
489	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block pointers failed for '%s'"), pImage->pszFilename);
490	goto out;
491	}
492
493	if (uImageFlags & VD_IMAGE_FLAGS_FIXED)
494	{
495	/* Fill image with zeroes. We do this for every fixed-size image since on some systems
496	* (for example Windows Vista), it takes ages to write a block near the end of a sparse
497	* file and the guest could complain about an ATA timeout. */
498
499	/** @todo Starting with Linux 2.6.23, there is an fallocate() system call.
500	* Currently supported file systems are ext4 and ocfs2. */
501
502	/* Allocate a temporary zero-filled buffer. Use a bigger block size to optimize writing */
503	const size_t cbBuf = 128 * _1K;
504	void *pvBuf = RTMemTmpAllocZ(cbBuf);
505	if (!pvBuf)
506	{
507	rc = VERR_NO_MEMORY;
508	goto out;
509	}
510
511	cbFill = (uint64_t)getImageBlocks(&pImage->Header) * pImage->cbTotalBlockData;
512	uOff = 0;
513	/* Write data to all image blocks. */
514	while (uOff < cbFill)
515	{
516	unsigned cbChunk = (unsigned)RT_MIN(cbFill, cbBuf);
517
518	rc = RTFileWriteAt(File, pImage->offStartData + uOff,
519	pvBuf, cbChunk, NULL);
520	if (RT_FAILURE(rc))
521	{
522	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: writing block failed for '%s'"), pImage->pszFilename);
523	goto out;
524	}
525
526	uOff += cbChunk;
527
528	if (pfnProgress)
529	{
530	rc = pfnProgress(NULL /* WARNING! pVM=NULL */,
531	uPercentStart + uOff * uPercentSpan / cbFill,
532	pvUser);
533	if (RT_FAILURE(rc))
534	goto out;
535	}
536	}
537	RTMemTmpFree(pvBuf);
538	}
539
540	out:
541	if (RT_SUCCESS(rc) && pfnProgress)
542	pfnProgress(NULL /* WARNING! pVM=NULL */,
543	uPercentStart + uPercentSpan, pvUser);
544
545	if (RT_FAILURE(rc))
546	vdiFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
547	return rc;
548	}
549
550	/**
551	* Internal: Open a VDI image.
552	*/
553	static int vdiOpenImage(PVDIIMAGEDESC pImage, unsigned uOpenFlags)
554	{
555	int rc;
556	RTFILE File;
557
558	if (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
559	return VERR_NOT_SUPPORTED;
560
561	pImage->uOpenFlags = uOpenFlags;
562
563	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
564	if (pImage->pInterfaceError)
565	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
566
567	/*
568	* Open the image.
569	*/
570	rc = RTFileOpen(&File, pImage->pszFilename,
571	uOpenFlags & VD_OPEN_FLAGS_READONLY
572	? RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE
573	: RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
574	if (RT_FAILURE(rc))
575	{
576	/* Do NOT signal an appropriate error here, as the VD layer has the
577	* choice of retrying the open if it failed. */
578	goto out;
579	}
580	pImage->File = File;
581
582	/* Read pre-header. */
583	rc = RTFileReadAt(File, 0, &pImage->PreHeader, sizeof(pImage->PreHeader),
584	NULL);
585	if (RT_FAILURE(rc))
586	{
587	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading pre-header in '%s'"), pImage->pszFilename);
588	goto out;
589	}
590	rc = vdiValidatePreHeader(&pImage->PreHeader);
591	if (RT_FAILURE(rc))
592	{
593	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: invalid pre-header in '%s'"), pImage->pszFilename);
594	goto out;
595	}
596
597	/* Read header. */
598	pImage->Header.uVersion = pImage->PreHeader.u32Version;
599	switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
600	{
601	case 0:
602	rc = RTFileReadAt(File, sizeof(pImage->PreHeader),
603	&pImage->Header.u.v0, sizeof(pImage->Header.u.v0),
604	NULL);
605	if (RT_FAILURE(rc))
606	{
607	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v0 header in '%s'"), pImage->pszFilename);
608	goto out;
609	}
610	break;
611	case 1:
612	rc = RTFileReadAt(File, sizeof(pImage->PreHeader),
613	&pImage->Header.u.v1, sizeof(pImage->Header.u.v1),
614	NULL);
615	if (RT_FAILURE(rc))
616	{
617	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1 header in '%s'"), pImage->pszFilename);
618	goto out;
619	}
620	/* Convert VDI 1.1 images to VDI 1.1+ on open in read/write mode.
621	* Conversion is harmless, as any VirtualBox version supporting VDI
622	* 1.1 doesn't touch fields it doesn't know about. */
623	if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
624	&& GET_MINOR_HEADER_VERSION(&pImage->Header) == 1
625	&& pImage->Header.u.v1.cbHeader < sizeof(pImage->Header.u.v1plus))
626	{
627	pImage->Header.u.v1plus.cbHeader = sizeof(pImage->Header.u.v1plus);
628	/* Mark LCHS geometry not-calculated. */
629	pImage->Header.u.v1plus.LCHSGeometry.cCylinders = 0;
630	pImage->Header.u.v1plus.LCHSGeometry.cHeads = 0;
631	pImage->Header.u.v1plus.LCHSGeometry.cSectors = 0;
632	pImage->Header.u.v1plus.LCHSGeometry.cbSector = VDI_GEOMETRY_SECTOR_SIZE;
633	}
634	else if (pImage->Header.u.v1.cbHeader >= sizeof(pImage->Header.u.v1plus))
635	{
636	/* Read the actual VDI 1.1+ header completely. */
637	rc = RTFileReadAt(File, sizeof(pImage->PreHeader), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
638	if (RT_FAILURE(rc))
639	{
640	rc = vdiError(pImage, rc, RT_SRC_POS, N_("VDI: error reading v1.1+ header in '%s'"), pImage->pszFilename);
641	goto out;
642	}
643	}
644	break;
645	default:
646	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);
647	goto out;
648	}
649
650	rc = vdiValidateHeader(&pImage->Header);
651	if (RT_FAILURE(rc))
652	{
653	rc = vdiError(pImage, VERR_VD_VDI_INVALID_HEADER, RT_SRC_POS, N_("VDI: invalid header in '%s'"), pImage->pszFilename);
654	goto out;
655	}
656
657	/* Setup image parameters by header. */
658	vdiSetupImageDesc(pImage);
659
660	/* Allocate memory for blocks array. */
661	pImage->paBlocks = (PVDIIMAGEBLOCKPOINTER)RTMemAlloc(sizeof(VDIIMAGEBLOCKPOINTER) * getImageBlocks(&pImage->Header));
662	if (!pImage->paBlocks)
663	{
664	rc = VERR_NO_MEMORY;
665	goto out;
666	}
667
668	/* Read blocks array. */
669	rc = RTFileReadAt(pImage->File, pImage->offStartBlocks, pImage->paBlocks,
670	getImageBlocks(&pImage->Header) * sizeof(VDIIMAGEBLOCKPOINTER),
671	NULL);
672
673	out:
674	if (RT_FAILURE(rc))
675	vdiFreeImage(pImage, false);
676	return rc;
677	}
678
679	/**
680	* Internal: Save header to file.
681	*/
682	static int vdiUpdateHeader(PVDIIMAGEDESC pImage)
683	{
684	int rc;
685	switch (GET_MAJOR_HEADER_VERSION(&pImage->Header))
686	{
687	case 0:
688	rc = RTFileWriteAt(pImage->File, sizeof(VDIPREHEADER), &pImage->Header.u.v0, sizeof(pImage->Header.u.v0), NULL);
689	break;
690	case 1:
691	if (pImage->Header.u.v1plus.cbHeader < sizeof(pImage->Header.u.v1plus))
692	rc = RTFileWriteAt(pImage->File, sizeof(VDIPREHEADER), &pImage->Header.u.v1, sizeof(pImage->Header.u.v1), NULL);
693	else
694	rc = RTFileWriteAt(pImage->File, sizeof(VDIPREHEADER), &pImage->Header.u.v1plus, sizeof(pImage->Header.u.v1plus), NULL);
695	break;
696	default:
697	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
698	break;
699	}
700	AssertMsgRC(rc, ("vdiUpdateHeader failed, filename=\"%s\" rc=%Rrc\n", pImage->pszFilename, rc));
701	return rc;
702	}
703
704	/**
705	* Internal: Save block pointer to file, save header to file.
706	*/
707	static int vdiUpdateBlockInfo(PVDIIMAGEDESC pImage, unsigned uBlock)
708	{
709	/* Update image header. */
710	int rc = vdiUpdateHeader(pImage);
711	if (RT_SUCCESS(rc))
712	{
713	/* write only one block pointer. */
714	rc = RTFileWriteAt(pImage->File,
715	pImage->offStartBlocks + uBlock * sizeof(VDIIMAGEBLOCKPOINTER),
716	&pImage->paBlocks[uBlock],
717	sizeof(VDIIMAGEBLOCKPOINTER),
718	NULL);
719	AssertMsgRC(rc, ("vdiUpdateBlockInfo failed to update block=%u, filename=\"%s\", rc=%Rrc\n",
720	uBlock, pImage->pszFilename, rc));
721	}
722	return rc;
723	}
724
725	/**
726	* Internal: Flush the image file to disk.
727	*/
728	static void vdiFlushImage(PVDIIMAGEDESC pImage)
729	{
730	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
731	{
732	/* Save header. */
733	int rc = vdiUpdateHeader(pImage);
734	AssertMsgRC(rc, ("vdiUpdateHeader() failed, filename=\"%s\", rc=%Rrc\n",
735	pImage->pszFilename, rc));
736	RTFileFlush(pImage->File);
737	}
738	}
739
740	/**
741	* Internal: Free all allocated space for representing an image, and optionally
742	* delete the image from disk.
743	*/
744	static void vdiFreeImage(PVDIIMAGEDESC pImage, bool fDelete)
745	{
746	AssertPtr(pImage);
747
748	if (pImage->File != NIL_RTFILE)
749	{
750	vdiFlushImage(pImage);
751	RTFileClose(pImage->File);
752	pImage->File = NIL_RTFILE;
753	}
754	if (pImage->paBlocks)
755	{
756	RTMemFree(pImage->paBlocks);
757	pImage->paBlocks = NULL;
758	}
759	if (fDelete && pImage->pszFilename)
760	RTFileDelete(pImage->pszFilename);
761	}
762
763
764	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
765	static int vdiCheckIfValid(const char *pszFilename)
766	{
767	LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
768	int rc = VINF_SUCCESS;
769	PVDIIMAGEDESC pImage;
770
771	if ( !VALID_PTR(pszFilename)
772	\|\| !*pszFilename)
773	{
774	rc = VERR_INVALID_PARAMETER;
775	goto out;
776	}
777
778	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
779	if (!pImage)
780	{
781	rc = VERR_NO_MEMORY;
782	goto out;
783	}
784	pImage->pszFilename = pszFilename;
785	pImage->File = NIL_RTFILE;
786	pImage->paBlocks = NULL;
787	pImage->pVDIfsDisk = NULL;
788
789	rc = vdiOpenImage(pImage, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY);
790	vdiFreeImage(pImage, false);
791	RTMemFree(pImage);
792
793	out:
794	LogFlowFunc(("returns %Rrc\n", rc));
795	return rc;
796	}
797
798	/** @copydoc VBOXHDDBACKEND::pfnOpen */
799	static int vdiOpen(const char *pszFilename, unsigned uOpenFlags,
800	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
801	void **ppBackendData)
802	{
803	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
804	int rc;
805	PVDIIMAGEDESC pImage;
806
807	/* Check open flags. All valid flags are supported. */
808	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
809	{
810	rc = VERR_INVALID_PARAMETER;
811	goto out;
812	}
813
814	/* Check remaining arguments. */
815	if ( !VALID_PTR(pszFilename)
816	\|\| !*pszFilename)
817	{
818	rc = VERR_INVALID_PARAMETER;
819	goto out;
820	}
821
822	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
823	if (!pImage)
824	{
825	rc = VERR_NO_MEMORY;
826	goto out;
827	}
828	pImage->pszFilename = pszFilename;
829	pImage->File = NIL_RTFILE;
830	pImage->paBlocks = NULL;
831	pImage->pVDIfsDisk = pVDIfsDisk;
832
833	rc = vdiOpenImage(pImage, uOpenFlags);
834	if (RT_SUCCESS(rc))
835	*ppBackendData = pImage;
836
837	out:
838	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
839	return rc;
840	}
841
842	/** @copydoc VBOXHDDBACKEND::pfnCreate */
843	static int vdiCreate(const char *pszFilename, uint64_t cbSize,
844	unsigned uImageFlags, const char *pszComment,
845	PCPDMMEDIAGEOMETRY pPCHSGeometry,
846	PCPDMMEDIAGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
847	unsigned uOpenFlags, unsigned uPercentStart,
848	unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
849	PVDINTERFACE pVDIfsImage, PVDINTERFACE pVDIfsOperation,
850	void **ppBackendData)
851	{
852	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));
853	int rc;
854	PVDIIMAGEDESC pImage;
855
856	PFNVMPROGRESS pfnProgress = NULL;
857	void *pvUser = NULL;
858	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
859	VDINTERFACETYPE_PROGRESS);
860	PVDINTERFACEPROGRESS pCbProgress = NULL;
861	if (pIfProgress)
862	{
863	pCbProgress = VDGetInterfaceProgress(pIfProgress);
864	if (pCbProgress)
865	pfnProgress = pCbProgress->pfnProgress;
866	pvUser = pIfProgress->pvUser;
867	}
868
869	/* Check open flags. All valid flags are supported. */
870	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
871	{
872	rc = VERR_INVALID_PARAMETER;
873	goto out;
874	}
875
876	/* Check size. Maximum 2PB-3M (to be on the safe side). No tricks with
877	* adjusting the 1M block size so far, which would extend the size. */
878	if ( !cbSize
879	\|\| cbSize >= _1P * 2 - _1M * 3)
880	{
881	rc = VERR_VD_INVALID_SIZE;
882	goto out;
883	}
884
885	/* Check remaining arguments. */
886	if ( !VALID_PTR(pszFilename)
887	\|\| !*pszFilename
888	\|\| cbSize < VDI_IMAGE_DEFAULT_BLOCK_SIZE
889	\|\| !VALID_PTR(pPCHSGeometry)
890	\|\| !VALID_PTR(pLCHSGeometry))
891	{
892	rc = VERR_INVALID_PARAMETER;
893	goto out;
894	}
895
896	pImage = (PVDIIMAGEDESC)RTMemAllocZ(sizeof(VDIIMAGEDESC));
897	if (!pImage)
898	{
899	rc = VERR_NO_MEMORY;
900	goto out;
901	}
902	pImage->pszFilename = pszFilename;
903	pImage->File = NIL_RTFILE;
904	pImage->paBlocks = NULL;
905	pImage->pVDIfsDisk = pVDIfsDisk;
906
907	rc = vdiCreateImage(pImage, cbSize, uImageFlags, pszComment,
908	pPCHSGeometry, pLCHSGeometry, pUuid,
909	pfnProgress, pvUser, uPercentStart, uPercentSpan);
910	if (RT_SUCCESS(rc))
911	{
912	/* So far the image is opened in read/write mode. Make sure the
913	* image is opened in read-only mode if the caller requested that. */
914	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
915	{
916	vdiFreeImage(pImage, false);
917	rc = vdiOpenImage(pImage, uOpenFlags);
918	if (RT_FAILURE(rc))
919	goto out;
920	}
921	*ppBackendData = pImage;
922	}
923	else
924	RTMemFree(pImage);
925
926	out:
927	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
928	return rc;
929	}
930
931	/** @copydoc VBOXHDDBACKEND::pfnRename */
932	static int vdiRename(void pBackendData, const char pszFilename)
933	{
934	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
935
936	int rc = VINF_SUCCESS;
937	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
938
939	/* Check arguments. */
940	if ( !pImage
941	\|\| !pszFilename
942	\|\| !*pszFilename)
943	{
944	rc = VERR_INVALID_PARAMETER;
945	goto out;
946	}
947
948	/* Close the image. */
949	vdiFreeImage(pImage, false);
950
951	/* Rename the file. */
952	rc = RTFileMove(pImage->pszFilename, pszFilename, 0);
953	if (RT_FAILURE(rc))
954	{
955	/* The move failed, try to reopen the original image. */
956	int rc2 = vdiOpenImage(pImage, pImage->uOpenFlags);
957	if (RT_FAILURE(rc2))
958	rc = rc2;
959
960	goto out;
961	}
962
963	/* Update pImage with the new information. */
964	pImage->pszFilename = pszFilename;
965
966	/* Open the new image. */
967	rc = vdiOpenImage(pImage, pImage->uOpenFlags);
968	if (RT_FAILURE(rc))
969	goto out;
970
971	out:
972	LogFlowFunc(("returns %Rrc\n", rc));
973	return rc;
974	}
975
976	/** @copydoc VBOXHDDBACKEND::pfnClose */
977	static int vdiClose(void *pBackendData, bool fDelete)
978	{
979	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
980	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
981	int rc = VINF_SUCCESS;
982
983	/* Freeing a never allocated image (e.g. because the open failed) is
984	* not signalled as an error. After all nothing bad happens. */
985	if (pImage)
986	{
987	vdiFreeImage(pImage, fDelete);
988	RTMemFree(pImage);
989	}
990
991	LogFlowFunc(("returns %Rrc\n", rc));
992	return rc;
993	}
994
995	/** @copydoc VBOXHDDBACKEND::pfnRead */
996	static int vdiRead(void pBackendData, uint64_t uOffset, void pvBuf,
997	size_t cbToRead, size_t *pcbActuallyRead)
998	{
999	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToRead=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbToRead, pcbActuallyRead));
1000	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1001	unsigned uBlock;
1002	unsigned offRead;
1003	int rc;
1004
1005	AssertPtr(pImage);
1006	Assert(!(uOffset % 512));
1007	Assert(!(cbToRead % 512));
1008
1009	if ( uOffset + cbToRead > getImageDiskSize(&pImage->Header)
1010	\|\| !VALID_PTR(pvBuf)
1011	\|\| !cbToRead)
1012	{
1013	rc = VERR_INVALID_PARAMETER;
1014	goto out;
1015	}
1016
1017	/* Calculate starting block number and offset inside it. */
1018	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1019	offRead = (unsigned)uOffset & pImage->uBlockMask;
1020
1021	/* Clip read range to at most the rest of the block. */
1022	cbToRead = RT_MIN(cbToRead, getImageBlockSize(&pImage->Header) - offRead);
1023	Assert(!(cbToRead % 512));
1024
1025	if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_FREE)
1026	rc = VERR_VD_BLOCK_FREE;
1027	else if (pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO)
1028	{
1029	memset(pvBuf, 0, cbToRead);
1030	rc = VINF_SUCCESS;
1031	}
1032	else
1033	{
1034	/* Block present in image file, read relevant data. */
1035	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1036	+ (pImage->offStartData + pImage->offStartBlockData + offRead);
1037	rc = RTFileReadAt(pImage->File, u64Offset, pvBuf, cbToRead, NULL);
1038	}
1039
1040	if (pcbActuallyRead)
1041	*pcbActuallyRead = cbToRead;
1042
1043	out:
1044	LogFlowFunc(("returns %Rrc\n", rc));
1045	return rc;
1046	}
1047
1048	/*@copydoc VBOXHDDBACKEND::pfnWrite /
1049	static int vdiWrite(void pBackendData, uint64_t uOffset, const void pvBuf,
1050	size_t cbToWrite, size_t *pcbWriteProcess,
1051	size_t pcbPreRead, size_t pcbPostRead, unsigned fWrite)
1052	{
1053	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n", pBackendData, uOffset, pvBuf, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
1054	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1055	unsigned uBlock;
1056	unsigned offWrite;
1057	int rc = VINF_SUCCESS;
1058
1059	AssertPtr(pImage);
1060	Assert(!(uOffset % 512));
1061	Assert(!(cbToWrite % 512));
1062
1063	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1064	{
1065	rc = VERR_VD_IMAGE_READ_ONLY;
1066	goto out;
1067	}
1068
1069	if (!VALID_PTR(pvBuf) \|\| !cbToWrite)
1070	{
1071	rc = VERR_INVALID_PARAMETER;
1072	goto out;
1073	}
1074
1075	/* No size check here, will do that later. For dynamic images which are
1076	* not multiples of the block size in length, this would prevent writing to
1077	* the last grain. */
1078
1079	/* Calculate starting block number and offset inside it. */
1080	uBlock = (unsigned)(uOffset >> pImage->uShiftOffset2Index);
1081	offWrite = (unsigned)uOffset & pImage->uBlockMask;
1082
1083	/* Clip write range to at most the rest of the block. */
1084	cbToWrite = RT_MIN(cbToWrite, getImageBlockSize(&pImage->Header) - offWrite);
1085	Assert(!(cbToWrite % 512));
1086
1087	do
1088	{
1089	if (!IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
1090	{
1091	/* Block is either free or zero. */
1092	if ( !(pImage->uOpenFlags & VD_OPEN_FLAGS_HONOR_ZEROES)
1093	&& ( pImage->paBlocks[uBlock] == VDI_IMAGE_BLOCK_ZERO
1094	\|\| cbToWrite == getImageBlockSize(&pImage->Header)))
1095	{
1096	/* If the destination block is unallocated at this point, it's
1097	* either a zero block or a block which hasn't been used so far
1098	* (which also means that it's a zero block. Don't need to write
1099	* anything to this block if the data consists of just zeroes. */
1100	Assert(!(cbToWrite % 4));
1101	Assert(cbToWrite * 8 <= UINT32_MAX);
1102	if (ASMBitFirstSet((volatile void )pvBuf, (uint32_t)cbToWrite 8) == -1)
1103	{
1104	pImage->paBlocks[uBlock] = VDI_IMAGE_BLOCK_ZERO;
1105	break;
1106	}
1107	}
1108
1109	if (cbToWrite == getImageBlockSize(&pImage->Header))
1110	{
1111	/* Full block write to previously unallocated block.
1112	* Allocate block and write data. */
1113	Assert(!offWrite);
1114	unsigned cBlocksAllocated = getImageBlocksAllocated(&pImage->Header);
1115	uint64_t u64Offset = (uint64_t)cBlocksAllocated * pImage->cbTotalBlockData
1116	+ (pImage->offStartData + pImage->offStartBlockData);
1117	rc = RTFileWriteAt(pImage->File, u64Offset, pvBuf, cbToWrite, NULL);
1118	if (RT_FAILURE(rc))
1119	goto out;
1120	pImage->paBlocks[uBlock] = cBlocksAllocated;
1121	setImageBlocksAllocated(&pImage->Header, cBlocksAllocated + 1);
1122
1123	rc = vdiUpdateBlockInfo(pImage, uBlock);
1124	if (RT_FAILURE(rc))
1125	goto out;
1126
1127	*pcbPreRead = 0;
1128	*pcbPostRead = 0;
1129	}
1130	else
1131	{
1132	/* Trying to do a partial write to an unallocated block. Don't do
1133	* anything except letting the upper layer know what to do. */
1134	*pcbPreRead = offWrite % getImageBlockSize(&pImage->Header);
1135	pcbPostRead = getImageBlockSize(&pImage->Header) - cbToWrite - pcbPreRead;
1136	rc = VERR_VD_BLOCK_FREE;
1137	}
1138	}
1139	else
1140	{
1141	/* Block present in image file, write relevant data. */
1142	uint64_t u64Offset = (uint64_t)pImage->paBlocks[uBlock] * pImage->cbTotalBlockData
1143	+ (pImage->offStartData + pImage->offStartBlockData + offWrite);
1144	rc = RTFileWriteAt(pImage->File, u64Offset, pvBuf, cbToWrite, NULL);
1145	}
1146	} while (0);
1147
1148	if (pcbWriteProcess)
1149	*pcbWriteProcess = cbToWrite;
1150
1151	out:
1152	LogFlowFunc(("returns %Rrc\n", rc));
1153	return rc;
1154	}
1155
1156	/** @copydoc VBOXHDDBACKEND::pfnFlush */
1157	static int vdiFlush(void *pBackendData)
1158	{
1159	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1160	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1161	int rc = VINF_SUCCESS;
1162
1163	Assert(pImage);
1164
1165	vdiFlushImage(pImage);
1166	LogFlowFunc(("returns %Rrc\n", rc));
1167	return rc;
1168	}
1169
1170	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
1171	static unsigned vdiGetVersion(void *pBackendData)
1172	{
1173	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1174	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1175	unsigned uVersion;
1176
1177	AssertPtr(pImage);
1178
1179	if (pImage)
1180	uVersion = pImage->PreHeader.u32Version;
1181	else
1182	uVersion = 0;
1183
1184	LogFlowFunc(("returns %#x\n", uVersion));
1185	return uVersion;
1186	}
1187
1188	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
1189	static uint64_t vdiGetSize(void *pBackendData)
1190	{
1191	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1192	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1193	uint64_t cbSize;
1194
1195	AssertPtr(pImage);
1196
1197	if (pImage)
1198	cbSize = getImageDiskSize(&pImage->Header);
1199	else
1200	cbSize = 0;
1201
1202	LogFlowFunc(("returns %llu\n", cbSize));
1203	return cbSize;
1204	}
1205
1206	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
1207	static uint64_t vdiGetFileSize(void *pBackendData)
1208	{
1209	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1210	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1211	uint64_t cb = 0;
1212
1213	AssertPtr(pImage);
1214
1215	if (pImage)
1216	{
1217	uint64_t cbFile;
1218	if (pImage->File != NIL_RTFILE)
1219	{
1220	int rc = RTFileGetSize(pImage->File, &cbFile);
1221	if (RT_SUCCESS(rc))
1222	cb += cbFile;
1223	}
1224	}
1225
1226	LogFlowFunc(("returns %lld\n", cb));
1227	return cb;
1228	}
1229
1230	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
1231	static int vdiGetPCHSGeometry(void *pBackendData,
1232	PPDMMEDIAGEOMETRY pPCHSGeometry)
1233	{
1234	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1235	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1236	int rc;
1237
1238	AssertPtr(pImage);
1239
1240	if (pImage)
1241	{
1242	if (pImage->PCHSGeometry.cCylinders)
1243	{
1244	*pPCHSGeometry = pImage->PCHSGeometry;
1245	rc = VINF_SUCCESS;
1246	}
1247	else
1248	rc = VERR_VD_GEOMETRY_NOT_SET;
1249	}
1250	else
1251	rc = VERR_VD_NOT_OPENED;
1252
1253	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1254	return rc;
1255	}
1256
1257	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
1258	static int vdiSetPCHSGeometry(void *pBackendData,
1259	PCPDMMEDIAGEOMETRY pPCHSGeometry)
1260	{
1261	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1262	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1263	int rc;
1264
1265	AssertPtr(pImage);
1266
1267	if (pImage)
1268	{
1269	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1270	{
1271	rc = VERR_VD_IMAGE_READ_ONLY;
1272	goto out;
1273	}
1274
1275	pImage->PCHSGeometry = *pPCHSGeometry;
1276	rc = VINF_SUCCESS;
1277	}
1278	else
1279	rc = VERR_VD_NOT_OPENED;
1280
1281	out:
1282	LogFlowFunc(("returns %Rrc\n", rc));
1283	return rc;
1284	}
1285
1286	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
1287	static int vdiGetLCHSGeometry(void *pBackendData,
1288	PPDMMEDIAGEOMETRY pLCHSGeometry)
1289	{
1290	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1291	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1292	int rc;
1293
1294	AssertPtr(pImage);
1295
1296	if (pImage)
1297	{
1298	VDIDISKGEOMETRY DummyGeo = { 0, 0, 0, VDI_GEOMETRY_SECTOR_SIZE };
1299	PVDIDISKGEOMETRY pGeometry = getImageLCHSGeometry(&pImage->Header);
1300	if (!pGeometry)
1301	pGeometry = &DummyGeo;
1302
1303	if ( pGeometry->cCylinders > 0
1304	&& pGeometry->cHeads > 0
1305	&& pGeometry->cSectors > 0)
1306	{
1307	pLCHSGeometry->cCylinders = pGeometry->cCylinders;
1308	pLCHSGeometry->cHeads = pGeometry->cHeads;
1309	pLCHSGeometry->cSectors = pGeometry->cSectors;
1310	rc = VINF_SUCCESS;
1311	}
1312	else
1313	rc = VERR_VD_GEOMETRY_NOT_SET;
1314	}
1315	else
1316	rc = VERR_VD_NOT_OPENED;
1317
1318	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1319	return rc;
1320	}
1321
1322	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
1323	static int vdiSetLCHSGeometry(void *pBackendData,
1324	PCPDMMEDIAGEOMETRY pLCHSGeometry)
1325	{
1326	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1327	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1328	PVDIDISKGEOMETRY pGeometry;
1329	int rc;
1330
1331	AssertPtr(pImage);
1332
1333	if (pImage)
1334	{
1335	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1336	{
1337	rc = VERR_VD_IMAGE_READ_ONLY;
1338	goto out;
1339	}
1340
1341	pGeometry = getImageLCHSGeometry(&pImage->Header);
1342	if (pGeometry)
1343	{
1344	pGeometry->cCylinders = pLCHSGeometry->cCylinders;
1345	pGeometry->cHeads = pLCHSGeometry->cHeads;
1346	pGeometry->cSectors = pLCHSGeometry->cSectors;
1347	pGeometry->cbSector = VDI_GEOMETRY_SECTOR_SIZE;
1348
1349	/* Update header information in base image file. */
1350	vdiFlushImage(pImage);
1351	}
1352	rc = VINF_SUCCESS;
1353	}
1354	else
1355	rc = VERR_VD_NOT_OPENED;
1356
1357	out:
1358	LogFlowFunc(("returns %Rrc\n", rc));
1359	return rc;
1360	}
1361
1362	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
1363	static unsigned vdiGetImageFlags(void *pBackendData)
1364	{
1365	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1366	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1367	unsigned uImageFlags;
1368
1369	AssertPtr(pImage);
1370
1371	if (pImage)
1372	uImageFlags = pImage->uImageFlags;
1373	else
1374	uImageFlags = 0;
1375
1376	LogFlowFunc(("returns %#x\n", uImageFlags));
1377	return uImageFlags;
1378	}
1379
1380	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
1381	static unsigned vdiGetOpenFlags(void *pBackendData)
1382	{
1383	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1384	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1385	unsigned uOpenFlags;
1386
1387	AssertPtr(pImage);
1388
1389	if (pImage)
1390	uOpenFlags = pImage->uOpenFlags;
1391	else
1392	uOpenFlags = 0;
1393
1394	LogFlowFunc(("returns %#x\n", uOpenFlags));
1395	return uOpenFlags;
1396	}
1397
1398	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
1399	static int vdiSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1400	{
1401	LogFlowFunc(("pBackendData=%#p uOpenFlags=%#x\n", pBackendData, uOpenFlags));
1402	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1403	int rc;
1404	const char *pszFilename;
1405
1406	/* Image must be opened and the new flags must be valid. Just readonly and
1407	* info flags are supported. */
1408	if (!pImage \|\| (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO)))
1409	{
1410	rc = VERR_INVALID_PARAMETER;
1411	goto out;
1412	}
1413
1414	/* Implement this operation via reopening the image. */
1415	pszFilename = pImage->pszFilename;
1416	vdiFreeImage(pImage, false);
1417	rc = vdiOpenImage(pImage, uOpenFlags);
1418
1419	out:
1420	LogFlowFunc(("returns %Rrc\n", rc));
1421	return rc;
1422	}
1423
1424	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1425	static int vdiGetComment(void pBackendData, char pszComment,
1426	size_t cbComment)
1427	{
1428	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
1429	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1430	int rc = VINF_SUCCESS;
1431
1432	AssertPtr(pImage);
1433
1434	if (pImage)
1435	{
1436	char *pszTmp = getImageComment(&pImage->Header);
1437	size_t cb = strlen(pszTmp);
1438	if (cb < cbComment)
1439	{
1440	/* memcpy is much better than strncpy. */
1441	memcpy(pszComment, pszTmp, cb + 1);
1442	}
1443	else
1444	rc = VERR_BUFFER_OVERFLOW;
1445	}
1446	else
1447	rc = VERR_VD_NOT_OPENED;
1448
1449	LogFlowFunc(("returns %Rrc comment=\"%s\"\n", rc, pszComment));
1450	return rc;
1451	}
1452
1453	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
1454	static int vdiSetComment(void pBackendData, const char pszComment)
1455	{
1456	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1457	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1458	int rc;
1459
1460	AssertPtr(pImage);
1461
1462	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1463	{
1464	rc = VERR_VD_IMAGE_READ_ONLY;
1465	goto out;
1466	}
1467
1468	if (pImage)
1469	{
1470	size_t cchComment = pszComment ? strlen(pszComment) : 0;
1471	if (cchComment >= VDI_IMAGE_COMMENT_SIZE)
1472	{
1473	LogFunc(("pszComment is too long, %d bytes!\n", cchComment));
1474	rc = VERR_VD_VDI_COMMENT_TOO_LONG;
1475	goto out;
1476	}
1477
1478	/* we don't support old style images */
1479	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1480	{
1481	/*
1482	* Update the comment field, making sure to zero out all of the previous comment.
1483	*/
1484	memset(pImage->Header.u.v1.szComment, '\0', VDI_IMAGE_COMMENT_SIZE);
1485	memcpy(pImage->Header.u.v1.szComment, pszComment, cchComment);
1486
1487	/* write out new the header */
1488	rc = vdiUpdateHeader(pImage);
1489	}
1490	else
1491	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1492	}
1493	else
1494	rc = VERR_VD_NOT_OPENED;
1495
1496	out:
1497	LogFlowFunc(("returns %Rrc\n", rc));
1498	return rc;
1499	}
1500
1501	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
1502	static int vdiGetUuid(void *pBackendData, PRTUUID pUuid)
1503	{
1504	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1505	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1506	int rc;
1507
1508	AssertPtr(pImage);
1509
1510	if (pImage)
1511	{
1512	pUuid = getImageCreationUUID(&pImage->Header);
1513	rc = VINF_SUCCESS;
1514	}
1515	else
1516	rc = VERR_VD_NOT_OPENED;
1517
1518	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1519	return rc;
1520	}
1521
1522	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
1523	static int vdiSetUuid(void *pBackendData, PCRTUUID pUuid)
1524	{
1525	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1526	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1527	int rc = VINF_SUCCESS;
1528
1529	AssertPtr(pImage);
1530
1531	if (pImage)
1532	{
1533	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1534	{
1535	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1536	pImage->Header.u.v1.uuidCreate = *pUuid;
1537	/* Make it possible to clone old VDIs. */
1538	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1539	pImage->Header.u.v0.uuidCreate = *pUuid;
1540	else
1541	{
1542	LogFunc(("Version is not supported!\n"));
1543	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1544	}
1545	}
1546	else
1547	rc = VERR_VD_IMAGE_READ_ONLY;
1548	}
1549	else
1550	rc = VERR_VD_NOT_OPENED;
1551
1552	LogFlowFunc(("returns %Rrc\n", rc));
1553	return rc;
1554	}
1555
1556	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
1557	static int vdiGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1558	{
1559	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1560	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1561	int rc;
1562
1563	AssertPtr(pImage);
1564
1565	if (pImage)
1566	{
1567	pUuid = getImageModificationUUID(&pImage->Header);
1568	rc = VINF_SUCCESS;
1569	}
1570	else
1571	rc = VERR_VD_NOT_OPENED;
1572
1573	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1574	return rc;
1575	}
1576
1577	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
1578	static int vdiSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1579	{
1580	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1581	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1582	int rc = VINF_SUCCESS;
1583
1584	AssertPtr(pImage);
1585
1586	if (pImage)
1587	{
1588	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1589	{
1590	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1591	pImage->Header.u.v1.uuidModify = *pUuid;
1592	/* Make it possible to clone old VDIs. */
1593	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1594	pImage->Header.u.v0.uuidModify = *pUuid;
1595	else
1596	{
1597	LogFunc(("Version is not supported!\n"));
1598	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1599	}
1600	}
1601	else
1602	rc = VERR_VD_IMAGE_READ_ONLY;
1603	}
1604	else
1605	rc = VERR_VD_NOT_OPENED;
1606
1607	LogFlowFunc(("returns %Rrc\n", rc));
1608	return rc;
1609	}
1610
1611	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1612	static int vdiGetParentUuid(void *pBackendData, PRTUUID pUuid)
1613	{
1614	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1615	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1616	int rc;
1617
1618	AssertPtr(pImage);
1619
1620	if (pImage)
1621	{
1622	pUuid = getImageParentUUID(&pImage->Header);
1623	rc = VINF_SUCCESS;
1624	}
1625	else
1626	rc = VERR_VD_NOT_OPENED;
1627
1628	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1629	return rc;
1630	}
1631
1632	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1633	static int vdiSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1634	{
1635	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1636	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1637	int rc = VINF_SUCCESS;
1638
1639	AssertPtr(pImage);
1640
1641	if (pImage)
1642	{
1643	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1644	{
1645	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1646	pImage->Header.u.v1.uuidLinkage = *pUuid;
1647	/* Make it possible to clone old VDIs. */
1648	else if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 0)
1649	pImage->Header.u.v0.uuidLinkage = *pUuid;
1650	else
1651	{
1652	LogFunc(("Version is not supported!\n"));
1653	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1654	}
1655	}
1656	else
1657	rc = VERR_VD_IMAGE_READ_ONLY;
1658	}
1659	else
1660	rc = VERR_VD_NOT_OPENED;
1661
1662	LogFlowFunc(("returns %Rrc\n", rc));
1663	return rc;
1664	}
1665
1666	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1667	static int vdiGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1668	{
1669	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1670	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1671	int rc;
1672
1673	AssertPtr(pImage);
1674
1675	if (pImage)
1676	{
1677	pUuid = getImageParentModificationUUID(&pImage->Header);
1678	rc = VINF_SUCCESS;
1679	}
1680	else
1681	rc = VERR_VD_NOT_OPENED;
1682
1683	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1684	return rc;
1685	}
1686
1687	/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
1688	static int vdiSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1689	{
1690	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1691	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1692	int rc = VINF_SUCCESS;
1693
1694	AssertPtr(pImage);
1695
1696	if (pImage)
1697	{
1698	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1699	{
1700	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) == 1)
1701	pImage->Header.u.v1.uuidParentModify = *pUuid;
1702	else
1703	{
1704	LogFunc(("Version is not supported!\n"));
1705	rc = VERR_VD_VDI_UNSUPPORTED_VERSION;
1706	}
1707	}
1708	else
1709	rc = VERR_VD_IMAGE_READ_ONLY;
1710	}
1711	else
1712	rc = VERR_VD_NOT_OPENED;
1713
1714	LogFlowFunc(("returns %Rrc\n", rc));
1715	return rc;
1716	}
1717
1718	/** @copydoc VBOXHDDBACKEND::pfnDump */
1719	static void vdiDump(void *pBackendData)
1720	{
1721	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1722
1723	RTLogPrintf("Dumping VDI image \"%s\" mode=%s uOpenFlags=%X File=%08X\n",
1724	pImage->pszFilename,
1725	(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY) ? "r/o" : "r/w",
1726	pImage->uOpenFlags,
1727	pImage->File);
1728	RTLogPrintf("Header: Version=%08X Type=%X Flags=%X Size=%llu\n",
1729	pImage->PreHeader.u32Version,
1730	getImageType(&pImage->Header),
1731	getImageFlags(&pImage->Header),
1732	getImageDiskSize(&pImage->Header));
1733	RTLogPrintf("Header: cbBlock=%u cbBlockExtra=%u cBlocks=%u cBlocksAllocated=%u\n",
1734	getImageBlockSize(&pImage->Header),
1735	getImageExtraBlockSize(&pImage->Header),
1736	getImageBlocks(&pImage->Header),
1737	getImageBlocksAllocated(&pImage->Header));
1738	RTLogPrintf("Header: offBlocks=%u offData=%u\n",
1739	getImageBlocksOffset(&pImage->Header),
1740	getImageDataOffset(&pImage->Header));
1741	PVDIDISKGEOMETRY pg = getImageLCHSGeometry(&pImage->Header);
1742	if (pg)
1743	RTLogPrintf("Header: Geometry: C/H/S=%u/%u/%u cbSector=%u\n",
1744	pg->cCylinders, pg->cHeads, pg->cSectors, pg->cbSector);
1745	RTLogPrintf("Header: uuidCreation={%RTuuid}\n", getImageCreationUUID(&pImage->Header));
1746	RTLogPrintf("Header: uuidModification={%RTuuid}\n", getImageModificationUUID(&pImage->Header));
1747	RTLogPrintf("Header: uuidParent={%RTuuid}\n", getImageParentUUID(&pImage->Header));
1748	if (GET_MAJOR_HEADER_VERSION(&pImage->Header) >= 1)
1749	RTLogPrintf("Header: uuidParentModification={%RTuuid}\n", getImageParentModificationUUID(&pImage->Header));
1750	RTLogPrintf("Image: fFlags=%08X offStartBlocks=%u offStartData=%u\n",
1751	pImage->uImageFlags, pImage->offStartBlocks, pImage->offStartData);
1752	RTLogPrintf("Image: uBlockMask=%08X cbTotalBlockData=%u uShiftOffset2Index=%u offStartBlockData=%u\n",
1753	pImage->uBlockMask,
1754	pImage->cbTotalBlockData,
1755	pImage->uShiftOffset2Index,
1756	pImage->offStartBlockData);
1757
1758	unsigned uBlock, cBlocksNotFree, cBadBlocks, cBlocks = getImageBlocks(&pImage->Header);
1759	for (uBlock=0, cBlocksNotFree=0, cBadBlocks=0; uBlock<cBlocks; uBlock++)
1760	{
1761	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(pImage->paBlocks[uBlock]))
1762	{
1763	cBlocksNotFree++;
1764	if (pImage->paBlocks[uBlock] >= cBlocks)
1765	cBadBlocks++;
1766	}
1767	}
1768	if (cBlocksNotFree != getImageBlocksAllocated(&pImage->Header))
1769	{
1770	RTLogPrintf("!! WARNING: %u blocks actually allocated (cBlocksAllocated=%u) !!\n",
1771	cBlocksNotFree, getImageBlocksAllocated(&pImage->Header));
1772	}
1773	if (cBadBlocks)
1774	{
1775	RTLogPrintf("!! WARNING: %u bad blocks found !!\n",
1776	cBadBlocks);
1777	}
1778	}
1779
1780	static int vdiGetTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
1781	{
1782	int rc = VERR_NOT_IMPLEMENTED;
1783	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
1784	return rc;
1785	}
1786
1787	static int vdiGetParentTimeStamp(void *pBackendData, PRTTIMESPEC pTimeStamp)
1788	{
1789	int rc = VERR_NOT_IMPLEMENTED;
1790	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
1791	return rc;
1792	}
1793
1794	static int vdiSetParentTimeStamp(void *pBackendData, PCRTTIMESPEC pTimeStamp)
1795	{
1796	int rc = VERR_NOT_IMPLEMENTED;
1797	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
1798	return rc;
1799	}
1800
1801	static int vdiGetParentFilename(void pBackendData, char *ppszParentFilename)
1802	{
1803	int rc = VERR_NOT_IMPLEMENTED;
1804	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
1805	return rc;
1806	}
1807
1808	static int vdiSetParentFilename(void pBackendData, const char pszParentFilename)
1809	{
1810	int rc = VERR_NOT_IMPLEMENTED;
1811	LogFlow(("%s: returned %Rrc\n", __FUNCTION__, rc));
1812	return rc;
1813	}
1814
1815	static bool vdiIsAsyncIOSupported(void *pBackendData)
1816	{
1817	return false;
1818	}
1819
1820	static int vdiAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbRead,
1821	PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
1822	{
1823	int rc = VERR_NOT_IMPLEMENTED;
1824	LogFlowFunc(("returns %Rrc\n", rc));
1825	return rc;
1826	}
1827
1828	static int vdiAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbWrite,
1829	PPDMDATASEG paSeg, unsigned cSeg, void *pvUser)
1830	{
1831	int rc = VERR_NOT_IMPLEMENTED;
1832	LogFlowFunc(("returns %Rrc\n", rc));
1833	return rc;
1834	}
1835
1836	/** @copydoc VBOXHDDBACKEND::pfnCompact */
1837	static int vdiCompact(void *pBackendData, unsigned uPercentStart,
1838	unsigned uPercentSpan, PVDINTERFACE pVDIfsOperation)
1839	{
1840	PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)pBackendData;
1841	int rc = VINF_SUCCESS;
1842	void pvBuf = NULL, pvTmp = NULL;
1843	unsigned *paBlocks2 = NULL;
1844
1845	int (pfnParentRead)(void , uint64_t, void *, size_t) = NULL;
1846	void *pvParent = NULL;
1847	PVDINTERFACE pIfParentState = VDInterfaceGet(pVDIfsOperation,
1848	VDINTERFACETYPE_PARENTSTATE);
1849	PVDINTERFACEPARENTSTATE pCbParentState = NULL;
1850	if (pIfParentState)
1851	{
1852	pCbParentState = VDGetInterfaceParentState(pIfParentState);
1853	if (pCbParentState)
1854	pfnParentRead = pCbParentState->pfnParentRead;
1855	pvParent = pIfParentState->pvUser;
1856	}
1857
1858	PFNVMPROGRESS pfnProgress = NULL;
1859	void *pvUser = NULL;
1860	PVDINTERFACE pIfProgress = VDInterfaceGet(pVDIfsOperation,
1861	VDINTERFACETYPE_PROGRESS);
1862	PVDINTERFACEPROGRESS pCbProgress = NULL;
1863	if (pIfProgress)
1864	{
1865	pCbProgress = VDGetInterfaceProgress(pIfProgress);
1866	if (pCbProgress)
1867	pfnProgress = pCbProgress->pfnProgress;
1868	pvUser = pIfProgress->pvUser;
1869	}
1870
1871	do {
1872	AssertBreakStmt(pImage, rc = VERR_INVALID_PARAMETER);
1873
1874	AssertBreakStmt(!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY),
1875	rc = VERR_VD_IMAGE_READ_ONLY);
1876
1877	unsigned cBlocks;
1878	unsigned cBlocksToMove = 0;
1879	size_t cbBlock;
1880	cBlocks = getImageBlocks(&pImage->Header);
1881	cbBlock = getImageBlockSize(&pImage->Header);
1882	if (pfnParentRead)
1883	{
1884	pvBuf = RTMemTmpAlloc(cbBlock);
1885	AssertBreakStmt(VALID_PTR(pvBuf), rc = VERR_NO_MEMORY);
1886	}
1887	pvTmp = RTMemTmpAlloc(cbBlock);
1888	AssertBreakStmt(VALID_PTR(pvTmp), rc = VERR_NO_MEMORY);
1889
1890	uint64_t cbFile;
1891	rc = RTFileGetSize(pImage->File, &cbFile);
1892	AssertRCBreak(rc);
1893	unsigned cBlocksAllocated = (unsigned)((cbFile - pImage->offStartData - pImage->offStartBlockData) >> pImage->uShiftOffset2Index);
1894	if (cBlocksAllocated == 0)
1895	{
1896	/* No data blocks in this image, no need to compact. */
1897	rc = VINF_SUCCESS;
1898	break;
1899	}
1900
1901	/* Allocate block array for back resolving. */
1902	paBlocks2 = (unsigned )RTMemAlloc(sizeof(unsigned ) * cBlocksAllocated);
1903	AssertBreakStmt(VALID_PTR(paBlocks2), rc = VERR_NO_MEMORY);
1904	/* Fill out back resolving, check/fix allocation errors before
1905	* compacting the image, just to be on the safe side. Update the
1906	* image contents straight away, as this enables cancelling. */
1907	for (unsigned i = 0; i < cBlocks; i++)
1908	paBlocks2[i] = VDI_IMAGE_BLOCK_FREE;
1909	rc = VINF_SUCCESS;
1910	for (unsigned i = 0; i < cBlocks; i++)
1911	{
1912	VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
1913	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
1914	{
1915	if (ptrBlock < cBlocksAllocated)
1916	{
1917	if (paBlocks2[ptrBlock] == VDI_IMAGE_BLOCK_FREE)
1918	paBlocks2[ptrBlock] = i;
1919	else
1920	{
1921	LogFunc(("Freed cross-linked block %u in file \"%s\"\n",
1922	i, pImage->pszFilename));
1923	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
1924	rc = vdiUpdateBlockInfo(pImage, i);
1925	if (RT_FAILURE(rc))
1926	break;
1927	}
1928	}
1929	else
1930	{
1931	LogFunc(("Freed out of bounds reference for block %u in file \"%s\"\n",
1932	i, pImage->pszFilename));
1933	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;;
1934	rc = vdiUpdateBlockInfo(pImage, i);
1935	if (RT_FAILURE(rc))
1936	break;
1937	}
1938	}
1939	}
1940	if (RT_FAILURE(rc))
1941	break;
1942
1943	/* Find redundant information and update the block pointers
1944	* accordingly, creating bubbles. Keep disk up to date, as this
1945	* enables cancelling. */
1946	for (unsigned i = 0; i < cBlocks; i++)
1947	{
1948	VDIIMAGEBLOCKPOINTER ptrBlock = pImage->paBlocks[i];
1949	if (IS_VDI_IMAGE_BLOCK_ALLOCATED(ptrBlock))
1950	{
1951	/* Block present in image file, read relevant data. */
1952	uint64_t u64Offset = (uint64_t)ptrBlock * pImage->cbTotalBlockData
1953	+ (pImage->offStartData + pImage->offStartBlockData);
1954	rc = RTFileReadAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
1955	if (RT_FAILURE(rc))
1956	break;
1957
1958	if (ASMBitFirstSet((volatile void )pvTmp, (uint32_t)cbBlock 8) == -1)
1959	{
1960	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_ZERO;
1961	rc = vdiUpdateBlockInfo(pImage, i);
1962	if (RT_FAILURE(rc))
1963	break;
1964	paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
1965	/* Adjust progress info, one block to be relocated. */
1966	cBlocksToMove++;
1967	}
1968	else if (pfnParentRead)
1969	{
1970	rc = pfnParentRead(pvParent, i * cbBlock, pvBuf, cbBlock);
1971	if (RT_FAILURE(rc))
1972	break;
1973	if (!memcmp(pvTmp, pvBuf, cbBlock))
1974	{
1975	pImage->paBlocks[i] = VDI_IMAGE_BLOCK_FREE;
1976	rc = vdiUpdateBlockInfo(pImage, i);
1977	if (RT_FAILURE(rc))
1978	break;
1979	paBlocks2[ptrBlock] = VDI_IMAGE_BLOCK_FREE;
1980	/* Adjust progress info, one block to be relocated. */
1981	cBlocksToMove++;
1982	}
1983	}
1984	}
1985
1986	if (pCbProgress && pCbProgress->pfnProgress)
1987	{
1988	rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
1989	(uint64_t)i * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
1990	pIfProgress->pvUser);
1991	if (RT_FAILURE(rc))
1992	break;
1993	}
1994	}
1995	if (RT_FAILURE(rc))
1996	break;
1997
1998	/* Fill bubbles with other data (if available). */
1999	unsigned cBlocksMoved = 0;
2000	unsigned uBlockUsedPos = cBlocksAllocated;
2001	for (unsigned i = 0; i < cBlocksAllocated; i++)
2002	{
2003	unsigned uBlock = paBlocks2[i];
2004	if (uBlock == VDI_IMAGE_BLOCK_FREE)
2005	{
2006	unsigned uBlockData = VDI_IMAGE_BLOCK_FREE;
2007	while (uBlockUsedPos > i && uBlockData == VDI_IMAGE_BLOCK_FREE)
2008	{
2009	uBlockUsedPos--;
2010	uBlockData = paBlocks2[uBlockUsedPos];
2011	}
2012	/* Terminate early if there is no block which needs copying. */
2013	if (uBlockUsedPos == i)
2014	break;
2015	uint64_t u64Offset = (uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2016	+ (pImage->offStartData + pImage->offStartBlockData);
2017	rc = RTFileReadAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
2018	u64Offset = (uint64_t)i * pImage->cbTotalBlockData
2019	+ (pImage->offStartData + pImage->offStartBlockData);
2020	rc = RTFileWriteAt(pImage->File, u64Offset, pvTmp, cbBlock, NULL);
2021	pImage->paBlocks[uBlockData] = i;
2022	setImageBlocksAllocated(&pImage->Header, cBlocksAllocated - cBlocksMoved);
2023	rc = vdiUpdateBlockInfo(pImage, uBlockData);
2024	if (RT_FAILURE(rc))
2025	break;
2026	paBlocks2[i] = uBlockData;
2027	paBlocks2[uBlockUsedPos] = VDI_IMAGE_BLOCK_FREE;
2028	cBlocksMoved++;
2029	}
2030
2031	if (pCbProgress && pCbProgress->pfnProgress)
2032	{
2033	rc = pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
2034	(uint64_t)(cBlocks + cBlocksMoved) * uPercentSpan / (cBlocks + cBlocksToMove) + uPercentStart,
2035	pIfProgress->pvUser);
2036	if (RT_FAILURE(rc))
2037	break;
2038	}
2039	}
2040	if (RT_FAILURE(rc))
2041	break;
2042
2043	/* Update image header. */
2044	setImageBlocksAllocated(&pImage->Header, uBlockUsedPos);
2045	vdiUpdateHeader(pImage);
2046
2047	/* Truncate the image to the proper size to finish compacting. */
2048	rc = RTFileSetSize(pImage->File,
2049	(uint64_t)uBlockUsedPos * pImage->cbTotalBlockData
2050	+ (pImage->offStartData + pImage->offStartBlockData));
2051	} while (0);
2052
2053	if (paBlocks2)
2054	RTMemTmpFree(paBlocks2);
2055	if (pvTmp)
2056	RTMemTmpFree(pvTmp);
2057	if (pvBuf)
2058	RTMemTmpFree(pvBuf);
2059
2060	if (RT_SUCCESS(rc) && pCbProgress && pCbProgress->pfnProgress)
2061	{
2062	pCbProgress->pfnProgress(NULL /* WARNING! pVM=NULL */,
2063	uPercentStart + uPercentSpan,
2064	pIfProgress->pvUser);
2065	}
2066
2067	LogFlowFunc(("returns %Rrc\n", rc));
2068	return rc;
2069	}
2070
2071
2072	VBOXHDDBACKEND g_VDIBackend =
2073	{
2074	/* pszBackendName */
2075	"VDI",
2076	/* cbSize */
2077	sizeof(VBOXHDDBACKEND),
2078	/* uBackendCaps */
2079	VD_CAP_UUID \| VD_CAP_CREATE_FIXED \| VD_CAP_CREATE_DYNAMIC
2080	\| VD_CAP_CREATE_SPLIT_2G \| VD_CAP_DIFF \| VD_CAP_FILE,
2081	/* papszFileExtensions */
2082	s_apszVdiFileExtensions,
2083	/* paConfigInfo */
2084	NULL,
2085	/* hPlugin */
2086	NIL_RTLDRMOD,
2087	/* pfnCheckIfValid */
2088	vdiCheckIfValid,
2089	/* pfnOpen */
2090	vdiOpen,
2091	/* pfnCreate */
2092	vdiCreate,
2093	/* pfnRename */
2094	vdiRename,
2095	/* pfnClose */
2096	vdiClose,
2097	/* pfnRead */
2098	vdiRead,
2099	/* pfnWrite */
2100	vdiWrite,
2101	/* pfnFlush */
2102	vdiFlush,
2103	/* pfnGetVersion */
2104	vdiGetVersion,
2105	/* pfnGetSize */
2106	vdiGetSize,
2107	/* pfnGetFileSize */
2108	vdiGetFileSize,
2109	/* pfnGetPCHSGeometry */
2110	vdiGetPCHSGeometry,
2111	/* pfnSetPCHSGeometry */
2112	vdiSetPCHSGeometry,
2113	/* pfnGetLCHSGeometry */
2114	vdiGetLCHSGeometry,
2115	/* pfnSetLCHSGeometry */
2116	vdiSetLCHSGeometry,
2117	/* pfnGetImageFlags */
2118	vdiGetImageFlags,
2119	/* pfnGetOpenFlags */
2120	vdiGetOpenFlags,
2121	/* pfnSetOpenFlags */
2122	vdiSetOpenFlags,
2123	/* pfnGetComment */
2124	vdiGetComment,
2125	/* pfnSetComment */
2126	vdiSetComment,
2127	/* pfnGetUuid */
2128	vdiGetUuid,
2129	/* pfnSetUuid */
2130	vdiSetUuid,
2131	/* pfnGetModificationUuid */
2132	vdiGetModificationUuid,
2133	/* pfnSetModificationUuid */
2134	vdiSetModificationUuid,
2135	/* pfnGetParentUuid */
2136	vdiGetParentUuid,
2137	/* pfnSetParentUuid */
2138	vdiSetParentUuid,
2139	/* pfnGetParentModificationUuid */
2140	vdiGetParentModificationUuid,
2141	/* pfnSetParentModificationUuid */
2142	vdiSetParentModificationUuid,
2143	/* pfnDump */
2144	vdiDump,
2145	/* pfnGetTimeStamp */
2146	vdiGetTimeStamp,
2147	/* pfnGetParentTimeStamp */
2148	vdiGetParentTimeStamp,
2149	/* pfnSetParentTimeStamp */
2150	vdiSetParentTimeStamp,
2151	/* pfnGetParentFilename */
2152	vdiGetParentFilename,
2153	/* pfnSetParentFilename */
2154	vdiSetParentFilename,
2155	/* pfnIsAsyncIOSupported */
2156	vdiIsAsyncIOSupported,
2157	/* pfnAsyncRead */
2158	vdiAsyncRead,
2159	/* pfnAsyncWrite */
2160	vdiAsyncWrite,
2161	/* pfnComposeLocation */
2162	genericFileComposeLocation,
2163	/* pfnComposeName */
2164	genericFileComposeName,
2165	/* pfnCompact */
2166	vdiCompact
2167	};
2168

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

source: vbox/trunk/src/VBox/Devices/Storage/VDIHDDCore.cpp@ 19223

Download in other formats: