RAW.cpp@ 47906

Last change on this file since 47906 was 47297, checked in by vboxsync, 11 years ago
RAW: Added .flp floppy image extension for compatibility with other products.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 34.2 KB

Line
1	/* $Id: RAW.cpp 47297 2013-07-22 12:54:54Z vboxsync $ */
2	/** @file
3	* RawHDDCore - Raw Disk image, Core Code.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	/*******************************************************************************
19	* Header Files *
20	*******************************************************************************/
21	#define LOG_GROUP LOG_GROUP_VD_RAW
22	#include <VBox/vd-plugin.h>
23	#include <VBox/err.h>
24
25	#include <VBox/log.h>
26	#include <iprt/assert.h>
27	#include <iprt/alloc.h>
28	#include <iprt/path.h>
29
30	/*******************************************************************************
31	* Constants And Macros, Structures and Typedefs *
32	*******************************************************************************/
33
34	/**
35	* Raw image data structure.
36	*/
37	typedef struct RAWIMAGE
38	{
39	/** Image name. */
40	const char *pszFilename;
41	/** Storage handle. */
42	PVDIOSTORAGE pStorage;
43
44	/** Pointer to the per-disk VD interface list. */
45	PVDINTERFACE pVDIfsDisk;
46	/** Pointer to the per-image VD interface list. */
47	PVDINTERFACE pVDIfsImage;
48	/** Error interface. */
49	PVDINTERFACEERROR pIfError;
50	/** I/O interface. */
51	PVDINTERFACEIOINT pIfIo;
52
53	/** Open flags passed by VBoxHD layer. */
54	unsigned uOpenFlags;
55	/** Image flags defined during creation or determined during open. */
56	unsigned uImageFlags;
57	/** Total size of the image. */
58	uint64_t cbSize;
59	/** Position in the image (only truly used for sequential access). */
60	uint64_t offAccess;
61	/** Flag if this is a newly created image. */
62	bool fCreate;
63	/** Physical geometry of this image. */
64	VDGEOMETRY PCHSGeometry;
65	/** Logical geometry of this image. */
66	VDGEOMETRY LCHSGeometry;
67
68	} RAWIMAGE, *PRAWIMAGE;
69
70
71	/** Size of write operations when filling an image with zeroes. */
72	#define RAW_FILL_SIZE (128 * _1K)
73
74	/** The maximum reasonable size of a floppy image (big format 2.88MB medium). */
75	#define RAW_MAX_FLOPPY_IMG_SIZE (512 * 82 * 48 * 2)
76
77	/*******************************************************************************
78	* Static Variables *
79	*******************************************************************************/
80
81	/** NULL-terminated array of supported file extensions. */
82	static const VDFILEEXTENSION s_aRawFileExtensions[] =
83	{
84	{"iso", VDTYPE_DVD},
85	{"cdr", VDTYPE_DVD},
86	{"img", VDTYPE_FLOPPY},
87	{"ima", VDTYPE_FLOPPY},
88	{"dsk", VDTYPE_FLOPPY},
89	{"flp", VDTYPE_FLOPPY},
90	{"vfd", VDTYPE_FLOPPY},
91	{NULL, VDTYPE_INVALID}
92	};
93
94	/*******************************************************************************
95	* Internal Functions *
96	*******************************************************************************/
97
98	/**
99	* Internal. Flush image data to disk.
100	*/
101	static int rawFlushImage(PRAWIMAGE pImage)
102	{
103	int rc = VINF_SUCCESS;
104
105	if ( pImage->pStorage
106	&& !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
107	rc = vdIfIoIntFileFlushSync(pImage->pIfIo, pImage->pStorage);
108
109	return rc;
110	}
111
112	/**
113	* Internal. Free all allocated space for representing an image except pImage,
114	* and optionally delete the image from disk.
115	*/
116	static int rawFreeImage(PRAWIMAGE pImage, bool fDelete)
117	{
118	int rc = VINF_SUCCESS;
119
120	/* Freeing a never allocated image (e.g. because the open failed) is
121	* not signalled as an error. After all nothing bad happens. */
122	if (pImage)
123	{
124	if (pImage->pStorage)
125	{
126	/* No point updating the file that is deleted anyway. */
127	if (!fDelete)
128	{
129	/* For newly created images in sequential mode fill it to
130	* the nominal size. */
131	if ( pImage->uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL
132	&& !(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
133	&& pImage->fCreate)
134	{
135	/* Fill rest of image with zeroes, a must for sequential
136	* images to reach the nominal size. */
137	uint64_t uOff;
138	void *pvBuf = RTMemTmpAllocZ(RAW_FILL_SIZE);
139	if (!pvBuf)
140	goto out;
141
142	uOff = pImage->offAccess;
143	/* Write data to all image blocks. */
144	while (uOff < pImage->cbSize)
145	{
146	unsigned cbChunk = (unsigned)RT_MIN(pImage->cbSize,
147	RAW_FILL_SIZE);
148
149	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage,
150	uOff, pvBuf, cbChunk);
151	if (RT_FAILURE(rc))
152	goto out;
153
154	uOff += cbChunk;
155	}
156	out:
157	if (pvBuf)
158	RTMemTmpFree(pvBuf);
159	}
160	rawFlushImage(pImage);
161	}
162
163	rc = vdIfIoIntFileClose(pImage->pIfIo, pImage->pStorage);
164	pImage->pStorage = NULL;
165	}
166
167	if (fDelete && pImage->pszFilename)
168	vdIfIoIntFileDelete(pImage->pIfIo, pImage->pszFilename);
169	}
170
171	LogFlowFunc(("returns %Rrc\n", rc));
172	return rc;
173	}
174
175	/**
176	* Internal: Open an image, constructing all necessary data structures.
177	*/
178	static int rawOpenImage(PRAWIMAGE pImage, unsigned uOpenFlags)
179	{
180	int rc;
181
182	pImage->uOpenFlags = uOpenFlags;
183	pImage->fCreate = false;
184
185	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
186	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
187	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
188
189	/*
190	* Open the image.
191	*/
192	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename,
193	VDOpenFlagsToFileOpenFlags(uOpenFlags,
194	false /* fCreate */),
195	&pImage->pStorage);
196	if (RT_FAILURE(rc))
197	{
198	/* Do NOT signal an appropriate error here, as the VD layer has the
199	* choice of retrying the open if it failed. */
200	goto out;
201	}
202
203	rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &pImage->cbSize);
204	if (RT_FAILURE(rc))
205	goto out;
206	if (pImage->cbSize % 512)
207	{
208	rc = VERR_VD_RAW_INVALID_HEADER;
209	goto out;
210	}
211	pImage->uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
212
213	out:
214	if (RT_FAILURE(rc))
215	rawFreeImage(pImage, false);
216	return rc;
217	}
218
219	/**
220	* Internal: Create a raw image.
221	*/
222	static int rawCreateImage(PRAWIMAGE pImage, uint64_t cbSize,
223	unsigned uImageFlags, const char *pszComment,
224	PCVDGEOMETRY pPCHSGeometry,
225	PCVDGEOMETRY pLCHSGeometry, unsigned uOpenFlags,
226	PFNVDPROGRESS pfnProgress, void *pvUser,
227	unsigned uPercentStart, unsigned uPercentSpan)
228	{
229	int rc;
230	RTFOFF cbFree = 0;
231	uint64_t uOff;
232	void *pvBuf = NULL;
233	int32_t fOpen;
234
235	uImageFlags \|= VD_IMAGE_FLAGS_FIXED;
236
237	pImage->uOpenFlags = uOpenFlags & ~VD_OPEN_FLAGS_READONLY;
238
239	pImage->uImageFlags = uImageFlags;
240	pImage->fCreate = true;
241	pImage->PCHSGeometry = *pPCHSGeometry;
242	pImage->LCHSGeometry = *pLCHSGeometry;
243
244	pImage->pIfError = VDIfErrorGet(pImage->pVDIfsDisk);
245	pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
246	AssertPtrReturn(pImage->pIfIo, VERR_INVALID_PARAMETER);
247
248	if (uImageFlags & VD_IMAGE_FLAGS_DIFF)
249	{
250	rc = vdIfError(pImage->pIfError, VERR_VD_RAW_INVALID_TYPE, RT_SRC_POS, N_("Raw: cannot create diff image '%s'"), pImage->pszFilename);
251	goto out;
252	}
253
254	/* Create image file. */
255	fOpen = VDOpenFlagsToFileOpenFlags(pImage->uOpenFlags, true /* fCreate */);
256	if (uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL)
257	fOpen &= ~RTFILE_O_READ;
258	rc = vdIfIoIntFileOpen(pImage->pIfIo, pImage->pszFilename, fOpen, &pImage->pStorage);
259	if (RT_FAILURE(rc))
260	{
261	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Raw: cannot create image '%s'"), pImage->pszFilename);
262	goto out;
263	}
264
265	if (!(uOpenFlags & VD_OPEN_FLAGS_SEQUENTIAL))
266	{
267	/* Check the free space on the disk and leave early if there is not
268	* sufficient space available. */
269	rc = vdIfIoIntFileGetFreeSpace(pImage->pIfIo, pImage->pszFilename, &cbFree);
270	if (RT_SUCCESS(rc) /* ignore errors */ && ((uint64_t)cbFree < cbSize))
271	{
272	rc = vdIfError(pImage->pIfError, VERR_DISK_FULL, RT_SRC_POS, N_("Raw: disk would overflow creating image '%s'"), pImage->pszFilename);
273	goto out;
274	}
275
276	/* Allocate & commit whole file if fixed image, it must be more
277	* effective than expanding file by write operations. */
278	rc = vdIfIoIntFileSetSize(pImage->pIfIo, pImage->pStorage, cbSize);
279	if (RT_FAILURE(rc))
280	{
281	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Raw: setting image size failed for '%s'"), pImage->pszFilename);
282	goto out;
283	}
284
285	/* Fill image with zeroes. We do this for every fixed-size image since
286	* on some systems (for example Windows Vista), it takes ages to write
287	* a block near the end of a sparse file and the guest could complain
288	* about an ATA timeout. */
289	pvBuf = RTMemTmpAllocZ(RAW_FILL_SIZE);
290	if (!pvBuf)
291	{
292	rc = VERR_NO_MEMORY;
293	goto out;
294	}
295
296	uOff = 0;
297	/* Write data to all image blocks. */
298	while (uOff < cbSize)
299	{
300	unsigned cbChunk = (unsigned)RT_MIN(cbSize, RAW_FILL_SIZE);
301
302	rc = vdIfIoIntFileWriteSync(pImage->pIfIo, pImage->pStorage, uOff,
303	pvBuf, cbChunk);
304	if (RT_FAILURE(rc))
305	{
306	rc = vdIfError(pImage->pIfError, rc, RT_SRC_POS, N_("Raw: writing block failed for '%s'"), pImage->pszFilename);
307	goto out;
308	}
309
310	uOff += cbChunk;
311
312	if (pfnProgress)
313	{
314	rc = pfnProgress(pvUser,
315	uPercentStart + uOff * uPercentSpan * 98 / (cbSize * 100));
316	if (RT_FAILURE(rc))
317	goto out;
318	}
319	}
320	}
321
322	if (RT_SUCCESS(rc) && pfnProgress)
323	pfnProgress(pvUser, uPercentStart + uPercentSpan * 98 / 100);
324
325	pImage->cbSize = cbSize;
326
327	rc = rawFlushImage(pImage);
328
329	out:
330	if (pvBuf)
331	RTMemTmpFree(pvBuf);
332
333	if (RT_SUCCESS(rc) && pfnProgress)
334	pfnProgress(pvUser, uPercentStart + uPercentSpan);
335
336	if (RT_FAILURE(rc))
337	rawFreeImage(pImage, rc != VERR_ALREADY_EXISTS);
338	return rc;
339	}
340
341
342	/** @copydoc VBOXHDDBACKEND::pfnCheckIfValid */
343	static int rawCheckIfValid(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
344	PVDINTERFACE pVDIfsImage, VDTYPE *penmType)
345	{
346	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
347	PVDIOSTORAGE pStorage = NULL;
348	uint64_t cbFile;
349	int rc = VINF_SUCCESS;
350	char *pszExtension = NULL;
351
352	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
353	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
354
355	if ( !VALID_PTR(pszFilename)
356	\|\| !*pszFilename)
357	{
358	rc = VERR_INVALID_PARAMETER;
359	goto out;
360	}
361
362	pszExtension = RTPathExt(pszFilename);
363
364	/*
365	* Open the file and read the footer.
366	*/
367	rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
368	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY,
369	false /* fCreate */),
370	&pStorage);
371	if (RT_SUCCESS(rc))
372	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
373
374	/* Try to guess the image type based on the extension. */
375	if ( RT_SUCCESS(rc)
376	&& pszExtension)
377	{
378	if ( !RTStrICmp(pszExtension, ".iso")
379	\|\| !RTStrICmp(pszExtension, ".cdr")) /* DVD images. */
380	{
381	/* Note that there are ISO images smaller than 1 MB; it is impossible to distinguish
382	* between raw floppy and CD images based on their size (and cannot be reliably done
383	* based on contents, either).
384	*/
385	if (cbFile > 32768 && !(cbFile % 2048))
386	{
387	*penmType = VDTYPE_DVD;
388	rc = VINF_SUCCESS;
389	}
390	else
391	rc = VERR_VD_RAW_INVALID_HEADER;
392	}
393	else if ( !RTStrICmp(pszExtension, ".img")
394	\|\| !RTStrICmp(pszExtension, ".ima")
395	\|\| !RTStrICmp(pszExtension, ".dsk")
396	\|\| !RTStrICmp(pszExtension, ".flp")
397	\|\| !RTStrICmp(pszExtension, ".vfd")) /* Floppy images */
398	{
399	if (!(cbFile % 512) && cbFile <= RAW_MAX_FLOPPY_IMG_SIZE)
400	{
401	*penmType = VDTYPE_FLOPPY;
402	rc = VINF_SUCCESS;
403	}
404	else
405	rc = VERR_VD_RAW_INVALID_HEADER;
406	}
407	else
408	rc = VERR_VD_RAW_INVALID_HEADER;
409	}
410	else
411	rc = VERR_VD_RAW_INVALID_HEADER;
412
413	if (pStorage)
414	vdIfIoIntFileClose(pIfIo, pStorage);
415
416	out:
417	LogFlowFunc(("returns %Rrc\n", rc));
418	return rc;
419	}
420
421	/** @copydoc VBOXHDDBACKEND::pfnOpen */
422	static int rawOpen(const char *pszFilename, unsigned uOpenFlags,
423	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
424	VDTYPE enmType, void **ppBackendData)
425	{
426	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, ppBackendData));
427	int rc;
428	PRAWIMAGE pImage;
429
430	/* Check open flags. All valid flags are supported. */
431	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
432	{
433	rc = VERR_INVALID_PARAMETER;
434	goto out;
435	}
436
437	/* Check remaining arguments. */
438	if ( !VALID_PTR(pszFilename)
439	\|\| !*pszFilename)
440	{
441	rc = VERR_INVALID_PARAMETER;
442	goto out;
443	}
444
445
446	pImage = (PRAWIMAGE)RTMemAllocZ(sizeof(RAWIMAGE));
447	if (!pImage)
448	{
449	rc = VERR_NO_MEMORY;
450	goto out;
451	}
452	pImage->pszFilename = pszFilename;
453	pImage->pStorage = NULL;
454	pImage->pVDIfsDisk = pVDIfsDisk;
455	pImage->pVDIfsImage = pVDIfsImage;
456
457	rc = rawOpenImage(pImage, uOpenFlags);
458	if (RT_SUCCESS(rc))
459	*ppBackendData = pImage;
460	else
461	RTMemFree(pImage);
462
463	out:
464	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
465	return rc;
466	}
467
468	/** @copydoc VBOXHDDBACKEND::pfnCreate */
469	static int rawCreate(const char *pszFilename, uint64_t cbSize,
470	unsigned uImageFlags, const char *pszComment,
471	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
472	PCRTUUID pUuid, unsigned uOpenFlags,
473	unsigned uPercentStart, unsigned uPercentSpan,
474	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
475	PVDINTERFACE pVDIfsOperation, void **ppBackendData)
476	{
477	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));
478	int rc;
479	PRAWIMAGE pImage;
480
481	PFNVDPROGRESS pfnProgress = NULL;
482	void *pvUser = NULL;
483	PVDINTERFACEPROGRESS pIfProgress = VDIfProgressGet(pVDIfsOperation);
484	if (pIfProgress)
485	{
486	pfnProgress = pIfProgress->pfnProgress;
487	pvUser = pIfProgress->Core.pvUser;
488	}
489
490	/* Check open flags. All valid flags are supported. */
491	if (uOpenFlags & ~VD_OPEN_FLAGS_MASK)
492	{
493	rc = VERR_INVALID_PARAMETER;
494	goto out;
495	}
496
497	/* Check remaining arguments. */
498	if ( !VALID_PTR(pszFilename)
499	\|\| !*pszFilename
500	\|\| !VALID_PTR(pPCHSGeometry)
501	\|\| !VALID_PTR(pLCHSGeometry))
502	{
503	rc = VERR_INVALID_PARAMETER;
504	goto out;
505	}
506
507	pImage = (PRAWIMAGE)RTMemAllocZ(sizeof(RAWIMAGE));
508	if (!pImage)
509	{
510	rc = VERR_NO_MEMORY;
511	goto out;
512	}
513	pImage->pszFilename = pszFilename;
514	pImage->pStorage = NULL;
515	pImage->pVDIfsDisk = pVDIfsDisk;
516	pImage->pVDIfsImage = pVDIfsImage;
517
518	rc = rawCreateImage(pImage, cbSize, uImageFlags, pszComment,
519	pPCHSGeometry, pLCHSGeometry, uOpenFlags,
520	pfnProgress, pvUser, uPercentStart, uPercentSpan);
521	if (RT_SUCCESS(rc))
522	{
523	/* So far the image is opened in read/write mode. Make sure the
524	* image is opened in read-only mode if the caller requested that. */
525	if (uOpenFlags & VD_OPEN_FLAGS_READONLY)
526	{
527	rawFreeImage(pImage, false);
528	rc = rawOpenImage(pImage, uOpenFlags);
529	if (RT_FAILURE(rc))
530	{
531	RTMemFree(pImage);
532	goto out;
533	}
534	}
535	*ppBackendData = pImage;
536	}
537	else
538	RTMemFree(pImage);
539
540	out:
541	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
542	return rc;
543	}
544
545	/** @copydoc VBOXHDDBACKEND::pfnRename */
546	static int rawRename(void pBackendData, const char pszFilename)
547	{
548	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
549	int rc = VINF_SUCCESS;
550	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
551
552	/* Check arguments. */
553	if ( !pImage
554	\|\| !pszFilename
555	\|\| !*pszFilename)
556	{
557	rc = VERR_INVALID_PARAMETER;
558	goto out;
559	}
560
561	/* Close the image. */
562	rc = rawFreeImage(pImage, false);
563	if (RT_FAILURE(rc))
564	goto out;
565
566	/* Rename the file. */
567	rc = vdIfIoIntFileMove(pImage->pIfIo, pImage->pszFilename, pszFilename, 0);
568	if (RT_FAILURE(rc))
569	{
570	/* The move failed, try to reopen the original image. */
571	int rc2 = rawOpenImage(pImage, pImage->uOpenFlags);
572	if (RT_FAILURE(rc2))
573	rc = rc2;
574
575	goto out;
576	}
577
578	/* Update pImage with the new information. */
579	pImage->pszFilename = pszFilename;
580
581	/* Open the old image with new name. */
582	rc = rawOpenImage(pImage, pImage->uOpenFlags);
583	if (RT_FAILURE(rc))
584	goto out;
585
586	out:
587	LogFlowFunc(("returns %Rrc\n", rc));
588	return rc;
589	}
590
591	/** @copydoc VBOXHDDBACKEND::pfnClose */
592	static int rawClose(void *pBackendData, bool fDelete)
593	{
594	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
595	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
596	int rc;
597
598	rc = rawFreeImage(pImage, fDelete);
599	RTMemFree(pImage);
600
601	LogFlowFunc(("returns %Rrc\n", rc));
602	return rc;
603	}
604
605	/** @copydoc VBOXHDDBACKEND::pfnRead */
606	static int rawRead(void *pBackendData, uint64_t uOffset, size_t cbRead,
607	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
608	{
609	int rc = VINF_SUCCESS;
610	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
611
612	rc = vdIfIoIntFileReadUser(pImage->pIfIo, pImage->pStorage, uOffset,
613	pIoCtx, cbRead);
614	if (RT_SUCCESS(rc))
615	*pcbActuallyRead = cbRead;
616
617	return rc;
618	}
619
620	/** @copydoc VBOXHDDBACKEND::pfnWrite */
621	static int rawWrite(void *pBackendData, uint64_t uOffset, size_t cbWrite,
622	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
623	size_t *pcbPostRead, unsigned fWrite)
624	{
625	int rc = VINF_SUCCESS;
626	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
627
628	rc = vdIfIoIntFileWriteUser(pImage->pIfIo, pImage->pStorage, uOffset,
629	pIoCtx, cbWrite, NULL, NULL);
630	if (RT_SUCCESS(rc))
631	{
632	*pcbWriteProcess = cbWrite;
633	*pcbPostRead = 0;
634	*pcbPreRead = 0;
635	}
636
637	return rc;
638	}
639
640	/** @copydoc VBOXHDDBACKEND::pfnFlush */
641	static int rawFlush(void *pBackendData, PVDIOCTX pIoCtx)
642	{
643	int rc = VINF_SUCCESS;
644	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
645
646	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
647	rc = vdIfIoIntFileFlush(pImage->pIfIo, pImage->pStorage, pIoCtx,
648	NULL, NULL);
649
650	return rc;
651	}
652
653	/** @copydoc VBOXHDDBACKEND::pfnGetVersion */
654	static unsigned rawGetVersion(void *pBackendData)
655	{
656	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
657	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
658
659	AssertPtr(pImage);
660
661	if (pImage)
662	return 1;
663	else
664	return 0;
665	}
666
667	/** @copydoc VBOXHDDBACKEND::pfnGetSize */
668	static uint64_t rawGetSize(void *pBackendData)
669	{
670	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
671	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
672	uint64_t cb = 0;
673
674	AssertPtr(pImage);
675
676	if (pImage && pImage->pStorage)
677	cb = pImage->cbSize;
678
679	LogFlowFunc(("returns %llu\n", cb));
680	return cb;
681	}
682
683	/** @copydoc VBOXHDDBACKEND::pfnGetFileSize */
684	static uint64_t rawGetFileSize(void *pBackendData)
685	{
686	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
687	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
688	uint64_t cb = 0;
689
690	AssertPtr(pImage);
691
692	if (pImage)
693	{
694	uint64_t cbFile;
695	if (pImage->pStorage)
696	{
697	int rc = vdIfIoIntFileGetSize(pImage->pIfIo, pImage->pStorage, &cbFile);
698	if (RT_SUCCESS(rc))
699	cb += cbFile;
700	}
701	}
702
703	LogFlowFunc(("returns %lld\n", cb));
704	return cb;
705	}
706
707	/** @copydoc VBOXHDDBACKEND::pfnGetPCHSGeometry */
708	static int rawGetPCHSGeometry(void *pBackendData,
709	PVDGEOMETRY pPCHSGeometry)
710	{
711	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
712	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
713	int rc;
714
715	AssertPtr(pImage);
716
717	if (pImage)
718	{
719	if (pImage->PCHSGeometry.cCylinders)
720	{
721	*pPCHSGeometry = pImage->PCHSGeometry;
722	rc = VINF_SUCCESS;
723	}
724	else
725	rc = VERR_VD_GEOMETRY_NOT_SET;
726	}
727	else
728	rc = VERR_VD_NOT_OPENED;
729
730	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
731	return rc;
732	}
733
734	/** @copydoc VBOXHDDBACKEND::pfnSetPCHSGeometry */
735	static int rawSetPCHSGeometry(void *pBackendData,
736	PCVDGEOMETRY pPCHSGeometry)
737	{
738	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n", pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
739	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
740	int rc;
741
742	AssertPtr(pImage);
743
744	if (pImage)
745	{
746	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
747	{
748	rc = VERR_VD_IMAGE_READ_ONLY;
749	goto out;
750	}
751
752	pImage->PCHSGeometry = *pPCHSGeometry;
753	rc = VINF_SUCCESS;
754	}
755	else
756	rc = VERR_VD_NOT_OPENED;
757
758	out:
759	LogFlowFunc(("returns %Rrc\n", rc));
760	return rc;
761	}
762
763	/** @copydoc VBOXHDDBACKEND::pfnGetLCHSGeometry */
764	static int rawGetLCHSGeometry(void *pBackendData,
765	PVDGEOMETRY pLCHSGeometry)
766	{
767	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
768	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
769	int rc;
770
771	AssertPtr(pImage);
772
773	if (pImage)
774	{
775	if (pImage->LCHSGeometry.cCylinders)
776	{
777	*pLCHSGeometry = pImage->LCHSGeometry;
778	rc = VINF_SUCCESS;
779	}
780	else
781	rc = VERR_VD_GEOMETRY_NOT_SET;
782	}
783	else
784	rc = VERR_VD_NOT_OPENED;
785
786	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
787	return rc;
788	}
789
790	/** @copydoc VBOXHDDBACKEND::pfnSetLCHSGeometry */
791	static int rawSetLCHSGeometry(void *pBackendData,
792	PCVDGEOMETRY pLCHSGeometry)
793	{
794	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n", pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
795	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
796	int rc;
797
798	AssertPtr(pImage);
799
800	if (pImage)
801	{
802	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
803	{
804	rc = VERR_VD_IMAGE_READ_ONLY;
805	goto out;
806	}
807
808	pImage->LCHSGeometry = *pLCHSGeometry;
809	rc = VINF_SUCCESS;
810	}
811	else
812	rc = VERR_VD_NOT_OPENED;
813
814	out:
815	LogFlowFunc(("returns %Rrc\n", rc));
816	return rc;
817	}
818
819	/** @copydoc VBOXHDDBACKEND::pfnGetImageFlags */
820	static unsigned rawGetImageFlags(void *pBackendData)
821	{
822	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
823	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
824	unsigned uImageFlags;
825
826	AssertPtr(pImage);
827
828	if (pImage)
829	uImageFlags = pImage->uImageFlags;
830	else
831	uImageFlags = 0;
832
833	LogFlowFunc(("returns %#x\n", uImageFlags));
834	return uImageFlags;
835	}
836
837	/** @copydoc VBOXHDDBACKEND::pfnGetOpenFlags */
838	static unsigned rawGetOpenFlags(void *pBackendData)
839	{
840	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
841	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
842	unsigned uOpenFlags;
843
844	AssertPtr(pImage);
845
846	if (pImage)
847	uOpenFlags = pImage->uOpenFlags;
848	else
849	uOpenFlags = 0;
850
851	LogFlowFunc(("returns %#x\n", uOpenFlags));
852	return uOpenFlags;
853	}
854
855	/** @copydoc VBOXHDDBACKEND::pfnSetOpenFlags */
856	static int rawSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
857	{
858	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
859	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
860	int rc;
861
862	/* Image must be opened and the new flags must be valid. */
863	if (!pImage \|\| (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
864	\| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE
865	\| VD_OPEN_FLAGS_SEQUENTIAL \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
866	{
867	rc = VERR_INVALID_PARAMETER;
868	goto out;
869	}
870
871	/* Implement this operation via reopening the image. */
872	rc = rawFreeImage(pImage, false);
873	if (RT_FAILURE(rc))
874	goto out;
875	rc = rawOpenImage(pImage, uOpenFlags);
876
877	out:
878	LogFlowFunc(("returns %Rrc\n", rc));
879	return rc;
880	}
881
882	/** @copydoc VBOXHDDBACKEND::pfnGetComment */
883	static int rawGetComment(void pBackendData, char pszComment,
884	size_t cbComment)
885	{
886	LogFlowFunc(("pBackendData=%#p pszComment=%#p cbComment=%zu\n", pBackendData, pszComment, cbComment));
887	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
888	int rc;
889
890	AssertPtr(pImage);
891
892	if (pImage)
893	rc = VERR_NOT_SUPPORTED;
894	else
895	rc = VERR_VD_NOT_OPENED;
896
897	LogFlowFunc(("returns %Rrc comment='%s'\n", rc, pszComment));
898	return rc;
899	}
900
901	/** @copydoc VBOXHDDBACKEND::pfnSetComment */
902	static int rawSetComment(void pBackendData, const char pszComment)
903	{
904	LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
905	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
906	int rc;
907
908	AssertPtr(pImage);
909
910	if (pImage)
911	{
912	if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
913	rc = VERR_VD_IMAGE_READ_ONLY;
914	else
915	rc = VERR_NOT_SUPPORTED;
916	}
917	else
918	rc = VERR_VD_NOT_OPENED;
919
920	LogFlowFunc(("returns %Rrc\n", rc));
921	return rc;
922	}
923
924	/** @copydoc VBOXHDDBACKEND::pfnGetUuid */
925	static int rawGetUuid(void *pBackendData, PRTUUID pUuid)
926	{
927	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
928	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
929	int rc;
930
931	AssertPtr(pImage);
932
933	if (pImage)
934	rc = VERR_NOT_SUPPORTED;
935	else
936	rc = VERR_VD_NOT_OPENED;
937
938	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
939	return rc;
940	}
941
942	/** @copydoc VBOXHDDBACKEND::pfnSetUuid */
943	static int rawSetUuid(void *pBackendData, PCRTUUID pUuid)
944	{
945	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
946	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
947	int rc;
948
949	LogFlowFunc(("%RTuuid\n", pUuid));
950	AssertPtr(pImage);
951
952	if (pImage)
953	{
954	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
955	rc = VERR_NOT_SUPPORTED;
956	else
957	rc = VERR_VD_IMAGE_READ_ONLY;
958	}
959	else
960	rc = VERR_VD_NOT_OPENED;
961
962	LogFlowFunc(("returns %Rrc\n", rc));
963	return rc;
964	}
965
966	/** @copydoc VBOXHDDBACKEND::pfnGetModificationUuid */
967	static int rawGetModificationUuid(void *pBackendData, PRTUUID pUuid)
968	{
969	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
970	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
971	int rc;
972
973	AssertPtr(pImage);
974
975	if (pImage)
976	rc = VERR_NOT_SUPPORTED;
977	else
978	rc = VERR_VD_NOT_OPENED;
979
980	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
981	return rc;
982	}
983
984	/** @copydoc VBOXHDDBACKEND::pfnSetModificationUuid */
985	static int rawSetModificationUuid(void *pBackendData, PCRTUUID pUuid)
986	{
987	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
988	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
989	int rc;
990
991	AssertPtr(pImage);
992
993	if (pImage)
994	{
995	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
996	rc = VERR_NOT_SUPPORTED;
997	else
998	rc = VERR_VD_IMAGE_READ_ONLY;
999	}
1000	else
1001	rc = VERR_VD_NOT_OPENED;
1002
1003	LogFlowFunc(("returns %Rrc\n", rc));
1004	return rc;
1005	}
1006
1007	/** @copydoc VBOXHDDBACKEND::pfnGetParentUuid */
1008	static int rawGetParentUuid(void *pBackendData, PRTUUID pUuid)
1009	{
1010	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1011	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
1012	int rc;
1013
1014	AssertPtr(pImage);
1015
1016	if (pImage)
1017	rc = VERR_NOT_SUPPORTED;
1018	else
1019	rc = VERR_VD_NOT_OPENED;
1020
1021	LogFlowFunc(("returns %Rrc (%RTuuid)\n", rc, pUuid));
1022	return rc;
1023	}
1024
1025	/** @copydoc VBOXHDDBACKEND::pfnSetParentUuid */
1026	static int rawSetParentUuid(void *pBackendData, PCRTUUID pUuid)
1027	{
1028	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1029	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
1030	int rc;
1031
1032	AssertPtr(pImage);
1033
1034	if (pImage)
1035	{
1036	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1037	rc = VERR_NOT_SUPPORTED;
1038	else
1039	rc = VERR_VD_IMAGE_READ_ONLY;
1040	}
1041	else
1042	rc = VERR_VD_NOT_OPENED;
1043
1044	LogFlowFunc(("returns %Rrc\n", rc));
1045	return rc;
1046	}
1047
1048	/** @copydoc VBOXHDDBACKEND::pfnGetParentModificationUuid */
1049	static int rawGetParentModificationUuid(void *pBackendData, PRTUUID pUuid)
1050	{
1051	LogFlowFunc(("pBackendData=%#p pUuid=%#p\n", pBackendData, pUuid));
1052	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
1053	int rc;
1054
1055	AssertPtr(pImage);
1056
1057	if (pImage)
1058	rc = VERR_NOT_SUPPORTED;
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::pfnSetParentModificationUuid */
1067	static int rawSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
1068	{
1069	LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
1070	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
1071	int rc;
1072
1073	AssertPtr(pImage);
1074
1075	if (pImage)
1076	{
1077	if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
1078	rc = VERR_NOT_SUPPORTED;
1079	else
1080	rc = VERR_VD_IMAGE_READ_ONLY;
1081	}
1082	else
1083	rc = VERR_VD_NOT_OPENED;
1084
1085	LogFlowFunc(("returns %Rrc\n", rc));
1086	return rc;
1087	}
1088
1089	/** @copydoc VBOXHDDBACKEND::pfnDump */
1090	static void rawDump(void *pBackendData)
1091	{
1092	PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
1093
1094	AssertPtr(pImage);
1095	if (pImage)
1096	{
1097	vdIfErrorMessage(pImage->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cbSector=%llu\n",
1098	pImage->PCHSGeometry.cCylinders, pImage->PCHSGeometry.cHeads, pImage->PCHSGeometry.cSectors,
1099	pImage->LCHSGeometry.cCylinders, pImage->LCHSGeometry.cHeads, pImage->LCHSGeometry.cSectors,
1100	pImage->cbSize / 512);
1101	}
1102	}
1103
1104
1105
1106	VBOXHDDBACKEND g_RawBackend =
1107	{
1108	/* pszBackendName */
1109	"RAW",
1110	/* cbSize */
1111	sizeof(VBOXHDDBACKEND),
1112	/* uBackendCaps */
1113	VD_CAP_CREATE_FIXED \| VD_CAP_FILE \| VD_CAP_ASYNC \| VD_CAP_VFS,
1114	/* paFileExtensions */
1115	s_aRawFileExtensions,
1116	/* paConfigInfo */
1117	NULL,
1118	/* hPlugin */
1119	NIL_RTLDRMOD,
1120	/* pfnCheckIfValid */
1121	rawCheckIfValid,
1122	/* pfnOpen */
1123	rawOpen,
1124	/* pfnCreate */
1125	rawCreate,
1126	/* pfnRename */
1127	rawRename,
1128	/* pfnClose */
1129	rawClose,
1130	/* pfnRead */
1131	rawRead,
1132	/* pfnWrite */
1133	rawWrite,
1134	/* pfnFlush */
1135	rawFlush,
1136	/* pfnDiscard */
1137	NULL,
1138	/* pfnGetVersion */
1139	rawGetVersion,
1140	/* pfnGetSize */
1141	rawGetSize,
1142	/* pfnGetFileSize */
1143	rawGetFileSize,
1144	/* pfnGetPCHSGeometry */
1145	rawGetPCHSGeometry,
1146	/* pfnSetPCHSGeometry */
1147	rawSetPCHSGeometry,
1148	/* pfnGetLCHSGeometry */
1149	rawGetLCHSGeometry,
1150	/* pfnSetLCHSGeometry */
1151	rawSetLCHSGeometry,
1152	/* pfnGetImageFlags */
1153	rawGetImageFlags,
1154	/* pfnGetOpenFlags */
1155	rawGetOpenFlags,
1156	/* pfnSetOpenFlags */
1157	rawSetOpenFlags,
1158	/* pfnGetComment */
1159	rawGetComment,
1160	/* pfnSetComment */
1161	rawSetComment,
1162	/* pfnGetUuid */
1163	rawGetUuid,
1164	/* pfnSetUuid */
1165	rawSetUuid,
1166	/* pfnGetModificationUuid */
1167	rawGetModificationUuid,
1168	/* pfnSetModificationUuid */
1169	rawSetModificationUuid,
1170	/* pfnGetParentUuid */
1171	rawGetParentUuid,
1172	/* pfnSetParentUuid */
1173	rawSetParentUuid,
1174	/* pfnGetParentModificationUuid */
1175	rawGetParentModificationUuid,
1176	/* pfnSetParentModificationUuid */
1177	rawSetParentModificationUuid,
1178	/* pfnDump */
1179	rawDump,
1180	/* pfnGetTimeStamp */
1181	NULL,
1182	/* pfnGetParentTimeStamp */
1183	NULL,
1184	/* pfnSetParentTimeStamp */
1185	NULL,
1186	/* pfnGetParentFilename */
1187	NULL,
1188	/* pfnSetParentFilename */
1189	NULL,
1190	/* pfnComposeLocation */
1191	genericFileComposeLocation,
1192	/* pfnComposeName */
1193	genericFileComposeName,
1194	/* pfnCompact */
1195	NULL,
1196	/* pfnResize */
1197	NULL,
1198	/* pfnRepair */
1199	NULL
1200	};

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

source: vbox/trunk/src/VBox/Storage/RAW.cpp@ 47906

Download in other formats: