ParallelsHDDCore.cpp@ 22966

Last change on this file since 22966 was 22966, checked in by vboxsync, 15 years ago

Storage: Convert the backends to use the interface for I/O rather than using the RTFile* API directly.

For a VM the PDMAsyncCompletion is used now as the I/O layer (fixing the I/O load problems).
Still disabled by default until it was tested on all supported platforms to not risk corruption
of images. To enable compile with VBOX_WITH_NEW_IO_CODE set.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 37.9 KB

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

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

source: vbox/trunk/src/VBox/Devices/Storage/ParallelsHDDCore.cpp@ 22966

Download in other formats: