Parallels.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: 46.2 KB

Line
1	/* $Id: Parallels.cpp 33567 2010-10-28 15:37:21Z vboxsync $ */
2	/** @file
3	*
4	* Parallels hdd disk image, core code.
5	*/
6
7	/*
8	* Copyright (C) 2006-2010 Oracle Corporation
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*/
18
19	#define LOG_GROUP LOG_GROUP_VD_PARALLELS
20	#include <VBox/vd-plugin.h>
21	#include <VBox/err.h>
22
23	#include <VBox/log.h>
24	#include <iprt/assert.h>
25	#include <iprt/mem.h>
26	#include <iprt/uuid.h>
27	#include <iprt/path.h>
28	#include <iprt/string.h>
29
30	#define PARALLELS_HEADER_MAGIC "WithoutFreeSpace"
31	#define PARALLELS_DISK_VERSION 2
32
33	/** The header of the parallels disk. */
34	#pragma pack(1)
35	typedef struct ParallelsHeader
36	{
37	/** The magic header to identify a parallels hdd image. */
38	char HeaderIdentifier[16];
39	/** The version of the disk image. */
40	uint32_t uVersion;
41	/** The number of heads the hdd has. */
42	uint32_t cHeads;
43	/** Number of cylinders. */
44	uint32_t cCylinders;
45	/** Number of sectors per track. */
46	uint32_t cSectorsPerTrack;
47	/** Number of entries in the allocation bitmap. */
48	uint32_t cEntriesInAllocationBitmap;
49	/** Total number of sectors. */
50	uint32_t cSectors;
51	/** Padding. */
52	char Padding[24];
53	} ParallelsHeader;
54	#pragma pack()
55
56	/**
57	* Parallels image structure.
58	*/
59	typedef struct PARALLELSIMAGE
60	{
61	/** Image file name. */
62	const char *pszFilename;
63	/** Opaque storage handle. */
64	PVDIOSTORAGE pStorage;
65
66	/** I/O interface. */
67	PVDINTERFACE pInterfaceIO;
68	/** I/O interface callbacks. */
69	PVDINTERFACEIOINT pInterfaceIOCallbacks;
70
71	/** Pointer to the per-disk VD interface list. */
72	PVDINTERFACE pVDIfsDisk;
73	/** Pointer to the per-image VD interface list. */
74	PVDINTERFACE pVDIfsImage;
75	/** Error interface. */
76	PVDINTERFACE pInterfaceError;
77	/** Error interface callbacks. */
78	PVDINTERFACEERROR pInterfaceErrorCallbacks;
79
80	/** Open flags passed by VBoxHDD layer. */
81	unsigned uOpenFlags;
82	/** Image flags defined during creation or determined during open. */
83	unsigned uImageFlags;
84	/** Total size of the image. */
85	uint64_t cbSize;
86
87	/** Physical geometry of this image. */
88	VDGEOMETRY PCHSGeometry;
89	/** Logical geometry of this image. */
90	VDGEOMETRY LCHSGeometry;
91
92	/** Pointer to the allocation bitmap. */
93	uint32_t *pAllocationBitmap;
94	/** Entries in the allocation bitmap. */
95	uint64_t cAllocationBitmapEntries;
96	/** Flag whether the allocation bitmap was changed. */
97	bool fAllocationBitmapChanged;
98	/** Current file size. */
99	uint64_t cbFileCurrent;
100	} PARALLELSIMAGE, *PPARALLELSIMAGE;
101
102	/*******************************************************************************
103	* Static Variables *
104	*******************************************************************************/
105
106	/** NULL-terminated array of supported file extensions. */
107	static const VDFILEEXTENSION s_aParallelsFileExtensions[] =
108	{
109	{"hdd", VDTYPE_HDD},
110	{NULL, VDTYPE_INVALID}
111	};
112
113	/***************************************************
114	* Internal functions *
115	**************************************************/
116
117	/**
118	* Internal: signal an error to the frontend.
119	*/
120	DECLINLINE(int) parallelsError(PPARALLELSIMAGE pImage, int rc, RT_SRC_POS_DECL,
121	const char *pszFormat, ...)
122	{
123	va_list va;
124	va_start(va, pszFormat);
125	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
126	pImage->pInterfaceErrorCallbacks->pfnError(pImage->pInterfaceError->pvUser, rc, RT_SRC_POS_ARGS,
127	pszFormat, va);
128	va_end(va);
129	return rc;
130	}
131
132	/**
133	* Internal: signal an informational message to the frontend.
134	*/
135	DECLINLINE(int) parallelsMessage(PPARALLELSIMAGE pImage, const char *pszFormat, ...)
136	{
137	int rc = VINF_SUCCESS;
138	va_list va;
139	va_start(va, pszFormat);
140	if (pImage->pInterfaceError && pImage->pInterfaceErrorCallbacks)
141	rc = pImage->pInterfaceErrorCallbacks->pfnMessage(pImage->pInterfaceError->pvUser,
142	pszFormat, va);
143	va_end(va);
144	return rc;
145	}
146
147
148	DECLINLINE(int) parallelsFileOpen(PPARALLELSIMAGE pImage, const char *pszFilename,
149	uint32_t fOpen)
150	{
151	return pImage->pInterfaceIOCallbacks->pfnOpen(pImage->pInterfaceIO->pvUser,
152	pszFilename, fOpen,
153	&pImage->pStorage);
154	}
155
156	DECLINLINE(int) parallelsFileClose(PPARALLELSIMAGE pImage)
157	{
158	return pImage->pInterfaceIOCallbacks->pfnClose(pImage->pInterfaceIO->pvUser,
159	pImage->pStorage);
160	}
161
162	DECLINLINE(int) parallelsFileDelete(PPARALLELSIMAGE pImage, const char *pszFilename)
163	{
164	return pImage->pInterfaceIOCallbacks->pfnDelete(pImage->pInterfaceIO->pvUser,
165	pszFilename);
166	}
167
168	DECLINLINE(int) parallelsFileMove(PPARALLELSIMAGE pImage, const char *pszSrc,
169	const char *pszDst, unsigned fMove)
170	{
171	return pImage->pInterfaceIOCallbacks->pfnMove(pImage->pInterfaceIO->pvUser,
172	pszSrc, pszDst, fMove);
173	}
174
175	DECLINLINE(int) parallelsFileGetSize(PPARALLELSIMAGE pImage, uint64_t *pcbSize)
176	{
177	return pImage->pInterfaceIOCallbacks->pfnGetSize(pImage->pInterfaceIO->pvUser,
178	pImage->pStorage, pcbSize);
179	}
180
181	DECLINLINE(int) parallelsFileSetSize(PPARALLELSIMAGE pImage, uint64_t cbSize)
182	{
183	return pImage->pInterfaceIOCallbacks->pfnSetSize(pImage->pInterfaceIO->pvUser,
184	pImage->pStorage, cbSize);
185	}
186
187	DECLINLINE(int) parallelsFileWriteSync(PPARALLELSIMAGE pImage, uint64_t uOffset,
188	const void *pvBuffer, size_t cbBuffer,
189	size_t *pcbWritten)
190	{
191	return pImage->pInterfaceIOCallbacks->pfnWriteSync(pImage->pInterfaceIO->pvUser,
192	pImage->pStorage, uOffset,
193	pvBuffer, cbBuffer, pcbWritten);
194	}
195
196	DECLINLINE(int) parallelsFileReadSync(PPARALLELSIMAGE pImage, uint64_t uOffset,
197	void pvBuffer, size_t cbBuffer, size_t pcbRead)
198	{
199	return pImage->pInterfaceIOCallbacks->pfnReadSync(pImage->pInterfaceIO->pvUser,
200	pImage->pStorage, uOffset,
201	pvBuffer, cbBuffer, pcbRead);
202	}
203
204	DECLINLINE(int) parallelsFileFlushSync(PPARALLELSIMAGE pImage)
205	{
206	return pImage->pInterfaceIOCallbacks->pfnFlushSync(pImage->pInterfaceIO->pvUser,
207	pImage->pStorage);
208	}
209
210	DECLINLINE(int) parallelsFileReadUserAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
211	PVDIOCTX pIoCtx, size_t cbRead)
212	{
213	return pImage->pInterfaceIOCallbacks->pfnReadUserAsync(pImage->pInterfaceIO->pvUser,
214	pImage->pStorage,
215	uOffset, pIoCtx,
216	cbRead);
217	}
218
219	DECLINLINE(int) parallelsFileWriteUserAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
220	PVDIOCTX pIoCtx, size_t cbWrite,
221	PFNVDXFERCOMPLETED pfnComplete,
222	void *pvCompleteUser)
223	{
224	return pImage->pInterfaceIOCallbacks->pfnWriteUserAsync(pImage->pInterfaceIO->pvUser,
225	pImage->pStorage,
226	uOffset, pIoCtx,
227	cbWrite,
228	pfnComplete,
229	pvCompleteUser);
230	}
231
232	DECLINLINE(int) parallelsFileWriteMetaAsync(PPARALLELSIMAGE pImage, uint64_t uOffset,
233	void *pvBuffer, size_t cbBuffer,
234	PVDIOCTX pIoCtx,
235	PFNVDXFERCOMPLETED pfnComplete,
236	void *pvCompleteUser)
237	{
238	return pImage->pInterfaceIOCallbacks->pfnWriteMetaAsync(pImage->pInterfaceIO->pvUser,
239	pImage->pStorage,
240	uOffset, pvBuffer,
241	cbBuffer, pIoCtx,
242	pfnComplete,
243	pvCompleteUser);
244	}
245
246	DECLINLINE(int) parallelsFileFlushAsync(PPARALLELSIMAGE pImage, PVDIOCTX pIoCtx,
247	PFNVDXFERCOMPLETED pfnComplete,
248	void *pvCompleteUser)
249	{
250	return pImage->pInterfaceIOCallbacks->pfnFlushAsync(pImage->pInterfaceIO->pvUser,
251	pImage->pStorage,
252	pIoCtx, pfnComplete,
253	pvCompleteUser);
254	}
255
256
257	/**
258	* Internal. Flush image data to disk.
259	*/
260	static int parallelsFlushImage(PPARALLELSIMAGE pImage)
261	{
262	int rc = VINF_SUCCESS;
263
264	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
265	return VINF_SUCCESS;
266
267	if ( !(pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
268	&& (pImage->fAllocationBitmapChanged))
269	{
270	pImage->fAllocationBitmapChanged = false;
271	/* Write the allocation bitmap to the file. */
272	rc = parallelsFileWriteSync(pImage, sizeof(ParallelsHeader),
273	pImage->pAllocationBitmap,
274	pImage->cAllocationBitmapEntries * sizeof(uint32_t),
275	NULL);
276	if (RT_FAILURE(rc))
277	return rc;
278	}
279
280	/* Flush file. */
281	rc = parallelsFileFlushSync(pImage);
282
283	LogFlowFunc(("returns %Rrc\n", rc));
284	return rc;
285	}
286
287	/**
288	* Internal. Free all allocated space for representing an image except pImage,
289	* and optionally delete the image from disk.
290	*/
291	static int parallelsFreeImage(PPARALLELSIMAGE pImage, bool fDelete)
292	{
293	int rc = VINF_SUCCESS;
294
295	/* Freeing a never allocated image (e.g. because the open failed) is
296	* not signalled as an error. After all nothing bad happens. */
297	if (pImage)
298	{
299	if (pImage->pStorage)
300	{
301	/* No point updating the file that is deleted anyway. */
302	if (!fDelete)
303	parallelsFlushImage(pImage);
304
305	parallelsFileClose(pImage);
306	pImage->pStorage = NULL;
307	}
308
309	if (pImage->pAllocationBitmap)
310	{
311	RTMemFree(pImage->pAllocationBitmap);
312	pImage->pAllocationBitmap = NULL;
313	}
314
315	if (fDelete && pImage->pszFilename)
316	parallelsFileDelete(pImage, pImage->pszFilename);
317	}
318
319	return rc;
320	}
321
322	static int parallelsOpenImage(PPARALLELSIMAGE pImage, unsigned uOpenFlags)
323	{
324	int rc = VINF_SUCCESS;
325	ParallelsHeader parallelsHeader;
326
327	/* Try to get error interface. */
328	pImage->pInterfaceError = VDInterfaceGet(pImage->pVDIfsDisk, VDINTERFACETYPE_ERROR);
329	if (pImage->pInterfaceError)
330	pImage->pInterfaceErrorCallbacks = VDGetInterfaceError(pImage->pInterfaceError);
331
332	/* Get I/O interface. */
333	pImage->pInterfaceIO = VDInterfaceGet(pImage->pVDIfsImage, VDINTERFACETYPE_IOINT);
334	AssertPtrReturn(pImage->pInterfaceIO, VERR_INVALID_PARAMETER);
335	pImage->pInterfaceIOCallbacks = VDGetInterfaceIOInt(pImage->pInterfaceIO);
336	AssertPtrReturn(pImage->pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
337
338	rc = parallelsFileOpen(pImage, pImage->pszFilename,
339	VDOpenFlagsToFileOpenFlags(uOpenFlags,
340	false /* fCreate */));
341	if (RT_FAILURE(rc))
342	goto out;
343
344	rc = parallelsFileGetSize(pImage, &pImage->cbFileCurrent);
345	if (RT_FAILURE(rc))
346	goto out;
347	AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
348
349	rc = parallelsFileReadSync(pImage, 0, &parallelsHeader, sizeof(parallelsHeader), NULL);
350	if (RT_FAILURE(rc))
351	goto out;
352
353	if (memcmp(parallelsHeader.HeaderIdentifier, PARALLELS_HEADER_MAGIC, 16))
354	{
355	/* Check if the file has hdd as extension. It is a fixed size raw image then. */
356	char *pszExtension = RTPathExt(pImage->pszFilename);
357	if (strcmp(pszExtension, ".hdd"))
358	{
359	rc = VERR_VD_PARALLELS_INVALID_HEADER;
360	goto out;
361	}
362
363	/* This is a fixed size image. */
364	pImage->uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
365	pImage->cbSize = pImage->cbFileCurrent;
366
367	pImage->PCHSGeometry.cHeads = 16;
368	pImage->PCHSGeometry.cSectors = 63;
369	uint64_t cCylinders = pImage->cbSize / (512 * pImage->PCHSGeometry.cSectors * pImage->PCHSGeometry.cHeads);
370	pImage->PCHSGeometry.cCylinders = (uint32_t)cCylinders;
371	}
372	else
373	{
374	if (parallelsHeader.uVersion != PARALLELS_DISK_VERSION)
375	{
376	rc = VERR_NOT_SUPPORTED;
377	goto out;
378	}
379
380	if (parallelsHeader.cEntriesInAllocationBitmap > (1 << 30))
381	{
382	rc = VERR_NOT_SUPPORTED;
383	goto out;
384	}
385
386	Log(("cSectors=%u\n", parallelsHeader.cSectors));
387	pImage->cbSize = ((uint64_t)parallelsHeader.cSectors) * 512;
388	pImage->uImageFlags = VD_IMAGE_FLAGS_NONE;
389	pImage->cAllocationBitmapEntries = parallelsHeader.cEntriesInAllocationBitmap;
390	pImage->pAllocationBitmap = (uint32_t )RTMemAllocZ((uint32_t)pImage->cAllocationBitmapEntries sizeof(uint32_t));
391	if (!pImage->pAllocationBitmap)
392	{
393	rc = VERR_NO_MEMORY;
394	goto out;
395	}
396
397	rc = parallelsFileReadSync(pImage, sizeof(ParallelsHeader),
398	pImage->pAllocationBitmap,
399	pImage->cAllocationBitmapEntries * sizeof(uint32_t),
400	NULL);
401	if (RT_FAILURE(rc))
402	goto out;
403
404	pImage->PCHSGeometry.cCylinders = parallelsHeader.cCylinders;
405	pImage->PCHSGeometry.cHeads = parallelsHeader.cHeads;
406	pImage->PCHSGeometry.cSectors = parallelsHeader.cSectorsPerTrack;
407	}
408
409	out:
410	LogFlowFunc(("returns %Rrc\n", rc));
411	return rc;
412	}
413
414
415	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
416	static int parallelsCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
417	PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
418	{
419	int rc;
420	PVDIOSTORAGE pStorage;
421	ParallelsHeader parallelsHeader;
422
423	/* Get I/O interface. */
424	PVDINTERFACE pInterfaceIO = VDInterfaceGet(pVDIfsImage, VDINTERFACETYPE_IOINT);
425	AssertPtrReturn(pInterfaceIO, VERR_INVALID_PARAMETER);
426	PVDINTERFACEIOINT pInterfaceIOCallbacks = VDGetInterfaceIOInt(pInterfaceIO);
427	AssertPtrReturn(pInterfaceIOCallbacks, VERR_INVALID_PARAMETER);
428
429	rc = pInterfaceIOCallbacks->pfnOpen(pInterfaceIO->pvUser, pszFilename,
430	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
431	false /* fCreate */),
432	&pStorage);
433	if (RT_FAILURE(rc))
434	return rc;
435
436	rc = pInterfaceIOCallbacks->pfnReadSync(pInterfaceIO->pvUser, pStorage,
437	0, &parallelsHeader,
438	sizeof(ParallelsHeader), NULL);
439	if (RT_SUCCESS(rc))
440	{
441	if ( !memcmp(parallelsHeader.HeaderIdentifier, PARALLELS_HEADER_MAGIC, 16)
442	&& (parallelsHeader.uVersion == PARALLELS_DISK_VERSION))
443	rc = VINF_SUCCESS;
444	else
445	{
446	/*
447	* The image may be an fixed size image.
448	* Unfortunately fixed sized parallels images
449	* are just raw files hence no magic header to
450	* check for.
451	* The code succeeds if the file is a multiple
452	* of 512 and if the file extensions is *.hdd
453	*/
454	uint64_t cbFile;
455	char *pszExtension;
456
457	rc = pInterfaceIOCallbacks->pfnGetSize(pInterfaceIO->pvUser, pStorage,
458	&cbFile);
459	if (RT_FAILURE(rc) \|\| ((cbFile % 512) != 0))
460	{
461	pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
462	return VERR_VD_PARALLELS_INVALID_HEADER;
463	}
464
465	pszExtension = RTPathExt(pszFilename);
466	if (!pszExtension \|\| strcmp(pszExtension, ".hdd"))
467	rc = VERR_VD_PARALLELS_INVALID_HEADER;
468	else
469	rc = VINF_SUCCESS;
470	}
471	}
472
473	if (RT_SUCCESS(rc))
474	*penmType = VDTYPE_HDD;
475
476	pInterfaceIOCallbacks->pfnClose(pInterfaceIO->pvUser, pStorage);
477	return rc;
478	}
479
480	/** @copydoc VBOXHDDBACKEND::pfnOpen */
481	static int parallelsOpen(const char *pszFilename, unsigned uOpenFlags,
482	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
483	VDTYPE enmType, void **ppBackendData)
484	{
485	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
486	int rc;
487	PPARALLELSIMAGE pImage;
488
489	/* Check open flags. All valid flags are supported. */
490	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
491	{
492	rc = VERR_INVALID_PARAMETER;
493	goto out;
494	}
495
496	/* Check remaining arguments. */
497	if ( !VALID_PTR(pszFilename)
498	\|\| !*pszFilename)
499	{
500	rc = VERR_INVALID_PARAMETER;
501	goto out;
502	}
503
504	/** @todo r=klaus why this duplicate check, async is not claimed... */
505	if (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO)
506	{
507	rc = VERR_NOT_SUPPORTED;
508	goto out;
509	}
510
511	pImage = (PPARALLELSIMAGE)RTMemAllocZ(sizeof(PARALLELSIMAGE));
512	if (!pImage)
513	{
514	rc = VERR_NO_MEMORY;
515	goto out;
516	}
517
518	pImage->pszFilename = pszFilename;
519	pImage->pStorage = NULL;
520	pImage->pVDIfsDisk = pVDIfsDisk;
521	pImage->pVDIfsImage = pVDIfsImage;
522	pImage->fAllocationBitmapChanged = false;
523
524	rc = parallelsOpenImage(pImage, uOpenFlags);
525	if (RT_SUCCESS(rc))
526	*ppBackendData = pImage;
527	else
528	RTMemFree(pImage);
529
530	out:
531	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
532	return rc;
533	}
534
535	/** @copydoc VBOXHDDBACKEND::pfnCreate */
536	static int parallelsCreate(const char *pszFilename, uint64_t cbSize,
537	unsigned uImageFlags, const char *pszComment,
538	PCVDGEOMETRY pPCHSGeometry,
539	PCVDGEOMETRY pLCHSGeometry, PCRTUUID pUuid,
540	unsigned uOpenFlags, unsigned uPercentStart,
541	unsigned uPercentSpan, PVDINTERFACE pVDIfsDisk,
542	PVDINTERFACE pVDIfsImage,
543	PVDINTERFACE pVDIfsOperation, void **ppBackendData)
544	{
545	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));
546	int rc = VERR_NOT_IMPLEMENTED;
547
548	LogFlowFunc(("returns %Rrc\n", rc));
549	return rc;
550	}
551
552	/** @copydoc VBOXHDDBACKEND::pfnRename */
553	static int parallelsRename(void pBackendData, const char pszFilename)
554	{
555	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
556	int rc = VINF_SUCCESS;
557	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
558
559	/* Check arguments. */
560	if ( !pImage
561	\|\| !pszFilename
562	\|\| !*pszFilename)
563	{
564	rc = VERR_INVALID_PARAMETER;
565	goto out;
566	}
567
568	/* Close the image. */
569	rc = parallelsFreeImage(pImage, false);
570	if (RT_FAILURE(rc))
571	goto out;
572
573	/* Rename the file. */
574	rc = parallelsFileMove(pImage, pImage->pszFilename, pszFilename, 0);
575	if (RT_FAILURE(rc))
576	{
577	/* The move failed, try to reopen the original image. */
578	int rc2 = parallelsOpenImage(pImage, pImage->uOpenFlags);
579	if (RT_FAILURE(rc2))
580	rc = rc2;
581
582	goto out;
583	}
584
585	/* Update pImage with the new information. */
586	pImage->pszFilename = pszFilename;
587
588	/* Open the old image with new name. */
589	rc = parallelsOpenImage(pImage, pImage->uOpenFlags);
590	if (RT_FAILURE(rc))
591	goto out;
592
593	out:
594	LogFlowFunc(("returns %Rrc\n", rc));
595	return rc;
596	}
597
598	/** @copydoc VBOXHDDBACKEND::pfnClose */
599	static int parallelsClose(void *pBackendData, bool fDelete)
600	{
601	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
602	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
603	int rc;
604
605	rc = parallelsFreeImage(pImage, fDelete);
606	RTMemFree(pImage);
607
608	LogFlowFunc(("returns %Rrc\n", rc));
609	return rc;
610	}
611
612	/** @copydoc VBOXHDDBACKEND::pfnRead */
613	static int parallelsRead(void pBackendData, uint64_t uOffset, void pvBuf,
614	size_t cbBuf, size_t *pcbActuallyRead)
615	{
616	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbBuf=%zu pcbActuallyRead=%#p\n", pBackendData, uOffset, pvBuf, cbBuf, pcbActuallyRead));
617	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
618	int rc = VINF_SUCCESS;
619	uint64_t uSector;
620	uint64_t uOffsetInFile;
621	uint32_t iIndexInAllocationTable;
622
623	AssertPtr(pImage);
624	Assert(uOffset % 512 == 0);
625	Assert(cbBuf % 512 == 0);
626
627	if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
628	{
629	rc = parallelsFileReadSync(pImage, uOffset, pvBuf, cbBuf, NULL);
630	}
631	else
632	{
633	/* Calculate offset in the real file. */
634	uSector = uOffset / 512;
635	/* One chunk in the file is always one track big. */
636	iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
637	uSector = uSector % pImage->PCHSGeometry.cSectors;
638
639	cbBuf = RT_MIN(cbBuf, (pImage->PCHSGeometry.cSectors - uSector)*512);
640
641	if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
642	{
643	rc = VERR_VD_BLOCK_FREE;
644	}
645	else
646	{
647	uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
648	rc = parallelsFileReadSync(pImage, uOffsetInFile, pvBuf, cbBuf, NULL);
649	}
650	}
651
652	if (RT_SUCCESS(rc))
653	{
654	if (pcbActuallyRead)
655	*pcbActuallyRead = cbBuf;
656
657	Log2(("parallelsRead: off=%#llx pvBuf=%p cbBuf=%d\n"
658	"%.*Rhxd\n",
659	uOffset, pvBuf, cbBuf, cbBuf, pvBuf));
660	}
661
662	LogFlowFunc(("returns %Rrc\n", rc));
663	return rc;
664	}
665
666	/** @copydoc VBOXHDDBACKEND::pfnWrite */
667	static int parallelsWrite(void pBackendData, uint64_t uOffset, const void pvBuf,
668	size_t cbBuf, size_t *pcbWriteProcess,
669	size_t pcbPreRead, size_t pcbPostRead, unsigned fWrite)
670	{
671	LogFlowFunc(("pBackendData=%#p uOffset=%llu pvBuf=%#p cbBuf=%zu pcbWriteProcess=%#p\n", pBackendData, uOffset, pvBuf, cbBuf, pcbWriteProcess));
672	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
673	int rc = VINF_SUCCESS;
674	uint64_t uSector;
675	uint64_t uOffsetInFile;
676	uint32_t iIndexInAllocationTable;
677
678	AssertPtr(pImage);
679	Assert(uOffset % 512 == 0);
680	Assert(cbBuf % 512 == 0);
681
682	if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
683	{
684	rc = parallelsFileWriteSync(pImage, uOffset, pvBuf, cbBuf, NULL);
685	}
686	else
687	{
688	/** Calculate offset in the real file. */
689	uSector = uOffset / 512;
690	/** One chunk in the file is always one track big. */
691	iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
692	uSector = uSector % pImage->PCHSGeometry.cSectors;
693
694	cbBuf = RT_MIN(cbBuf, (pImage->PCHSGeometry.cSectors - uSector)*512);
695
696	if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
697	{
698	/* Allocate new chunk in the file. */
699	AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
700	pImage->pAllocationBitmap[iIndexInAllocationTable] = (uint32_t)(pImage->cbFileCurrent / 512);
701	pImage->cbFileCurrent += pImage->PCHSGeometry.cSectors * 512;
702	pImage->fAllocationBitmapChanged = true;
703
704	uint8_t pNewBlock = (uint8_t )RTMemAllocZ(pImage->PCHSGeometry.cSectors * 512);
705
706	if (!pNewBlock)
707	{
708	rc = VERR_NO_MEMORY;
709	goto out;
710	}
711
712	uOffsetInFile = (uint64_t)pImage->pAllocationBitmap[iIndexInAllocationTable] * 512;
713	memcpy(pNewBlock + (uOffset - ((uint64_t)iIndexInAllocationTable * pImage->PCHSGeometry.cSectors * 512)),
714	pvBuf, cbBuf);
715
716	/*
717	* Write the new block at the current end of the file.
718	*/
719	rc = parallelsFileWriteSync(pImage, uOffsetInFile, pNewBlock,
720	pImage->PCHSGeometry.cSectors * 512,
721	NULL);
722
723	RTMemFree(pNewBlock);
724	}
725	else
726	{
727	uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
728	rc = parallelsFileWriteSync(pImage, uOffsetInFile, pvBuf, cbBuf, NULL);
729	}
730	}
731
732	if (pcbWriteProcess)
733	*pcbWriteProcess = cbBuf;
734
735	/* Stay on the safe side. Do not run the risk of confusing the higher
736	* level, as that can be pretty lethal to image consistency. */
737	*pcbPreRead = 0;
738	*pcbPostRead = 0;
739
740	out:
741	LogFlowFunc(("returns %Rrc\n", rc));
742	return rc;
743	}
744
745	/** @copydoc VBOXHDDBACKEND::pfnFlush */
746	static int parallelsFlush(void *pBackendData)
747	{
748	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
749	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
750	int rc;
751
752	AssertPtr(pImage);
753
754	rc = parallelsFlushImage(pImage);
755
756	LogFlowFunc(("returns %Rrc\n", rc));
757	return rc;
758	}
759
760	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
761	static unsigned parallelsGetVersion(void *pBackendData)
762	{
763	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
764	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
765
766	AssertPtr(pImage);
767
768	if (pImage)
769	return PARALLELS_DISK_VERSION;
770	else
771	return 0;
772	}
773
774	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
775	static uint64_t parallelsGetSize(void *pBackendData)
776	{
777	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
778	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
779	uint64_t cb = 0;
780
781	AssertPtr(pImage);
782
783	if (pImage && pImage->pStorage)
784	cb = pImage->cbSize;
785
786	LogFlowFunc(("returns %llu\n", cb));
787	return cb;
788	}
789
790	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
791	static uint64_t parallelsGetFileSize(void *pBackendData)
792	{
793	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
794	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
795	uint64_t cb = 0;
796
797	AssertPtr(pImage);
798
799	if (pImage && pImage->pStorage)
800	cb = pImage->cbFileCurrent;
801
802	LogFlowFunc(("returns %lld\n", cb));
803	return cb;
804	}
805
806	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
807	static int parallelsGetPCHSGeometry(void *pBackendData,
808	PVDGEOMETRY pPCHSGeometry)
809	{
810	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
811	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
812	int rc;
813
814	AssertPtr(pImage);
815
816	if (pImage)
817	{
818	if (pImage->PCHSGeometry.cCylinders)
819	{
820	*pPCHSGeometry = pImage->PCHSGeometry;
821	rc = VINF_SUCCESS;
822	}
823	else
824	rc = VERR_VD_GEOMETRY_NOT_SET;
825	}
826	else
827	rc = VERR_VD_NOT_OPENED;
828
829	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
830	return rc;
831	}
832
833	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
834	static int parallelsSetPCHSGeometry(void *pBackendData,
835	PCVDGEOMETRY pPCHSGeometry)
836	{
837	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
838	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
839	int rc;
840
841	AssertPtr(pImage);
842
843	if (pImage)
844	{
845	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
846	{
847	rc = VERR_VD_IMAGE_READ_ONLY;
848	goto out;
849	}
850
851	pImage->PCHSGeometry = *pPCHSGeometry;
852	rc = VINF_SUCCESS;
853	}
854	else
855	rc = VERR_VD_NOT_OPENED;
856
857	out:
858	LogFlowFunc(("returns %Rrc\n", rc));
859	return rc;
860	}
861
862	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
863	static int parallelsGetLCHSGeometry(void *pBackendData,
864	PVDGEOMETRY pLCHSGeometry)
865	{
866	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
867	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
868	int rc;
869
870	AssertPtr(pImage);
871
872	if (pImage)
873	{
874	if (pImage->LCHSGeometry.cCylinders)
875	{
876	*pLCHSGeometry = pImage->LCHSGeometry;
877	rc = VINF_SUCCESS;
878	}
879	else
880	rc = VERR_VD_GEOMETRY_NOT_SET;
881	}
882	else
883	rc = VERR_VD_NOT_OPENED;
884
885	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
886	return rc;
887	}
888
889	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
890	static int parallelsSetLCHSGeometry(void *pBackendData,
891	PCVDGEOMETRY pLCHSGeometry)
892	{
893	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
894	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
895	int rc;
896
897	AssertPtr(pImage);
898
899	if (pImage)
900	{
901	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
902	{
903	rc = VERR_VD_IMAGE_READ_ONLY;
904	goto out;
905	}
906
907	pImage->LCHSGeometry = *pLCHSGeometry;
908	rc = VINF_SUCCESS;
909	}
910	else
911	rc = VERR_VD_NOT_OPENED;
912
913	out:
914	LogFlowFunc(("returns %Rrc\n", rc));
915	return rc;
916	}
917
918	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
919	static unsigned parallelsGetImageFlags(void *pBackendData)
920	{
921	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
922	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
923	unsigned uImageFlags;
924
925	AssertPtr(pImage);
926
927	if (pImage)
928	uImageFlags = pImage->uImageFlags;
929	else
930	uImageFlags = 0;
931
932	LogFlowFunc(("returns %#x\n", uImageFlags));
933	return uImageFlags;
934	}
935
936	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
937	static unsigned parallelsGetOpenFlags(void *pBackendData)
938	{
939	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
940	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
941	unsigned uOpenFlags;
942
943	AssertPtr(pImage);
944
945	if (pImage)
946	uOpenFlags = pImage->uOpenFlags;
947	else
948	uOpenFlags = 0;
949
950	LogFlowFunc(("returns %#x\n", uOpenFlags));
951	return uOpenFlags;
952	}
953
954	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
955	static int parallelsSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
956	{
957	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
958	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
959	int rc;
960
961	/* Image must be opened and the new flags must be valid. */
962	/** @todo r=klaus add VD_OPEN_FLAGS_ASYNC_IO when async io has been tested */
963	if (!pImage \|\| (uOpenFlags & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_SHAREABLE \| VD_OPEN_FLAGS_SEQUENTIAL)))
964	{
965	rc = VERR_INVALID_PARAMETER;
966	goto out;
967	}
968
969	/* Implement this operation via reopening the image. */
970	parallelsFreeImage(pImage, true);
971	rc = parallelsOpenImage(pImage, uOpenFlags);
972
973	out:
974	LogFlowFunc(("returns %Rrc\n", rc));
975	return rc;
976	}
977
978	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
979	static int parallelsGetComment(void pBackendData, char pszComment,
980	size_t cbComment)
981	{
982	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
983	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
984	int rc;
985
986	AssertPtr(pImage);
987
988	if (pImage)
989	rc = VERR_NOT_SUPPORTED;
990	else
991	rc = VERR_VD_NOT_OPENED;
992
993	LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
994	return rc;
995	}
996
997	/** @copydoc VBOXHDDBACKEND::pfnSetComment */
998	static int parallelsSetComment(void pBackendData, const char pszComment)
999	{
1000	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
1001	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1002	int rc;
1003
1004	AssertPtr(pImage);
1005
1006	if (pImage)
1007	{
1008	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1009	rc = VERR_VD_IMAGE_READ_ONLY;
1010	else
1011	rc = VERR_NOT_SUPPORTED;
1012	}
1013	else
1014	rc = VERR_VD_NOT_OPENED;
1015
1016	out:
1017	LogFlowFunc(("returns %Rrc\n", rc));
1018	return rc;
1019	}
1020
1021	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
1022	static int parallelsGetUuid(void *pBackendData, PRTUUID pUuid)
1023	{
1024	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1025	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1026	int rc;
1027
1028	AssertPtr(pImage);
1029
1030	if (pImage)
1031	rc = VERR_NOT_SUPPORTED;
1032	else
1033	rc = VERR_VD_NOT_OPENED;
1034
1035	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1036	return rc;
1037	}
1038
1039	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
1040	static int parallelsSetUuid(void *pBackendData, PCRTUUID pUuid)
1041	{
1042	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1043	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1044	int rc;
1045
1046	AssertPtr(pImage);
1047
1048	if (pImage)
1049	{
1050	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1051	rc = VERR_NOT_SUPPORTED;
1052	else
1053	rc = VERR_VD_IMAGE_READ_ONLY;
1054	}
1055	else
1056	rc = VERR_VD_NOT_OPENED;
1057
1058	LogFlowFunc(("returns %Rrc\n", rc));
1059	return rc;
1060	}
1061
1062	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
1063	static int parallelsGetModificationUuid(void *pBackendData, PRTUUID pUuid)
1064	{
1065	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1066	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1067	int rc;
1068
1069	AssertPtr(pImage);
1070
1071	if (pImage)
1072	rc = VERR_NOT_SUPPORTED;
1073	else
1074	rc = VERR_VD_NOT_OPENED;
1075
1076	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1077	return rc;
1078	}
1079
1080	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
1081	static int parallelsSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
1082	{
1083	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1084	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1085	int rc;
1086
1087	AssertPtr(pImage);
1088
1089	if (pImage)
1090	{
1091	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1092	rc = VERR_NOT_SUPPORTED;
1093	else
1094	rc = VERR_VD_IMAGE_READ_ONLY;
1095	}
1096	else
1097	rc = VERR_VD_NOT_OPENED;
1098
1099	LogFlowFunc(("returns %Rrc\n", rc));
1100	return rc;
1101	}
1102
1103	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1104	static int parallelsGetParentUuid(void *pBackendData, PRTUUID pUuid)
1105	{
1106	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1107	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1108	int rc;
1109
1110	AssertPtr(pImage);
1111
1112	if (pImage)
1113	rc = VERR_NOT_SUPPORTED;
1114	else
1115	rc = VERR_VD_NOT_OPENED;
1116
1117	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1118	return rc;
1119	}
1120
1121	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1122	static int parallelsSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1123	{
1124	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1125	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1126	int rc;
1127
1128	AssertPtr(pImage);
1129
1130	if (pImage)
1131	{
1132	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1133	rc = VERR_NOT_SUPPORTED;
1134	else
1135	rc = VERR_VD_IMAGE_READ_ONLY;
1136	}
1137	else
1138	rc = VERR_VD_NOT_OPENED;
1139
1140	LogFlowFunc(("returns %Rrc\n", rc));
1141	return rc;
1142	}
1143
1144	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1145	static int parallelsGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1146	{
1147	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1148	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1149	int rc;
1150
1151	AssertPtr(pImage);
1152
1153	if (pImage)
1154	rc = VERR_NOT_SUPPORTED;
1155	else
1156	rc = VERR_VD_NOT_OPENED;
1157
1158	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1159	return rc;
1160	}
1161
1162	/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
1163	static int parallelsSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1164	{
1165	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1166	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1167	int rc;
1168
1169	AssertPtr(pImage);
1170
1171	if (pImage)
1172	{
1173	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1174	rc = VERR_NOT_SUPPORTED;
1175	else
1176	rc = VERR_VD_IMAGE_READ_ONLY;
1177	}
1178	else
1179	rc = VERR_VD_NOT_OPENED;
1180
1181	LogFlowFunc(("returns %Rrc\n", rc));
1182	return rc;
1183	}
1184
1185	/** @copydoc VBOXHDDBACKEND::pfnDump */
1186	static void parallelsDump(void *pBackendData)
1187	{
1188	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1189
1190	AssertPtr(pImage);
1191	if (pImage)
1192	{
1193	parallelsMessage(pImage, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u\n",
1194	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
1195	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors);
1196	}
1197	}
1198
1199	/** @copydoc VBOXHDDBACKEND::pfnIsAsyncIOSupported */
1200	static bool parallelsIsAsyncIOSupported(void *pBackendData)
1201	{
1202	#if 0 /** @todo: Remove when tested */
1203	return true;
1204	#else
1205	return false;
1206	#endif
1207	}
1208
1209	/** @copydoc VBOXHDDBACKEND::pfnAsyncRead */
1210	static int parallelsAsyncRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1211	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1212	{
1213	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
1214	pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
1215	int rc = VINF_SUCCESS;
1216	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1217	uint64_t uSector;
1218	uint64_t uOffsetInFile;
1219	uint32_t iIndexInAllocationTable;
1220
1221	AssertPtr(pImage);
1222	Assert(uOffset % 512 == 0);
1223	Assert(cbToRead % 512 == 0);
1224
1225	if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
1226	{
1227	rc = parallelsFileReadUserAsync(pImage, uOffset, pIoCtx, cbToRead);
1228	}
1229	else
1230	{
1231	/* Calculate offset in the real file. */
1232	uSector = uOffset / 512;
1233	/* One chunk in the file is always one track big. */
1234	iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
1235	uSector = uSector % pImage->PCHSGeometry.cSectors;
1236
1237	cbToRead = RT_MIN(cbToRead, (pImage->PCHSGeometry.cSectors - uSector)*512);
1238
1239	if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
1240	{
1241	rc = VERR_VD_BLOCK_FREE;
1242	}
1243	else
1244	{
1245	uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
1246	rc = parallelsFileReadUserAsync(pImage, uOffsetInFile, pIoCtx, cbToRead);
1247	}
1248	}
1249
1250	*pcbActuallyRead = cbToRead;
1251
1252	LogFlowFunc(("returns %Rrc\n", rc));
1253	return rc;
1254	}
1255
1256	/** @copydoc VBOXHDDBACKEND::pfnAsyncWrite */
1257	static int parallelsAsyncWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1258	PVDIOCTX pIoCtx,
1259	size_t pcbWriteProcess, size_t pcbPreRead,
1260	size_t *pcbPostRead, unsigned fWrite)
1261	{
1262	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p\n",
1263	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess));
1264	int rc = VINF_SUCCESS;
1265	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1266	uint64_t uSector;
1267	uint64_t uOffsetInFile;
1268	uint32_t iIndexInAllocationTable;
1269
1270	AssertPtr(pImage);
1271	Assert(uOffset % 512 == 0);
1272	Assert(cbToWrite % 512 == 0);
1273
1274	if (pImage->uImageFlags & VD_IMAGE_FLAGS_FIXED)
1275	{
1276	rc = parallelsFileWriteUserAsync(pImage, uOffset, pIoCtx, cbToWrite, NULL, NULL);
1277	}
1278	else
1279	{
1280	/* Calculate offset in the real file. */
1281	uSector = uOffset / 512;
1282	/* One chunk in the file is always one track big. */
1283	iIndexInAllocationTable = (uint32_t)(uSector / pImage->PCHSGeometry.cSectors);
1284	uSector = uSector % pImage->PCHSGeometry.cSectors;
1285
1286	cbToWrite = RT_MIN(cbToWrite, (pImage->PCHSGeometry.cSectors - uSector)*512);
1287
1288	if (pImage->pAllocationBitmap[iIndexInAllocationTable] == 0)
1289	{
1290	if (fWrite & VD_WRITE_NO_ALLOC)
1291	{
1292	pcbPreRead = uSector 512;
1293	pcbPostRead = pImage->PCHSGeometry.cSectors 512 - cbToWrite - *pcbPreRead;
1294
1295	if (pcbWriteProcess)
1296	*pcbWriteProcess = cbToWrite;
1297	return VERR_VD_BLOCK_FREE;
1298	}
1299
1300	/* Allocate new chunk in the file. */
1301	Assert(uSector == 0);
1302	AssertMsg(pImage->cbFileCurrent % 512 == 0, ("File size is not a multiple of 512\n"));
1303	pImage->pAllocationBitmap[iIndexInAllocationTable] = (uint32_t)(pImage->cbFileCurrent / 512);
1304	pImage->cbFileCurrent += pImage->PCHSGeometry.cSectors * 512;
1305	pImage->fAllocationBitmapChanged = true;
1306	uOffsetInFile = (uint64_t)pImage->pAllocationBitmap[iIndexInAllocationTable] * 512;
1307
1308	/*
1309	* Write the new block at the current end of the file.
1310	*/
1311	rc = parallelsFileWriteUserAsync(pImage, uOffsetInFile, pIoCtx, cbToWrite, NULL, NULL);
1312	if (RT_SUCCESS(rc) \|\| (rc == VERR_VD_ASYNC_IO_IN_PROGRESS))
1313	{
1314	/* Write the changed allocation bitmap entry. */
1315	/** @todo: Error handling. */
1316	rc = parallelsFileWriteMetaAsync(pImage,
1317	sizeof(ParallelsHeader) + iIndexInAllocationTable * sizeof(uint32_t),
1318	&pImage->pAllocationBitmap[iIndexInAllocationTable],
1319	sizeof(uint32_t), pIoCtx,
1320	NULL, NULL);
1321	}
1322	}
1323	else
1324	{
1325	uOffsetInFile = (pImage->pAllocationBitmap[iIndexInAllocationTable] + uSector) * 512;
1326	rc = parallelsFileWriteUserAsync(pImage, uOffsetInFile, pIoCtx, cbToWrite, NULL, NULL);
1327	}
1328	}
1329
1330	if (pcbWriteProcess)
1331	*pcbWriteProcess = cbToWrite;
1332
1333	LogFlowFunc(("returns %Rrc\n", rc));
1334	return rc;
1335	}
1336
1337	/** @copydoc VBOXHDDBACKEND::pfnAsyncFlush */
1338	static int parallelsAsyncFlush(void *pBackendData, PVDIOCTX pIoCtx)
1339	{
1340	int rc = VINF_SUCCESS;
1341	PPARALLELSIMAGE pImage = (PPARALLELSIMAGE)pBackendData;
1342
1343	LogFlowFunc(("pImage=#%p\n", pImage));
1344
1345	/* Flush the file, everything is up to date already. */
1346	rc = parallelsFileFlushAsync(pImage, pIoCtx, NULL, NULL);
1347
1348	LogFlowFunc(("returns %Rrc\n", rc));
1349	return rc;
1350	}
1351
1352
1353	VBOXHDDBACKEND g_ParallelsBackend =
1354	{
1355	/* pszBackendName */
1356	"Parallels",
1357	/* cbSize */
1358	sizeof(VBOXHDDBACKEND),
1359	/* uBackendCaps */
1360	VD_CAP_FILE \| VD_CAP_ASYNC \| VD_CAP_VFS,
1361	/* paFileExtensions */
1362	s_aParallelsFileExtensions,
1363	/* paConfigInfo */
1364	NULL,
1365	/* hPlugin */
1366	NIL_RTLDRMOD,
1367	/* pfnCheckIfValid */
1368	parallelsCheckIfValid,
1369	/* pfnOpen */
1370	parallelsOpen,
1371	/* pfnCreate */
1372	parallelsCreate,
1373	/* pfnRename */
1374	parallelsRename,
1375	/* pfnClose */
1376	parallelsClose,
1377	/* pfnRead */
1378	parallelsRead,
1379	/* pfnWrite */
1380	parallelsWrite,
1381	/* pfnFlush */
1382	parallelsFlush,
1383	/* pfnGetVersion */
1384	parallelsGetVersion,
1385	/* pfnGetSize */
1386	parallelsGetSize,
1387	/* pfnGetFileSize */
1388	parallelsGetFileSize,
1389	/* pfnGetPCHSGeometry */
1390	parallelsGetPCHSGeometry,
1391	/* pfnSetPCHSGeometry */
1392	parallelsSetPCHSGeometry,
1393	/* pfnGetLCHSGeometry */
1394	parallelsGetLCHSGeometry,
1395	/* pfnSetLCHSGeometry */
1396	parallelsSetLCHSGeometry,
1397	/* pfnGetImageFlags */
1398	parallelsGetImageFlags,
1399	/* pfnGetOpenFlags */
1400	parallelsGetOpenFlags,
1401	/* pfnSetOpenFlags */
1402	parallelsSetOpenFlags,
1403	/* pfnGetComment */
1404	parallelsGetComment,
1405	/* pfnSetComment */
1406	parallelsSetComment,
1407	/* pfnGetUuid */
1408	parallelsGetUuid,
1409	/* pfnSetUuid */
1410	parallelsSetUuid,
1411	/* pfnGetModificationUuid */
1412	parallelsGetModificationUuid,
1413	/* pfnSetModificationUuid */
1414	parallelsSetModificationUuid,
1415	/* pfnGetParentUuid */
1416	parallelsGetParentUuid,
1417	/* pfnSetParentUuid */
1418	parallelsSetParentUuid,
1419	/* pfnGetParentModificationUuid */
1420	parallelsGetParentModificationUuid,
1421	/* pfnSetParentModificationUuid */
1422	parallelsSetParentModificationUuid,
1423	/* pfnDump */
1424	parallelsDump,
1425	/* pfnGetTimeStamp */
1426	NULL,
1427	/* pfnGetParentTimeStamp */
1428	NULL,
1429	/* pfnSetParentTimeStamp */
1430	NULL,
1431	/* pfnGetParentFilename */
1432	NULL,
1433	/* pfnSetParentFilename */
1434	NULL,
1435	/* pfnIsAsyncIOSupported */
1436	parallelsIsAsyncIOSupported,
1437	/* pfnAsyncRead */
1438	parallelsAsyncRead,
1439	/* pfnAsyncWrite */
1440	parallelsAsyncWrite,
1441	/* pfnAsyncFlush */
1442	parallelsAsyncFlush,
1443	/* pfnComposeLocation */
1444	genericFileComposeLocation,
1445	/* pfnComposeName */
1446	genericFileComposeName,
1447	/* pfnCompact */
1448	NULL,
1449	/* pfnResize */
1450	NULL
1451	};

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

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

Download in other formats: