VDVfs.cpp@ 106129

Last change on this file since 106129 was 106061, checked in by vboxsync, 2 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.0 KB

Line
1	/* $Id: VDVfs.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* Virtual Disk Container implementation. - VFS glue.
4	*/
5
6	/*
7	* Copyright (C) 2012-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#include <iprt/types.h>
33	#include <iprt/assert.h>
34	#include <iprt/mem.h>
35	#include <iprt/err.h>
36	#include <iprt/asm.h>
37	#include <iprt/string.h>
38	#include <iprt/file.h>
39	#include <iprt/sg.h>
40	#include <iprt/vfslowlevel.h>
41	#include <iprt/poll.h>
42	#include <VBox/vd.h>
43
44	#include "VDInternal.h"
45
46
47	/*********************************************************************************************************************************
48	* Structures and Typedefs *
49	*********************************************************************************************************************************/
50
51	/**
52	* The internal data of a DVM volume I/O stream.
53	*/
54	typedef struct VDVFSFILE
55	{
56	/** The volume the VFS file belongs to. */
57	PVDISK pDisk;
58	/** Current position. */
59	uint64_t offCurPos;
60	/** Flags given during creation. */
61	uint32_t fFlags;
62	} VDVFSFILE;
63	/** Pointer to a the internal data of a DVM volume file. */
64	typedef VDVFSFILE *PVDVFSFILE;
65
66	/**
67	* VD read helper taking care of unaligned accesses.
68	*
69	* @return VBox status code.
70	* @param pDisk VD disk container.
71	* @param off Offset to start reading from.
72	* @param pvBuf Pointer to the buffer to read into.
73	* @param cbRead Amount of bytes to read.
74	*/
75	static int vdReadHelper(PVDISK pDisk, uint64_t off, void *pvBuf, size_t cbRead)
76	{
77	int rc;
78
79	/* Take direct route if the request is sector aligned. */
80	uint64_t const offMisalign = off & 511;
81	size_t const cbMisalign = (off + cbRead) & 511;
82	if ( !offMisalign
83	&& !cbMisalign)
84	rc = VDRead(pDisk, off, pvBuf, cbRead);
85	else
86	{
87	uint8_t pbBuf = (uint8_t )pvBuf;
88	uint8_t abBuf[512];
89
90	/* Unaligned buffered read of head. Aligns the offset. */
91	if (offMisalign)
92	{
93	rc = VDRead(pDisk, off - offMisalign, abBuf, 512);
94	if (RT_SUCCESS(rc))
95	{
96	size_t const cbPart = RT_MIN(512 - offMisalign, cbRead);
97	memcpy(pbBuf, &abBuf[offMisalign], cbPart);
98	pbBuf += cbPart;
99	off += cbPart;
100	cbRead -= cbPart;
101	}
102	}
103	else
104	rc = VINF_SUCCESS;
105
106	/* Aligned direct read. */
107	if ( RT_SUCCESS(rc)
108	&& cbRead >= 512)
109	{
110	Assert(!(off % 512));
111
112	size_t cbPart = cbRead - cbMisalign;
113	Assert(!(cbPart % 512));
114	rc = VDRead(pDisk, off, pbBuf, cbPart);
115	if (RT_SUCCESS(rc))
116	{
117	pbBuf += cbPart;
118	off += cbPart;
119	cbRead -= cbPart;
120	}
121	}
122
123	/* Unaligned buffered read of tail. */
124	if ( RT_SUCCESS(rc)
125	&& cbRead)
126	{
127	Assert(cbRead == cbMisalign);
128	Assert(cbRead < 512);
129	Assert(!(off % 512));
130
131	rc = VDRead(pDisk, off, abBuf, 512);
132	if (RT_SUCCESS(rc))
133	memcpy(pbBuf, abBuf, cbRead);
134	}
135	}
136
137	return rc;
138	}
139
140
141	/**
142	* VD write helper taking care of unaligned accesses.
143	*
144	* @return VBox status code.
145	* @param pDisk VD disk container.
146	* @param off Offset to start writing to.
147	* @param pvSrc Pointer to the buffer to read from.
148	* @param cbWrite Amount of bytes to write.
149	*/
150	static int vdWriteHelper(PVDISK pDisk, uint64_t off, const void *pvSrc, size_t cbWrite)
151	{
152	uint8_t const pbSrc = (uint8_t const )pvSrc;
153	uint8_t abBuf[4096];
154	int rc;
155
156	/*
157	* Take direct route if the request is sector aligned.
158	*/
159	uint64_t const offMisalign = off & 511;
160	size_t const cbMisalign = (off + cbWrite) & 511;
161	if ( !offMisalign
162	&& !cbMisalign)
163	{
164	if (RTListIsEmpty(&pDisk->ListFilterChainWrite))
165	rc = VDWrite(pDisk, off, pbSrc, cbWrite);
166	else
167	{
168	/* Filtered writes must be double buffered as the filter may need to modify the input buffer directly. */
169	do
170	{
171	size_t cbThisWrite = RT_MIN(cbWrite, sizeof(abBuf));
172	rc = VDWrite(pDisk, off, memcpy(abBuf, pbSrc, cbThisWrite), cbThisWrite);
173	if (RT_SUCCESS(rc))
174	{
175	pbSrc += cbThisWrite;
176	off += cbThisWrite;
177	cbWrite -= cbThisWrite;
178	}
179	else
180	break;
181	} while (cbWrite > 0);
182	}
183	}
184	else
185	{
186
187	/*
188	* Unaligned buffered read+write of head. Aligns the offset.
189	*/
190	if (offMisalign)
191	{
192	rc = VDRead(pDisk, off - offMisalign, abBuf, 512);
193	if (RT_SUCCESS(rc))
194	{
195	size_t const cbPart = RT_MIN(512 - offMisalign, cbWrite);
196	memcpy(&abBuf[offMisalign], pbSrc, cbPart);
197	rc = VDWrite(pDisk, off - offMisalign, abBuf, 512);
198	if (RT_SUCCESS(rc))
199	{
200	pbSrc += cbPart;
201	off += cbPart;
202	cbWrite -= cbPart;
203	}
204	}
205	}
206	else
207	rc = VINF_SUCCESS;
208
209	/*
210	* Aligned direct write.
211	*/
212	if ( RT_SUCCESS(rc)
213	&& cbWrite >= 512)
214	{
215	Assert(!(off % 512));
216	size_t cbPart = cbWrite - cbMisalign;
217	Assert(!(cbPart % 512));
218
219	if (RTListIsEmpty(&pDisk->ListFilterChainWrite))
220	{
221	rc = VDWrite(pDisk, off, pbSrc, cbPart);
222	if (RT_SUCCESS(rc))
223	{
224	pbSrc += cbPart;
225	off += cbPart;
226	cbWrite -= cbPart;
227	}
228	}
229	else
230	{
231	/* Filtered writes must be double buffered as the filter may need to modify the input buffer directly. */
232	do
233	{
234	size_t cbThisWrite = RT_MIN(cbPart, sizeof(abBuf));
235	rc = VDWrite(pDisk, off, memcpy(abBuf, pbSrc, cbThisWrite), cbThisWrite);
236	if (RT_SUCCESS(rc))
237	{
238	pbSrc += cbThisWrite;
239	off += cbThisWrite;
240	cbWrite -= cbThisWrite;
241	cbPart -= cbThisWrite;
242	}
243	else
244	break;
245	} while (cbPart > 0);
246	}
247	}
248
249	/*
250	* Unaligned buffered read+write of tail.
251	*/
252	if ( RT_SUCCESS(rc)
253	&& cbWrite > 0)
254	{
255	Assert(cbWrite == cbMisalign);
256	Assert(cbWrite < 512);
257	Assert(!(off % 512));
258
259	rc = VDRead(pDisk, off, abBuf, 512);
260	if (RT_SUCCESS(rc))
261	{
262	memcpy(abBuf, pbSrc, cbWrite);
263	rc = VDWrite(pDisk, off, abBuf, 512);
264	}
265	}
266	}
267
268	return rc;
269	}
270
271
272	/**
273	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
274	*/
275	static DECLCALLBACK(int) vdVfsFile_Close(void *pvThis)
276	{
277	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
278
279	if (pThis->fFlags & VD_VFSFILE_DESTROY_ON_RELEASE)
280	VDDestroy(pThis->pDisk);
281
282	return VINF_SUCCESS;
283	}
284
285
286	/**
287	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
288	*/
289	static DECLCALLBACK(int) vdVfsFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
290	{
291	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
292	unsigned const cOpenImages = VDGetCount(pThis->pDisk);
293
294	pObjInfo->cbObject = VDGetSize(pThis->pDisk, cOpenImages - 1);
295	pObjInfo->cbAllocated = 0;
296	for (unsigned iImage = 0; iImage < cOpenImages; iImage++)
297	pObjInfo->cbAllocated += VDGetFileSize(pThis->pDisk, iImage);
298
299	/** @todo enumerate the disk images directly... */
300	RTTimeNow(&pObjInfo->AccessTime);
301	pObjInfo->BirthTime = pObjInfo->AccessTime;
302	pObjInfo->ChangeTime = pObjInfo->AccessTime;
303	pObjInfo->ModificationTime = pObjInfo->AccessTime;
304
305	pObjInfo->Attr.fMode = RTFS_DOS_NT_NORMAL \| RTFS_TYPE_FILE \| 0644;
306	pObjInfo->Attr.enmAdditional = enmAddAttr;
307	switch (enmAddAttr)
308	{
309	case RTFSOBJATTRADD_UNIX:
310	pObjInfo->Attr.u.Unix.uid = NIL_RTUID;
311	pObjInfo->Attr.u.Unix.gid = NIL_RTGID;
312	pObjInfo->Attr.u.Unix.cHardlinks = 1;
313	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
314	pObjInfo->Attr.u.Unix.INodeId = 0;
315	pObjInfo->Attr.u.Unix.fFlags = 0;
316	pObjInfo->Attr.u.Unix.GenerationId = 0;
317	pObjInfo->Attr.u.Unix.Device = 0;
318	break;
319
320	case RTFSOBJATTRADD_UNIX_OWNER:
321	pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID;
322	pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
323	break;
324	case RTFSOBJATTRADD_UNIX_GROUP:
325	pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID;
326	pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
327	break;
328	case RTFSOBJATTRADD_EASIZE:
329	pObjInfo->Attr.u.EASize.cb = 0;
330	break;
331
332	default:
333	AssertFailedReturn(VERR_INVALID_PARAMETER);
334	}
335
336	return VINF_SUCCESS;
337	}
338
339
340	/**
341	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
342	*/
343	static DECLCALLBACK(int) vdVfsFile_Read(void pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
344	{
345	PVDVFSFILE const pThis = (PVDVFSFILE)pvThis;
346
347	Assert(pSgBuf->cSegs == 1);
348	NOREF(fBlocking);
349
350	/*
351	* Find the current position and check if it's within the volume.
352	*/
353	uint64_t offUnsigned = off < 0 ? pThis->offCurPos : (uint64_t)off;
354	uint64_t const cbImage = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
355	if (offUnsigned >= cbImage)
356	{
357	if (pcbRead)
358	{
359	*pcbRead = 0;
360	pThis->offCurPos = cbImage;
361	return VINF_EOF;
362	}
363	return VERR_EOF;
364	}
365
366	size_t cbSeg = 0;
367	void * const pvSeg = RTSgBufGetCurrentSegment(pSgBuf, ~(size_t)0, &cbSeg);
368
369	int rcRet = VINF_SUCCESS;
370	size_t cbToRead;
371	if (cbSeg <= cbImage - offUnsigned)
372	cbToRead = cbSeg;
373	else if (pcbRead)
374	{
375	cbToRead = (size_t)(cbImage - offUnsigned);
376	rcRet = VINF_EOF;
377	}
378	else
379	return VERR_EOF;
380
381	/*
382	* Ok, we've got a valid stretch within the file. Do the reading.
383	*/
384	if (cbToRead > 0)
385	{
386	int rc2 = vdReadHelper(pThis->pDisk, offUnsigned, pvSeg, cbToRead);
387	if (RT_SUCCESS(rc2))
388	{
389	offUnsigned += cbToRead;
390	RTSgBufAdvance(pSgBuf, cbToRead);
391	}
392	else
393	{
394	cbToRead = 0;
395	rcRet = rc2;
396	}
397	}
398
399	pThis->offCurPos = offUnsigned;
400	if (pcbRead)
401	*pcbRead = cbToRead;
402	return rcRet;
403	}
404
405
406	/**
407	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
408	*/
409	static DECLCALLBACK(int) vdVfsFile_Write(void pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten)
410	{
411	PVDVFSFILE const pThis = (PVDVFSFILE)pvThis;
412
413	Assert(pSgBuf->cSegs == 1);
414	NOREF(fBlocking);
415
416	/*
417	* Find the current position and check if it's within the volume.
418	* Writing beyond the end of a volume is not supported.
419	*/
420	uint64_t offUnsigned = off < 0 ? pThis->offCurPos : (uint64_t)off;
421	uint64_t const cbImage = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
422	if (offUnsigned >= cbImage)
423	{
424	if (pcbWritten)
425	{
426	*pcbWritten = 0;
427	pThis->offCurPos = cbImage;
428	}
429	return VERR_EOF;
430	}
431
432	size_t cbSeg = 0;
433	void const * const pvSeg = RTSgBufGetCurrentSegment(pSgBuf, ~(size_t)0, &cbSeg);
434
435	size_t cbToWrite;
436	if (cbSeg <= cbImage - offUnsigned)
437	cbToWrite = cbSeg;
438	else if (pcbWritten)
439	cbToWrite = (size_t)(cbImage - offUnsigned);
440	else
441	return VERR_EOF;
442
443	/*
444	* Ok, we've got a valid stretch within the file. Do the reading.
445	*/
446	int rc = VINF_SUCCESS;
447	if (cbToWrite > 0)
448	{
449	rc = vdWriteHelper(pThis->pDisk, offUnsigned, pvSeg, cbToWrite);
450	if (RT_SUCCESS(rc))
451	{
452	offUnsigned += cbToWrite;
453	RTSgBufAdvance(pSgBuf, cbToWrite);
454	}
455	else
456	cbToWrite = 0;
457	}
458
459	pThis->offCurPos = offUnsigned;
460	if (pcbWritten)
461	*pcbWritten = cbToWrite;
462	return rc;
463	}
464
465
466	/**
467	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
468	*/
469	static DECLCALLBACK(int) vdVfsFile_Flush(void *pvThis)
470	{
471	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
472	return VDFlush(pThis->pDisk);
473	}
474
475
476	/**
477	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
478	*/
479	static DECLCALLBACK(int) vdVfsFile_Tell(void *pvThis, PRTFOFF poffActual)
480	{
481	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
482	*poffActual = pThis->offCurPos;
483	return VINF_SUCCESS;
484	}
485
486
487	/**
488	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetMode}
489	*/
490	static DECLCALLBACK(int) vdVfsFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
491	{
492	NOREF(pvThis);
493	NOREF(fMode);
494	NOREF(fMask);
495	return VERR_NOT_SUPPORTED;
496	}
497
498
499	/**
500	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
501	*/
502	static DECLCALLBACK(int) vdVfsFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
503	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
504	{
505	NOREF(pvThis);
506	NOREF(pAccessTime);
507	NOREF(pModificationTime);
508	NOREF(pChangeTime);
509	NOREF(pBirthTime);
510	return VERR_NOT_SUPPORTED;
511	}
512
513
514	/**
515	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
516	*/
517	static DECLCALLBACK(int) vdVfsFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
518	{
519	NOREF(pvThis);
520	NOREF(uid);
521	NOREF(gid);
522	return VERR_NOT_SUPPORTED;
523	}
524
525
526	/**
527	* @interface_method_impl{RTVFSFILEOPS,pfnSeek}
528	*/
529	static DECLCALLBACK(int) vdVfsFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
530	{
531	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
532
533	/*
534	* Seek relative to which position.
535	*/
536	uint64_t offWrt;
537	switch (uMethod)
538	{
539	case RTFILE_SEEK_BEGIN:
540	offWrt = 0;
541	break;
542
543	case RTFILE_SEEK_CURRENT:
544	offWrt = pThis->offCurPos;
545	break;
546
547	case RTFILE_SEEK_END:
548	offWrt = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
549	break;
550
551	default:
552	return VERR_INTERNAL_ERROR_5;
553	}
554
555	/*
556	* Calc new position, take care to stay without bounds.
557	*/
558	uint64_t offNew;
559	if (offSeek == 0)
560	offNew = offWrt;
561	else if (offSeek > 0)
562	{
563	offNew = offWrt + offSeek;
564	if ( offNew < offWrt
565	\|\| offNew > RTFOFF_MAX)
566	offNew = RTFOFF_MAX;
567	}
568	else if ((uint64_t)-offSeek < offWrt)
569	offNew = offWrt + offSeek;
570	else
571	offNew = 0;
572
573	/*
574	* Update the state and set return value.
575	*/
576	pThis->offCurPos = offNew;
577
578	*poffActual = offNew;
579	return VINF_SUCCESS;
580	}
581
582
583	/**
584	* @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
585	*/
586	static DECLCALLBACK(int) vdVfsFile_QuerySize(void pvThis, uint64_t pcbFile)
587	{
588	PVDVFSFILE pThis = (PVDVFSFILE)pvThis;
589	*pcbFile = VDGetSize(pThis->pDisk, VD_LAST_IMAGE);
590	return VINF_SUCCESS;
591	}
592
593
594	/**
595	* Standard file operations.
596	*/
597	DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_vdVfsStdFileOps =
598	{
599	{ /* Stream */
600	{ /* Obj */
601	RTVFSOBJOPS_VERSION,
602	RTVFSOBJTYPE_FILE,
603	"VDFile",
604	vdVfsFile_Close,
605	vdVfsFile_QueryInfo,
606	NULL,
607	RTVFSOBJOPS_VERSION
608	},
609	RTVFSIOSTREAMOPS_VERSION,
610	RTVFSIOSTREAMOPS_FEAT_NO_SG,
611	vdVfsFile_Read,
612	vdVfsFile_Write,
613	vdVfsFile_Flush,
614	NULL /PollOne/,
615	vdVfsFile_Tell,
616	NULL /Skip/,
617	NULL /ZeroFill/,
618	RTVFSIOSTREAMOPS_VERSION,
619	},
620	RTVFSFILEOPS_VERSION,
621	/RTVFSIOFILEOPS_FEAT_NO_AT_OFFSET/ 0,
622	{ /* ObjSet */
623	RTVFSOBJSETOPS_VERSION,
624	RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
625	vdVfsFile_SetMode,
626	vdVfsFile_SetTimes,
627	vdVfsFile_SetOwner,
628	RTVFSOBJSETOPS_VERSION
629	},
630	vdVfsFile_Seek,
631	vdVfsFile_QuerySize,
632	NULL /SetSize/,
633	NULL /QueryMaxSize/,
634	RTVFSFILEOPS_VERSION
635	};
636
637
638	VBOXDDU_DECL(int) VDCreateVfsFileFromDisk(PVDISK pDisk, uint32_t fFlags,
639	PRTVFSFILE phVfsFile)
640	{
641	AssertPtrReturn(pDisk, VERR_INVALID_HANDLE);
642	AssertPtrReturn(phVfsFile, VERR_INVALID_POINTER);
643	AssertReturn((fFlags & ~VD_VFSFILE_FLAGS_MASK) == 0, VERR_INVALID_PARAMETER);
644
645	/*
646	* Create the volume file.
647	*/
648	RTVFSFILE hVfsFile;
649	PVDVFSFILE pThis;
650	int rc = RTVfsNewFile(&g_vdVfsStdFileOps, sizeof(*pThis), RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_WRITE,
651	NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFile, (void **)&pThis);
652	if (RT_SUCCESS(rc))
653	{
654	pThis->offCurPos = 0;
655	pThis->pDisk = pDisk;
656	pThis->fFlags = fFlags;
657
658	*phVfsFile = hVfsFile;
659	return VINF_SUCCESS;
660	}
661
662	return rc;
663	}
664
665
666	/**
667	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
668	*/
669	static DECLCALLBACK(int) vdVfsChain_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
670	PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
671	{
672	RT_NOREF(pProviderReg, pSpec);
673
674	/*
675	* Basic checks.
676	*/
677	if (pElement->enmTypeIn != RTVFSOBJTYPE_INVALID)
678	return VERR_VFS_CHAIN_MUST_BE_FIRST_ELEMENT;
679	if ( pElement->enmType != RTVFSOBJTYPE_FILE
680	&& pElement->enmType != RTVFSOBJTYPE_IO_STREAM)
681	return VERR_VFS_CHAIN_ONLY_FILE_OR_IOS;
682
683	if (pElement->cArgs < 1)
684	return VERR_VFS_CHAIN_AT_LEAST_ONE_ARG;
685
686	/*
687	* Parse the flag if present, save in pElement->uProvider.
688	*/
689	uint32_t fFlags = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ
690	? VD_OPEN_FLAGS_READONLY : VD_OPEN_FLAGS_NORMAL;
691	if (pElement->cArgs > 1)
692	{
693	pElement->paArgs[pElement->cArgs - 1].uProvider = true; /* indicates flags */
694	const char *psz = pElement->paArgs[pElement->cArgs - 1].psz;
695	if (*psz)
696	{
697	if ( !strcmp(psz, "ro")
698	\|\| !strcmp(psz, "r"))
699	{
700	fFlags &= ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_NORMAL);
701	fFlags \|= VD_OPEN_FLAGS_READONLY;
702	}
703	else if (!strcmp(psz, "rw"))
704	{
705	fFlags &= ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_NORMAL);
706	fFlags \|= VD_OPEN_FLAGS_NORMAL;
707	}
708	else if (strlen(psz) <= 4)
709	{
710	*poffError = pElement->paArgs[pElement->cArgs - 1].offSpec;
711	return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument");
712	}
713	else
714	pElement->paArgs[pElement->cArgs - 1].uProvider = false; /* indicates no flags */
715	}
716	}
717
718	pElement->uProvider = fFlags;
719	if ( pElement->cArgs > 2
720	\|\| (pElement->cArgs == 2 && !pElement->paArgs[pElement->cArgs - 1].uProvider))
721	pElement->uProvider \|= RT_BIT_64(63);
722	return VINF_SUCCESS;
723	}
724
725
726	/**
727	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
728	*/
729	static DECLCALLBACK(int) vdVfsChain_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
730	PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
731	PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
732	{
733	RT_NOREF(pProviderReg, pSpec, poffError, pErrInfo);
734	AssertReturn(hPrevVfsObj == NIL_RTVFSOBJ, VERR_VFS_CHAIN_IPE);
735
736	/* Determin the format. */
737	char *pszFormat = NULL;
738	VDTYPE enmType = VDTYPE_INVALID;
739	int rc = VDGetFormat(NULL, NULL, pElement->paArgs[0].psz, VDTYPE_INVALID, &pszFormat, &enmType);
740	if (RT_SUCCESS(rc))
741	{
742	PVDISK pDisk = NULL;
743	rc = VDCreate(NULL, enmType, &pDisk);
744	if (RT_SUCCESS(rc))
745	{
746	if (!(pElement->uProvider & RT_BIT_64(63)))
747	rc = VDOpen(pDisk, pszFormat, pElement->paArgs[0].psz, (uint32_t)pElement->uProvider, NULL);
748	else
749	{
750	uint32_t cChain = pElement->cArgs;
751	if (pElement->cArgs >= 2 && pElement->paArgs[pElement->cArgs - 1].uProvider != 0)
752	cChain--;
753	uint32_t const fFinal = (uint32_t)pElement->uProvider;
754	uint32_t const fReadOnly = (fFinal & ~(VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_NORMAL)) \| VD_OPEN_FLAGS_READONLY;
755	uint32_t iChain;
756	for (iChain = 0; iChain < cChain && RT_SUCCESS(rc); iChain++)
757	rc = VDOpen(pDisk, pszFormat, pElement->paArgs[iChain].psz, iChain + 1 >= cChain ? fFinal : fReadOnly, NULL);
758	}
759	if (RT_SUCCESS(rc))
760	{
761	RTVFSFILE hVfsFile;
762	rc = VDCreateVfsFileFromDisk(pDisk, VD_VFSFILE_DESTROY_ON_RELEASE, &hVfsFile);
763	if (RT_SUCCESS(rc))
764	{
765	RTStrFree(pszFormat);
766
767	*phVfsObj = RTVfsObjFromFile(hVfsFile);
768	RTVfsFileRelease(hVfsFile);
769
770	if (*phVfsObj != NIL_RTVFSOBJ)
771	return VINF_SUCCESS;
772	return VERR_VFS_CHAIN_CAST_FAILED;
773	}
774	}
775	VDDestroy(pDisk);
776	}
777	RTStrFree(pszFormat);
778	}
779	return rc;
780	}
781
782
783	/**
784	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
785	*/
786	static DECLCALLBACK(bool) vdVfsChain_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
787	PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
788	PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
789	{
790	RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
791	return false;
792	}
793
794
795	/** VFS chain element 'file'. */
796	static RTVFSCHAINELEMENTREG g_rtVfsChainIsoFsVolReg =
797	{
798	/* uVersion = */ RTVFSCHAINELEMENTREG_VERSION,
799	/* fReserved = */ 0,
800	/* pszName = */ "vd",
801	/* ListEntry = */ { NULL, NULL },
802	/* pszHelp = */ "Opens a container image using the VD API.\n"
803	"To open a snapshot chain, start with the root image and end with the more recent diff image.\n"
804	"The final argument can be a flag 'ro' or 'r' for read-only, 'rw' for read-write.",
805	/* pfnValidate = */ vdVfsChain_Validate,
806	/* pfnInstantiate = */ vdVfsChain_Instantiate,
807	/* pfnCanReuseElement = */ vdVfsChain_CanReuseElement,
808	/* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION
809	};
810
811	RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainIsoFsVolReg, rtVfsChainIsoFsVolReg);
812

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

source: vbox/trunk/src/VBox/Storage/VDVfs.cpp@ 106129

Download in other formats: