dvmvfs.cpp@ 98392

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

Line
1	/* $Id: dvmvfs.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* IPRT Disk Volume Management API (DVM) - VFS glue.
4	*/
5
6	/*
7	* Copyright (C) 2012-2023 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	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_FS /** @todo fix log group */
42	#include <iprt/types.h>
43	#include <iprt/assert.h>
44	#include <iprt/mem.h>
45	#include <iprt/dvm.h>
46	#include <iprt/err.h>
47	#include <iprt/asm.h>
48	#include <iprt/string.h>
49	#include <iprt/file.h>
50	#include <iprt/sg.h>
51	#include <iprt/vfslowlevel.h>
52	#include <iprt/poll.h>
53	#include <iprt/log.h>
54	#include "internal/dvm.h"
55
56
57	/*********************************************************************************************************************************
58	* Structures and Typedefs *
59	*********************************************************************************************************************************/
60	/** Pointer to a volume manager VFS. */
61	typedef struct RTDVMVFSVOL *PRTDVMVFSVOL;
62
63	/**
64	* The internal data of a DVM volume I/O stream.
65	*/
66	typedef struct RTVFSDVMFILE
67	{
68	/** The volume the VFS file belongs to. */
69	RTDVMVOLUME hVol;
70	/** Pointer to the VFS volume. Can be NULL. */
71	PRTDVMVFSVOL pVfsVol;
72	/** Current position. */
73	uint64_t offCurPos;
74	/** Set if readable. */
75	bool fCanRead;
76	/** Set if writable. */
77	bool fCanWrite;
78	} RTVFSDVMFILE;
79	/** Pointer to a the internal data of a DVM volume file. */
80	typedef RTVFSDVMFILE *PRTVFSDVMFILE;
81
82	/**
83	* The internal data of a DVM volume symlink.
84	*/
85	typedef struct RTVFSDVMSYMLINK
86	{
87	/** The DVM volume the symlink represent. */
88	RTDVMVOLUME hVol;
89	/** The DVM volume manager @a hVol belongs to. */
90	RTDVM hVolMgr;
91	/** The symlink name. */
92	char *pszSymlink;
93	/** The symlink target (volXX). */
94	char szTarget[16];
95	} RTVFSDVMSYMLINK;
96	/** Pointer to a the internal data of a DVM volume file. */
97	typedef RTVFSDVMSYMLINK *PRTVFSDVMSYMLINK;
98
99	/**
100	* The volume manager VFS (root) dir data.
101	*/
102	typedef struct RTDVMVFSDIR
103	{
104	/** Pointer to the VFS volume. */
105	PRTDVMVFSVOL pVfsVol;
106	/** The current directory offset. */
107	uint32_t offDir;
108	/** Set if we need to try return hCurVolume again because of buffer overflow. */
109	bool fReturnCurrent;
110	/** Pointer to name alias string (returned by RTDvmVolumeQueryName, free it). */
111	char *pszNameAlias;
112	/** The current DVM volume. */
113	RTDVMVOLUME hCurVolume;
114	} RTDVMVFSDIR;
115	/** Pointer to a volume manager VFS (root) dir. */
116	typedef RTDVMVFSDIR *PRTDVMVFSDIR;
117
118	/**
119	* A volume manager VFS for use in chains (thing pseudo/devfs).
120	*/
121	typedef struct RTDVMVFSVOL
122	{
123	/** The volume manager. */
124	RTDVM hVolMgr;
125	/** Whether to close it on success. */
126	bool fCloseDvm;
127	/** Whether the access is read-only. */
128	bool fReadOnly;
129	/** Number of volumes. */
130	uint32_t cVolumes;
131	/** Self reference. */
132	RTVFS hVfsSelf;
133	} RTDVMVFSVOL;
134
135
136	/*********************************************************************************************************************************
137	* Internal Functions *
138	*********************************************************************************************************************************/
139	static DECLCALLBACK(int) rtDvmVfsVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir);
140
141
142	/**
143	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
144	*/
145	static DECLCALLBACK(int) rtDvmVfsFile_Close(void *pvThis)
146	{
147	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
148
149	RTDvmVolumeRelease(pThis->hVol);
150	return VINF_SUCCESS;
151	}
152
153
154	/**
155	* Worker for rtDvmVfsFile_QueryInfoWorker and rtDvmVfsSym_QueryInfoWorker.
156	*/
157	static int rtDvmVfsFileSym_QueryAddAttrWorker(RTDVMVOLUME hVolume, RTDVM hVolMgr,
158	PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
159	{
160	switch (enmAddAttr)
161	{
162	case RTFSOBJATTRADD_NOTHING:
163	case RTFSOBJATTRADD_UNIX:
164	pObjInfo->Attr.u.Unix.uid = (RTUID)RTDvmVolumeGetType(hVolume);
165	pObjInfo->Attr.u.Unix.gid = hVolMgr != NIL_RTDVM ? (RTGID)RTDvmMapGetFormatType(hVolMgr) : NIL_RTGID;
166	pObjInfo->Attr.u.Unix.cHardlinks = 1;
167	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
168	pObjInfo->Attr.u.Unix.INodeId = 0;
169	pObjInfo->Attr.u.Unix.fFlags = 0;
170	pObjInfo->Attr.u.Unix.GenerationId = 0;
171	pObjInfo->Attr.u.Unix.Device = 0;
172	break;
173
174	case RTFSOBJATTRADD_UNIX_OWNER:
175	{
176	RTDVMVOLTYPE enmType = RTDvmVolumeGetType(hVolume);
177	pObjInfo->Attr.u.UnixOwner.uid = (RTUID)enmType;
178	RTStrCopy(pObjInfo->Attr.u.UnixOwner.szName, sizeof(pObjInfo->Attr.u.UnixOwner.szName),
179	RTDvmVolumeTypeGetDescr(enmType));
180	break;
181	}
182
183	case RTFSOBJATTRADD_UNIX_GROUP:
184	if (hVolMgr != NIL_RTDVM)
185	{
186	pObjInfo->Attr.u.UnixGroup.gid = (RTGID)RTDvmMapGetFormatType(hVolMgr);
187	RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName),
188	RTDvmMapGetFormatName(hVolMgr));
189	}
190	else
191	{
192	pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID;
193	pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
194	}
195	break;
196
197	case RTFSOBJATTRADD_EASIZE:
198	pObjInfo->Attr.u.EASize.cb = 0;
199	break;
200
201	default:
202	return VERR_INVALID_PARAMETER;
203	}
204	return VINF_SUCCESS;
205	}
206
207
208	/**
209	* Worker for rtDvmVfsFile_QueryInfo, rtDvmVfsDir_QueryEntryInfo, and
210	* rtDvmVfsDir_ReadDir.
211	*/
212	static int rtDvmVfsFile_QueryInfoWorker(RTDVMVOLUME hVolume, RTDVM hVolMgr, bool fReadOnly,
213	PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
214	{
215
216	pObjInfo->cbObject = RTDvmVolumeGetSize(hVolume);
217	pObjInfo->cbAllocated = pObjInfo->cbObject;
218	RTTimeSpecSetNano(&pObjInfo->AccessTime, 0);
219	RTTimeSpecSetNano(&pObjInfo->ModificationTime, 0);
220	RTTimeSpecSetNano(&pObjInfo->ChangeTime, 0);
221	RTTimeSpecSetNano(&pObjInfo->BirthTime, 0);
222	pObjInfo->Attr.fMode = RTFS_TYPE_FILE \| RTFS_DOS_NT_NORMAL;
223	if (fReadOnly)
224	pObjInfo->Attr.fMode \|= RTFS_DOS_READONLY \| 0444;
225	else
226	pObjInfo->Attr.fMode \|= 0666;
227
228	return rtDvmVfsFileSym_QueryAddAttrWorker(hVolume, hVolMgr, pObjInfo, enmAddAttr);
229	}
230
231
232	/**
233	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
234	*/
235	static DECLCALLBACK(int) rtDvmVfsFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
236	{
237	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
238	return rtDvmVfsFile_QueryInfoWorker(pThis->hVol,
239	pThis->pVfsVol ? pThis->pVfsVol->hVolMgr : NIL_RTDVM,
240	pThis->pVfsVol ? pThis->pVfsVol->fReadOnly : !pThis->fCanWrite,
241	pObjInfo, enmAddAttr);
242	}
243
244
245	/**
246	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
247	*/
248	static DECLCALLBACK(int) rtDvmVfsFile_Read(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
249	{
250	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
251	int rc = VINF_SUCCESS;
252
253	Assert(pSgBuf->cSegs == 1);
254	NOREF(fBlocking);
255
256	/*
257	* Find the current position and check if it's within the volume.
258	*/
259	uint64_t offUnsigned = off < 0 ? pThis->offCurPos : (uint64_t)off;
260	if (offUnsigned >= RTDvmVolumeGetSize(pThis->hVol))
261	{
262	if (pcbRead)
263	{
264	*pcbRead = 0;
265	pThis->offCurPos = offUnsigned;
266	return VINF_EOF;
267	}
268	return VERR_EOF;
269	}
270
271	size_t cbLeftToRead;
272	if (offUnsigned + pSgBuf->paSegs[0].cbSeg > RTDvmVolumeGetSize(pThis->hVol))
273	{
274	if (!pcbRead)
275	return VERR_EOF;
276	*pcbRead = cbLeftToRead = (size_t)(RTDvmVolumeGetSize(pThis->hVol) - offUnsigned);
277	}
278	else
279	{
280	cbLeftToRead = pSgBuf->paSegs[0].cbSeg;
281	if (pcbRead)
282	*pcbRead = cbLeftToRead;
283	}
284
285	/*
286	* Ok, we've got a valid stretch within the file. Do the reading.
287	*/
288	if (cbLeftToRead > 0)
289	{
290	rc = RTDvmVolumeRead(pThis->hVol, offUnsigned, pSgBuf->paSegs[0].pvSeg, cbLeftToRead);
291	if (RT_SUCCESS(rc))
292	offUnsigned += cbLeftToRead;
293	}
294
295	pThis->offCurPos = offUnsigned;
296	return rc;
297	}
298
299
300	/**
301	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
302	*/
303	static DECLCALLBACK(int) rtDvmVfsFile_Write(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten)
304	{
305	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
306	int rc = VINF_SUCCESS;
307
308	Assert(pSgBuf->cSegs == 1);
309	NOREF(fBlocking);
310
311	/*
312	* Find the current position and check if it's within the volume.
313	* Writing beyond the end of a volume is not supported.
314	*/
315	uint64_t offUnsigned = off < 0 ? pThis->offCurPos : (uint64_t)off;
316	if (offUnsigned >= RTDvmVolumeGetSize(pThis->hVol))
317	{
318	if (pcbWritten)
319	{
320	*pcbWritten = 0;
321	pThis->offCurPos = offUnsigned;
322	}
323	return VERR_NOT_SUPPORTED;
324	}
325
326	size_t cbLeftToWrite;
327	if (offUnsigned + pSgBuf->paSegs[0].cbSeg > RTDvmVolumeGetSize(pThis->hVol))
328	{
329	if (!pcbWritten)
330	return VERR_EOF;
331	*pcbWritten = cbLeftToWrite = (size_t)(RTDvmVolumeGetSize(pThis->hVol) - offUnsigned);
332	}
333	else
334	{
335	cbLeftToWrite = pSgBuf->paSegs[0].cbSeg;
336	if (pcbWritten)
337	*pcbWritten = cbLeftToWrite;
338	}
339
340	/*
341	* Ok, we've got a valid stretch within the file. Do the reading.
342	*/
343	if (cbLeftToWrite > 0)
344	{
345	rc = RTDvmVolumeWrite(pThis->hVol, offUnsigned, pSgBuf->paSegs[0].pvSeg, cbLeftToWrite);
346	if (RT_SUCCESS(rc))
347	offUnsigned += cbLeftToWrite;
348	}
349
350	pThis->offCurPos = offUnsigned;
351	return rc;
352	}
353
354
355	/**
356	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
357	*/
358	static DECLCALLBACK(int) rtDvmVfsFile_Flush(void *pvThis)
359	{
360	NOREF(pvThis);
361	return VINF_SUCCESS; /** @todo Implement missing DVM API. */
362	}
363
364
365	/**
366	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
367	*/
368	static DECLCALLBACK(int) rtDvmVfsFile_Tell(void *pvThis, PRTFOFF poffActual)
369	{
370	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
371	*poffActual = pThis->offCurPos;
372	return VINF_SUCCESS;
373	}
374
375
376	/**
377	* @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
378	*/
379	static DECLCALLBACK(int) rtDvmVfsFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
380	{
381	NOREF(pvThis);
382	NOREF(fMode);
383	NOREF(fMask);
384	return VERR_NOT_SUPPORTED;
385	}
386
387
388	/**
389	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
390	*/
391	static DECLCALLBACK(int) rtDvmVfsFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
392	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
393	{
394	NOREF(pvThis);
395	NOREF(pAccessTime);
396	NOREF(pModificationTime);
397	NOREF(pChangeTime);
398	NOREF(pBirthTime);
399	return VERR_NOT_SUPPORTED;
400	}
401
402
403	/**
404	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
405	*/
406	static DECLCALLBACK(int) rtDvmVfsFile_SetOwner(void *pvThis, RTUID uid, RTGID gid)
407	{
408	NOREF(pvThis);
409	NOREF(uid);
410	NOREF(gid);
411	return VERR_NOT_SUPPORTED;
412	}
413
414
415	/**
416	* @interface_method_impl{RTVFSFILEOPS,pfnSeek}
417	*/
418	static DECLCALLBACK(int) rtDvmVfsFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
419	{
420	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
421
422	/*
423	* Seek relative to which position.
424	*/
425	uint64_t offWrt;
426	switch (uMethod)
427	{
428	case RTFILE_SEEK_BEGIN:
429	offWrt = 0;
430	break;
431
432	case RTFILE_SEEK_CURRENT:
433	offWrt = pThis->offCurPos;
434	break;
435
436	case RTFILE_SEEK_END:
437	offWrt = RTDvmVolumeGetSize(pThis->hVol);
438	break;
439
440	default:
441	return VERR_INTERNAL_ERROR_5;
442	}
443
444	/*
445	* Calc new position, take care to stay within bounds.
446	*
447	* @todo: Setting position beyond the end of the volume does not make sense.
448	*/
449	uint64_t offNew;
450	if (offSeek == 0)
451	offNew = offWrt;
452	else if (offSeek > 0)
453	{
454	offNew = offWrt + offSeek;
455	if ( offNew < offWrt
456	\|\| offNew > RTFOFF_MAX)
457	offNew = RTFOFF_MAX;
458	}
459	else if ((uint64_t)-offSeek < offWrt)
460	offNew = offWrt + offSeek;
461	else
462	offNew = 0;
463
464	/*
465	* Update the state and set return value.
466	*/
467	pThis->offCurPos = offNew;
468
469	*poffActual = offNew;
470	return VINF_SUCCESS;
471	}
472
473
474	/**
475	* @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
476	*/
477	static DECLCALLBACK(int) rtDvmVfsFile_QuerySize(void pvThis, uint64_t pcbFile)
478	{
479	PRTVFSDVMFILE pThis = (PRTVFSDVMFILE)pvThis;
480	*pcbFile = RTDvmVolumeGetSize(pThis->hVol);
481	return VINF_SUCCESS;
482	}
483
484
485	/**
486	* Standard file operations.
487	*/
488	DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtDvmVfsStdFileOps =
489	{
490	{ /* Stream */
491	{ /* Obj */
492	RTVFSOBJOPS_VERSION,
493	RTVFSOBJTYPE_FILE,
494	"DvmFile",
495	rtDvmVfsFile_Close,
496	rtDvmVfsFile_QueryInfo,
497	NULL,
498	RTVFSOBJOPS_VERSION
499	},
500	RTVFSIOSTREAMOPS_VERSION,
501	RTVFSIOSTREAMOPS_FEAT_NO_SG,
502	rtDvmVfsFile_Read,
503	rtDvmVfsFile_Write,
504	rtDvmVfsFile_Flush,
505	NULL /pfnPollOne/,
506	rtDvmVfsFile_Tell,
507	NULL /Skip/,
508	NULL /ZeroFill/,
509	RTVFSIOSTREAMOPS_VERSION,
510	},
511	RTVFSFILEOPS_VERSION,
512	/RTVFSIOFILEOPS_FEAT_NO_AT_OFFSET/ 0,
513	{ /* ObjSet */
514	RTVFSOBJSETOPS_VERSION,
515	RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
516	rtDvmVfsFile_SetMode,
517	rtDvmVfsFile_SetTimes,
518	rtDvmVfsFile_SetOwner,
519	RTVFSOBJSETOPS_VERSION
520	},
521	rtDvmVfsFile_Seek,
522	rtDvmVfsFile_QuerySize,
523	NULL /SetSize/,
524	NULL /QueryMaxSize/,
525	RTVFSFILEOPS_VERSION
526	};
527
528
529	/**
530	* Internal worker for RTDvmVolumeCreateVfsFile and rtDvmVfsDir_OpenFile.
531	*
532	* @returns IPRT status code.
533	* @param pVfsVol The VFS volume, optional.
534	* @param hVol The volume handle. (Reference not consumed.)
535	* @param fOpen RTFILE_O_XXX (valid).
536	* @param phVfsFileOut Where to return the handle to the file.
537	*/
538	static int rtDvmVfsCreateFileForVolume(PRTDVMVFSVOL pVfsVol, RTDVMVOLUME hVol, uint64_t fOpen, PRTVFSFILE phVfsFileOut)
539	{
540	uint32_t cRefs = RTDvmVolumeRetain(hVol);
541	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
542
543	/*
544	* Create the volume file.
545	*/
546	RTVFSFILE hVfsFile;
547	PRTVFSDVMFILE pThis;
548	int rc = RTVfsNewFile(&g_rtDvmVfsStdFileOps, sizeof(pThis), fOpen, NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFile, (void *)&pThis);
549	if (RT_SUCCESS(rc))
550	{
551	pThis->offCurPos = 0;
552	pThis->hVol = hVol;
553	pThis->fCanRead = RT_BOOL(fOpen & RTFILE_O_READ);
554	pThis->fCanWrite = RT_BOOL(fOpen & RTFILE_O_WRITE);
555	pThis->pVfsVol = pVfsVol;
556
557	*phVfsFileOut = hVfsFile;
558	return VINF_SUCCESS;
559	}
560
561	RTDvmVolumeRelease(hVol);
562	return rc;
563	}
564
565
566	RTDECL(int) RTDvmVolumeCreateVfsFile(RTDVMVOLUME hVol, uint64_t fOpen, PRTVFSFILE phVfsFileOut)
567	{
568	AssertPtrReturn(hVol, VERR_INVALID_HANDLE);
569	AssertPtrReturn(phVfsFileOut, VERR_INVALID_POINTER);
570	AssertReturn(fOpen & RTFILE_O_ACCESS_MASK, VERR_INVALID_FLAGS);
571	AssertReturn(!(fOpen & ~RTFILE_O_VALID_MASK), VERR_INVALID_FLAGS);
572	return rtDvmVfsCreateFileForVolume(NULL, hVol, fOpen, phVfsFileOut);
573	}
574
575
576	/*********************************************************************************************************************************
577	* DVM Symbolic Link Objects *
578	*********************************************************************************************************************************/
579	/**
580	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
581	*/
582	static DECLCALLBACK(int) rtDvmVfsSym_Close(void *pvThis)
583	{
584	PRTVFSDVMSYMLINK pThis = (PRTVFSDVMSYMLINK)pvThis;
585	if (pThis->pszSymlink)
586	{
587	RTStrFree(pThis->pszSymlink);
588	pThis->pszSymlink = NULL;
589	}
590	if (pThis->hVol != NIL_RTDVMVOLUME)
591	{
592	RTDvmVolumeRelease(pThis->hVol);
593	pThis->hVol = NIL_RTDVMVOLUME;
594	}
595	if (pThis->hVolMgr != NIL_RTDVM)
596	{
597	RTDvmRelease(pThis->hVolMgr);
598	pThis->hVolMgr = NIL_RTDVM;
599	}
600	return VINF_SUCCESS;
601	}
602
603
604	/**
605	* Worker for rtDvmVfsSym_QueryInfo and rtDvmVfsDir_Read.
606	*
607	* @returns IPRT status code.
608	* @param hVolume The volume handle.
609	* @param hVolMgr The volume manager handle. Optional.
610	* @param pszTarget The link target.
611	* @param pObjInfo The object info structure to populate.
612	* @param enmAddAttr The additional attributes to supply.
613	*/
614	static int rtDvmVfsSym_QueryInfoWorker(RTDVMVOLUME hVolume, RTDVM hVolMgr, const char *pszTarget,
615	PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
616	{
617	RT_ZERO(*pObjInfo);
618	pObjInfo->cbObject = pObjInfo->cbAllocated = pszTarget ? strlen(pszTarget) : 0;
619	pObjInfo->Attr.fMode = 0777 \| RTFS_TYPE_SYMLINK \| RTFS_DOS_NT_REPARSE_POINT;
620
621	return rtDvmVfsFileSym_QueryAddAttrWorker(hVolume, hVolMgr, pObjInfo, enmAddAttr);
622	}
623
624
625	/**
626	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
627	*/
628	static DECLCALLBACK(int) rtDvmVfsSym_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
629	{
630	PRTVFSDVMSYMLINK pThis = (PRTVFSDVMSYMLINK)pvThis;
631	return rtDvmVfsSym_QueryInfoWorker(pThis->hVol, pThis->hVolMgr, pThis->szTarget, pObjInfo, enmAddAttr);
632	}
633
634
635	/**
636	* @interface_method_impl{RTVFSSYMLINKOPS,pfnRead}
637	*/
638	static DECLCALLBACK(int) rtDvmVfsSym_Read(void pvThis, char pszTarget, size_t cbTarget)
639	{
640	PRTVFSDVMSYMLINK pThis = (PRTVFSDVMSYMLINK)pvThis;
641	return RTStrCopy(pszTarget, cbTarget, pThis->szTarget);
642	}
643
644
645	/**
646	* DVM symbolic link operations.
647	*/
648	static const RTVFSSYMLINKOPS g_rtDvmVfsSymOps =
649	{
650	{ /* Obj */
651	RTVFSOBJOPS_VERSION,
652	RTVFSOBJTYPE_SYMLINK,
653	"DvmSymlink",
654	rtDvmVfsSym_Close,
655	rtDvmVfsSym_QueryInfo,
656	NULL,
657	RTVFSOBJOPS_VERSION
658	},
659	RTVFSSYMLINKOPS_VERSION,
660	0,
661	{ /* ObjSet */
662	RTVFSOBJSETOPS_VERSION,
663	RT_UOFFSETOF(RTVFSSYMLINKOPS, ObjSet) - RT_UOFFSETOF(RTVFSSYMLINKOPS, Obj),
664	NULL /rtDvmVfsSym_SetMode/,
665	NULL /rtDvmVfsSym_SetTimes/,
666	NULL /rtDvmVfsSym_SetOwner/,
667	RTVFSOBJSETOPS_VERSION
668	},
669	rtDvmVfsSym_Read,
670	RTVFSSYMLINKOPS_VERSION
671	};
672
673
674	/**
675	* Internal worker for rtDvmVfsDir_OpenFile.
676	*
677	* @returns IPRT status code.
678	* @param hVol The volume handle (not consumed).
679	* @param hVolMgr The volume manager handle (not consumed).
680	* @param iVol The volume number.
681	* @param pszSymlink The volume name. Consumed on success.
682	* @param phVfsSymlinkOut Where to return the handle to the file.
683	*/
684	static int rtDvmVfsCreateSymlinkForVolume(RTDVMVOLUME hVol, RTDVM hVolMgr, uint32_t iVol, char *pszSymlink,
685	PRTVFSSYMLINK phVfsSymlinkOut)
686	{
687	uint32_t cRefs = RTDvmVolumeRetain(hVol);
688	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
689
690	cRefs = RTDvmRetain(hVolMgr);
691	AssertReturnStmt(cRefs != UINT32_MAX, RTDvmVolumeRelease(hVol), VERR_INVALID_HANDLE);
692
693	/*
694	* Create the symlink.
695	*/
696	RTVFSSYMLINK hVfsSym;
697	PRTVFSDVMSYMLINK pThis;
698	int rc = RTVfsNewSymlink(&g_rtDvmVfsSymOps, sizeof(pThis), NIL_RTVFS, NIL_RTVFSLOCK, &hVfsSym, (void *)&pThis);
699	if (RT_SUCCESS(rc))
700	{
701	pThis->hVol = hVol;
702	pThis->hVolMgr = hVolMgr;
703	pThis->pszSymlink = pszSymlink;
704	RTStrPrintf(pThis->szTarget, sizeof(pThis->szTarget), "vol%u", iVol);
705
706	*phVfsSymlinkOut = hVfsSym;
707	return VINF_SUCCESS;
708	}
709	RTDvmRelease(hVolMgr);
710	RTDvmVolumeRelease(hVol);
711	return rc;
712	}
713
714
715
716	/*********************************************************************************************************************************
717	* DVM Directory Objects *
718	*********************************************************************************************************************************/
719
720	/**
721	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
722	*/
723	static DECLCALLBACK(int) rtDvmVfsDir_Close(void *pvThis)
724	{
725	PRTDVMVFSDIR pThis = (PRTDVMVFSDIR)pvThis;
726
727	if (pThis->hCurVolume != NIL_RTDVMVOLUME)
728	{
729	RTDvmVolumeRelease(pThis->hCurVolume);
730	pThis->hCurVolume = NIL_RTDVMVOLUME;
731	}
732
733	if (pThis->pszNameAlias)
734	{
735	RTStrFree(pThis->pszNameAlias);
736	pThis->pszNameAlias = NULL;
737	}
738
739	pThis->pVfsVol = NULL;
740
741	return VINF_SUCCESS;
742	}
743
744
745	/**
746	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
747	*/
748	static DECLCALLBACK(int) rtDvmVfsDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
749	{
750	PRTDVMVFSDIR pThis = (PRTDVMVFSDIR)pvThis;
751	pObjInfo->cbObject = pThis->pVfsVol->cVolumes;
752	pObjInfo->cbAllocated = pThis->pVfsVol->cVolumes;
753	RTTimeSpecSetNano(&pObjInfo->AccessTime, 0);
754	RTTimeSpecSetNano(&pObjInfo->ModificationTime, 0);
755	RTTimeSpecSetNano(&pObjInfo->ChangeTime, 0);
756	RTTimeSpecSetNano(&pObjInfo->BirthTime, 0);
757	pObjInfo->Attr.fMode = RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY;
758	if (pThis->pVfsVol->fReadOnly)
759	pObjInfo->Attr.fMode \|= RTFS_DOS_READONLY \| 0555;
760	else
761	pObjInfo->Attr.fMode \|= 0777;
762
763	switch (enmAddAttr)
764	{
765	case RTFSOBJATTRADD_NOTHING:
766	case RTFSOBJATTRADD_UNIX:
767	pObjInfo->Attr.u.Unix.uid = NIL_RTUID;
768	pObjInfo->Attr.u.Unix.gid = (RTGID)RTDvmMapGetFormatType(pThis->pVfsVol->hVolMgr);
769	pObjInfo->Attr.u.Unix.cHardlinks = pThis->pVfsVol->cVolumes;
770	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
771	pObjInfo->Attr.u.Unix.INodeId = 0;
772	pObjInfo->Attr.u.Unix.fFlags = 0;
773	pObjInfo->Attr.u.Unix.GenerationId = 0;
774	pObjInfo->Attr.u.Unix.Device = 0;
775	break;
776
777	case RTFSOBJATTRADD_UNIX_OWNER:
778	pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID;
779	pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
780	break;
781
782	case RTFSOBJATTRADD_UNIX_GROUP:
783	pObjInfo->Attr.u.UnixGroup.gid = (RTGID)RTDvmMapGetFormatType(pThis->pVfsVol->hVolMgr);
784	RTStrCopy(pObjInfo->Attr.u.UnixGroup.szName, sizeof(pObjInfo->Attr.u.UnixGroup.szName),
785	RTDvmMapGetFormatName(pThis->pVfsVol->hVolMgr));
786	break;
787
788	case RTFSOBJATTRADD_EASIZE:
789	pObjInfo->Attr.u.EASize.cb = 0;
790	break;
791
792	default:
793	return VERR_INVALID_PARAMETER;
794	}
795	return VINF_SUCCESS;
796	}
797
798
799	/**
800	* @interface_method_impl{RTVFSOBJSETOPS,pfnMode}
801	*/
802	static DECLCALLBACK(int) rtDvmVfsDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask)
803	{
804	NOREF(pvThis); NOREF(fMode); NOREF(fMask);
805	return VERR_NOT_SUPPORTED;
806	}
807
808
809	/**
810	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes}
811	*/
812	static DECLCALLBACK(int) rtDvmVfsDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
813	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
814	{
815	NOREF(pvThis); NOREF(pAccessTime); NOREF(pModificationTime); NOREF(pChangeTime); NOREF(pBirthTime);
816	return VERR_NOT_SUPPORTED;
817	}
818
819
820	/**
821	* @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner}
822	*/
823	static DECLCALLBACK(int) rtDvmVfsDir_SetOwner(void *pvThis, RTUID uid, RTGID gid)
824	{
825	RT_NOREF(pvThis, uid, gid);
826	return VERR_NOT_SUPPORTED;
827	}
828
829
830	static int rtDvmVfsDir_FindEntry(PRTDVMVFSDIR pThis, const char *pszEntry,
831	PRTDVMVOLUME phVolume, uint32_t piVol, char *ppszSymlink)
832	{
833	*phVolume = NIL_RTDVMVOLUME;
834	*ppszSymlink = NULL;
835	*piVol = UINT32_MAX;
836
837	/*
838	* Enumerate the volumes and try match the volume name.
839	*/
840	int rc;
841	PRTDVMVFSVOL pVfsVol = pThis->pVfsVol;
842	if (pVfsVol->cVolumes > 0)
843	{
844	/* The first volume. */
845	uint32_t iVol = 0;
846	RTDVMVOLUME hVol;
847	rc = RTDvmMapQueryFirstVolume(pThis->pVfsVol->hVolMgr, &hVol);
848	while (RT_SUCCESS(rc))
849	{
850	/* Match the name. */
851	bool fMatch;
852	char *pszVolName;
853	rc = RTDvmVolumeQueryName(hVol, &pszVolName);
854	if (RT_SUCCESS(rc))
855	{
856	fMatch = RTStrCmp(pszEntry, pszVolName) == 0 && *pszVolName != '\0';
857	if (fMatch)
858	{
859	*phVolume = hVol;
860	*ppszSymlink = pszVolName;
861	*piVol = iVol;
862	return VINF_SUCCESS;
863	}
864	RTStrFree(pszVolName);
865	}
866	else if (rc == VERR_NOT_SUPPORTED)
867	fMatch = false;
868	else
869	{
870	RTDvmVolumeRelease(hVol);
871	break;
872	}
873
874	/* Match the sequential volume number. */
875	if (!fMatch)
876	{
877	char szTmp[16];
878	RTStrPrintf(szTmp, sizeof(szTmp), "vol%u", iVol);
879	fMatch = RTStrCmp(pszEntry, szTmp) == 0;
880	}
881
882	if (fMatch)
883	{
884	*phVolume = hVol;
885	*piVol = iVol;
886	return VINF_SUCCESS;
887	}
888
889	/* More volumes? */
890	iVol++;
891	if (iVol >= pVfsVol->cVolumes)
892	{
893	RTDvmVolumeRelease(hVol);
894	rc = VERR_FILE_NOT_FOUND;
895	break;
896	}
897
898	/* Get the next volume. */
899	RTDVMVOLUME hVolNext;
900	rc = RTDvmMapQueryNextVolume(pThis->pVfsVol->hVolMgr, hVol, &hVolNext);
901	RTDvmVolumeRelease(hVol);
902	hVol = hVolNext;
903	}
904	}
905	else
906	rc = VERR_FILE_NOT_FOUND;
907	return rc;
908	}
909
910
911	/**
912	* @interface_method_impl{RTVFSDIROPS,pfnOpen}
913	*/
914	static DECLCALLBACK(int) rtDvmVfsDir_Open(void pvThis, const char pszEntry, uint64_t fOpen, uint32_t fFlags, PRTVFSOBJ phVfsObj)
915	{
916	PRTDVMVFSDIR pThis = (PRTDVMVFSDIR)pvThis;
917
918	/*
919	* Special case: '.' and '..'
920	*/
921	if ( pszEntry[0] == '.'
922	&& ( pszEntry[1] == '\0'
923	\|\| ( pszEntry[1] == '.'
924	&& pszEntry[2] == '\0')))
925	{
926	if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
927	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
928	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
929	{
930	if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
931	{
932	RTVFSDIR hVfsDir;
933	int rc = rtDvmVfsVol_OpenRoot(pThis->pVfsVol, &hVfsDir);
934	if (RT_SUCCESS(rc))
935	{
936	*phVfsObj = RTVfsObjFromDir(hVfsDir);
937	RTVfsDirRelease(hVfsDir);
938	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
939	}
940	return rc;
941	}
942	return VERR_IS_A_DIRECTORY;
943	}
944	return VERR_ACCESS_DENIED;
945	}
946
947	/*
948	* Open volume file.
949	*/
950	RTDVMVOLUME hVolume = NIL_RTDVMVOLUME;
951	uint32_t iVol = 0;
952	char *pszSymlink = NULL;
953	int rc = rtDvmVfsDir_FindEntry(pThis, pszEntry, &hVolume, &iVol, &pszSymlink);
954	if (RT_SUCCESS(rc))
955	{
956	if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
957	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
958	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
959	{
960	if (fFlags & (RTVFSOBJ_F_OPEN_FILE \| RTVFSOBJ_F_OPEN_DEV_BLOCK))
961	{
962	if (!pszSymlink)
963	{
964	if ( !(fOpen & RTFILE_O_WRITE)
965	\|\| !pThis->pVfsVol->fReadOnly)
966	{
967	/* Create file object. */
968	RTVFSFILE hVfsFile;
969	rc = rtDvmVfsCreateFileForVolume(pThis->pVfsVol, hVolume, fOpen, &hVfsFile);
970	if (RT_SUCCESS(rc))
971	{
972	*phVfsObj = RTVfsObjFromFile(hVfsFile);
973	RTVfsFileRelease(hVfsFile);
974	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
975	}
976	}
977	else
978	rc = VERR_WRITE_PROTECT;
979	}
980	else
981	rc = VERR_IS_A_SYMLINK;
982	}
983	else if (fFlags & RTVFSOBJ_F_OPEN_SYMLINK)
984	{
985	/* Create symlink object */
986	RTVFSSYMLINK hVfsSym = NIL_RTVFSSYMLINK; /* (older gcc maybe used uninitialized) */
987	rc = rtDvmVfsCreateSymlinkForVolume(hVolume, pThis->pVfsVol ? pThis->pVfsVol->hVolMgr : NIL_RTDVM, iVol,
988	pszSymlink, &hVfsSym);
989	if (RT_SUCCESS(rc))
990	{
991	*phVfsObj = RTVfsObjFromSymlink(hVfsSym);
992	RTVfsSymlinkRelease(hVfsSym);
993	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
994	pszSymlink = NULL;
995	}
996	}
997	else
998	rc = VERR_IS_A_FILE;
999	}
1000	else
1001	rc = VERR_ALREADY_EXISTS;
1002	RTDvmVolumeRelease(hVolume);
1003	if (pszSymlink)
1004	RTStrFree(pszSymlink);
1005	}
1006	return rc;
1007	}
1008
1009
1010	/**
1011	* @interface_method_impl{RTVFSDIROPS,pfnOpenFile}
1012	*/
1013	static DECLCALLBACK(int) rtDvmVfsDir_OpenFile(void pvThis, const char pszFilename, uint64_t fOpen, PRTVFSFILE phVfsFile)
1014	{
1015	RTVFSOBJ hVfsObj;
1016	int rc = rtDvmVfsDir_Open(pvThis, pszFilename, fOpen, RTVFSOBJ_F_OPEN_FILE, &hVfsObj);
1017	if (RT_SUCCESS(rc))
1018	{
1019	*phVfsFile = RTVfsObjToFile(hVfsObj);
1020	RTVfsObjRelease(hVfsObj);
1021	}
1022	return rc;
1023	}
1024
1025
1026	/**
1027	* @interface_method_impl{RTVFSDIROPS,pfnCreateDir}
1028	*/
1029	static DECLCALLBACK(int) rtDvmVfsDir_CreateDir(void pvThis, const char pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir)
1030	{
1031	RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir);
1032	return VERR_NOT_SUPPORTED;
1033	}
1034
1035
1036	/**
1037	* @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink}
1038	*/
1039	static DECLCALLBACK(int) rtDvmVfsDir_OpenSymlink(void pvThis, const char pszSymlink, PRTVFSSYMLINK phVfsSymlink)
1040	{
1041	RT_NOREF(pvThis, pszSymlink, phVfsSymlink);
1042	return VERR_NOT_SUPPORTED;
1043	}
1044
1045
1046	/**
1047	* @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink}
1048	*/
1049	static DECLCALLBACK(int) rtDvmVfsDir_CreateSymlink(void pvThis, const char pszSymlink, const char *pszTarget,
1050	RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink)
1051	{
1052	RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink);
1053	return VERR_NOT_SUPPORTED;
1054	}
1055
1056
1057	/**
1058	* @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry}
1059	*/
1060	static DECLCALLBACK(int) rtDvmVfsDir_UnlinkEntry(void pvThis, const char pszEntry, RTFMODE fType)
1061	{
1062	RT_NOREF(pvThis, pszEntry, fType);
1063	return VERR_NOT_IMPLEMENTED;
1064	}
1065
1066
1067	/**
1068	* @interface_method_impl{RTVFSDIROPS,pfnRenameEntry}
1069	*/
1070	static DECLCALLBACK(int) rtDvmVfsDir_RenameEntry(void pvThis, const char pszEntry, RTFMODE fType, const char *pszNewName)
1071	{
1072	RT_NOREF(pvThis, pszEntry, fType, pszNewName);
1073	return VERR_NOT_IMPLEMENTED;
1074	}
1075
1076
1077	/**
1078	* @interface_method_impl{RTVFSDIROPS,pfnRewindDir}
1079	*/
1080	static DECLCALLBACK(int) rtDvmVfsDir_RewindDir(void *pvThis)
1081	{
1082	PRTDVMVFSDIR pThis = (PRTDVMVFSDIR)pvThis;
1083
1084	if (pThis->hCurVolume != NIL_RTDVMVOLUME)
1085	{
1086	RTDvmVolumeRelease(pThis->hCurVolume);
1087	pThis->hCurVolume = NIL_RTDVMVOLUME;
1088	}
1089	pThis->fReturnCurrent = false;
1090	pThis->offDir = 0;
1091	if (pThis->pszNameAlias)
1092	{
1093	RTStrFree(pThis->pszNameAlias);
1094	pThis->pszNameAlias = NULL;
1095	}
1096
1097	return VINF_SUCCESS;
1098	}
1099
1100
1101	/**
1102	* @interface_method_impl{RTVFSDIROPS,pfnReadDir}
1103	*/
1104	static DECLCALLBACK(int) rtDvmVfsDir_ReadDir(void pvThis, PRTDIRENTRYEX pDirEntry, size_t pcbDirEntry,
1105	RTFSOBJATTRADD enmAddAttr)
1106	{
1107	PRTDVMVFSDIR pThis = (PRTDVMVFSDIR)pvThis;
1108	PRTDVMVFSVOL pVfsVol = pThis->pVfsVol;
1109	int rc;
1110
1111	/*
1112	* Format the volume name since we'll be needing it all but the final call.
1113	*/
1114	char szVolNo[16];
1115	size_t const cchVolNo = RTStrPrintf(szVolNo, sizeof(szVolNo), "vol%u", pThis->offDir);
1116
1117	if (!pThis->fReturnCurrent)
1118	{
1119	/*
1120	* Do we have a pending name alias to return?
1121	*/
1122	if (pThis->pszNameAlias)
1123	{
1124	size_t cchNameAlias = strlen(pThis->pszNameAlias);
1125	size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchNameAlias + 1]);
1126	if (cbNeeded <= *pcbDirEntry)
1127	{
1128	*pcbDirEntry = cbNeeded;
1129
1130	/* Do the names. */
1131	pDirEntry->cbName = (uint16_t)cchNameAlias;
1132	memcpy(pDirEntry->szName, pThis->pszNameAlias, cchNameAlias + 1);
1133	pDirEntry->cwcShortName = 0;
1134	pDirEntry->wszShortName[0] = '\0';
1135
1136
1137	/* Do the rest. */
1138	rc = rtDvmVfsSym_QueryInfoWorker(pThis->hCurVolume, pVfsVol->hVolMgr, szVolNo, &pDirEntry->Info, enmAddAttr);
1139	if (RT_SUCCESS(rc))
1140	{
1141	RTStrFree(pThis->pszNameAlias);
1142	pThis->pszNameAlias = NULL;
1143	pThis->offDir += 1;
1144	}
1145	return rc;
1146	}
1147
1148	*pcbDirEntry = cbNeeded;
1149	return VERR_BUFFER_OVERFLOW;
1150	}
1151
1152	/*
1153	* Get the next volume to return info about.
1154	*/
1155	if (pThis->offDir < pVfsVol->cVolumes)
1156	{
1157	RTDVMVOLUME hNextVolume;
1158	if (pThis->offDir == 0)
1159	rc = RTDvmMapQueryFirstVolume(pVfsVol->hVolMgr, &hNextVolume);
1160	else
1161	rc = RTDvmMapQueryNextVolume(pVfsVol->hVolMgr, pThis->hCurVolume, &hNextVolume);
1162	if (RT_FAILURE(rc))
1163	return rc;
1164	RTDvmVolumeRelease(pThis->hCurVolume);
1165	pThis->hCurVolume = hNextVolume;
1166
1167	/* Check if we need to return a name alias later. */
1168	rc = RTDvmVolumeQueryName(pThis->hCurVolume, &pThis->pszNameAlias);
1169	if (RT_FAILURE(rc))
1170	pThis->pszNameAlias = NULL;
1171	else if (*pThis->pszNameAlias == '\0')
1172	{
1173	RTStrFree(pThis->pszNameAlias);
1174	pThis->pszNameAlias = NULL;
1175	}
1176	}
1177	else
1178	{
1179	RTDvmVolumeRelease(pThis->hCurVolume);
1180	pThis->hCurVolume = NIL_RTDVMVOLUME;
1181	return VERR_NO_MORE_FILES;
1182	}
1183	}
1184
1185	/*
1186	* Figure out the name length.
1187	*/
1188	size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchVolNo + 1]);
1189	if (cbNeeded <= *pcbDirEntry)
1190	{
1191	*pcbDirEntry = cbNeeded;
1192
1193	/* Do the names. */
1194	pDirEntry->cbName = (uint16_t)cchVolNo;
1195	memcpy(pDirEntry->szName, szVolNo, cchVolNo + 1);
1196	pDirEntry->cwcShortName = 0;
1197	pDirEntry->wszShortName[0] = '\0';
1198
1199	/* Do the rest. */
1200	rc = rtDvmVfsFile_QueryInfoWorker(pThis->hCurVolume, pVfsVol->hVolMgr, pVfsVol->fReadOnly, &pDirEntry->Info, enmAddAttr);
1201	if (RT_SUCCESS(rc))
1202	{
1203	pThis->fReturnCurrent = false;
1204	if (!pThis->pszNameAlias)
1205	pThis->offDir += 1;
1206	return rc;
1207	}
1208	}
1209	else
1210	{
1211	*pcbDirEntry = cbNeeded;
1212	rc = VERR_BUFFER_OVERFLOW;
1213	}
1214	pThis->fReturnCurrent = true;
1215	return rc;
1216	}
1217
1218
1219	/**
1220	* DVM (root) directory operations.
1221	*/
1222	static const RTVFSDIROPS g_rtDvmVfsDirOps =
1223	{
1224	{ /* Obj */
1225	RTVFSOBJOPS_VERSION,
1226	RTVFSOBJTYPE_DIR,
1227	"DvmDir",
1228	rtDvmVfsDir_Close,
1229	rtDvmVfsDir_QueryInfo,
1230	NULL,
1231	RTVFSOBJOPS_VERSION
1232	},
1233	RTVFSDIROPS_VERSION,
1234	0,
1235	{ /* ObjSet */
1236	RTVFSOBJSETOPS_VERSION,
1237	RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
1238	rtDvmVfsDir_SetMode,
1239	rtDvmVfsDir_SetTimes,
1240	rtDvmVfsDir_SetOwner,
1241	RTVFSOBJSETOPS_VERSION
1242	},
1243	rtDvmVfsDir_Open,
1244	NULL /* pfnFollowAbsoluteSymlink */,
1245	rtDvmVfsDir_OpenFile,
1246	NULL /* pfnOpenDir */,
1247	rtDvmVfsDir_CreateDir,
1248	rtDvmVfsDir_OpenSymlink,
1249	rtDvmVfsDir_CreateSymlink,
1250	NULL /* pfnQueryEntryInfo */,
1251	rtDvmVfsDir_UnlinkEntry,
1252	rtDvmVfsDir_RenameEntry,
1253	rtDvmVfsDir_RewindDir,
1254	rtDvmVfsDir_ReadDir,
1255	RTVFSDIROPS_VERSION,
1256	};
1257
1258
1259
1260	/**
1261	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose}
1262	*/
1263	static DECLCALLBACK(int) rtDvmVfsVol_Close(void *pvThis)
1264	{
1265	PRTDVMVFSVOL pThis = (PRTDVMVFSVOL)pvThis;
1266	LogFlow(("rtDvmVfsVol_Close(%p)\n", pThis));
1267
1268	if ( pThis->fCloseDvm
1269	&& pThis->hVolMgr != NIL_RTDVM )
1270	RTDvmRelease(pThis->hVolMgr);
1271	pThis->hVolMgr = NIL_RTDVM;
1272
1273	return VINF_SUCCESS;
1274	}
1275
1276
1277	/**
1278	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo}
1279	*/
1280	static DECLCALLBACK(int) rtDvmVfsVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
1281	{
1282	RT_NOREF(pvThis, pObjInfo, enmAddAttr);
1283	return VERR_WRONG_TYPE;
1284	}
1285
1286
1287	/**
1288	* @interface_method_impl{RTVFSOPS,pfnOpenRoot}
1289	*/
1290	static DECLCALLBACK(int) rtDvmVfsVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
1291	{
1292	PRTDVMVFSVOL pThis = (PRTDVMVFSVOL)pvThis;
1293
1294	PRTDVMVFSDIR pNewDir;
1295	int rc = RTVfsNewDir(&g_rtDvmVfsDirOps, sizeof(pNewDir), 0 /fFlags*/, pThis->hVfsSelf,
1296	NIL_RTVFSLOCK /use volume lock/, phVfsDir, (void **)&pNewDir);
1297	if (RT_SUCCESS(rc))
1298	{
1299	pNewDir->offDir = 0;
1300	pNewDir->pVfsVol = pThis;
1301	pNewDir->fReturnCurrent = false;
1302	pNewDir->pszNameAlias = NULL;
1303	pNewDir->hCurVolume = NIL_RTDVMVOLUME;
1304	}
1305	return rc;
1306	}
1307
1308
1309	/**
1310	* @interface_method_impl{RTVFSOPS,pfnQueryRangeState}
1311	*/
1312	static DECLCALLBACK(int) rtDvmVfsVol_QueryRangeState(void pvThis, uint64_t off, size_t cb, bool pfUsed)
1313	{
1314	RT_NOREF(pvThis, off, cb, pfUsed);
1315	return VERR_NOT_IMPLEMENTED;
1316	}
1317
1318
1319	DECL_HIDDEN_CONST(const RTVFSOPS) g_rtDvmVfsVolOps =
1320	{
1321	{ /* Obj */
1322	RTVFSOBJOPS_VERSION,
1323	RTVFSOBJTYPE_VFS,
1324	"DvmVol",
1325	rtDvmVfsVol_Close,
1326	rtDvmVfsVol_QueryInfo,
1327	NULL,
1328	RTVFSOBJOPS_VERSION
1329	},
1330	RTVFSOPS_VERSION,
1331	0 /* fFeatures */,
1332	rtDvmVfsVol_OpenRoot,
1333	rtDvmVfsVol_QueryRangeState,
1334	RTVFSOPS_VERSION
1335	};
1336
1337
1338
1339	/**
1340	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
1341	*/
1342	static DECLCALLBACK(int) rtDvmVfsChain_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
1343	PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
1344	{
1345	RT_NOREF(pProviderReg, pSpec);
1346
1347	/*
1348	* Basic checks.
1349	*/
1350	if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE)
1351	return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE;
1352	if (pElement->enmType != RTVFSOBJTYPE_VFS)
1353	return VERR_VFS_CHAIN_ONLY_VFS;
1354
1355	if (pElement->cArgs > 1)
1356	return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
1357
1358	/*
1359	* Parse the flag if present, save in pElement->uProvider.
1360	*/
1361	/** @todo allow specifying sector size */
1362	bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ;
1363	if (pElement->cArgs > 0)
1364	{
1365	const char *psz = pElement->paArgs[0].psz;
1366	if (*psz)
1367	{
1368	if ( !strcmp(psz, "ro")
1369	\|\| !strcmp(psz, "r"))
1370	fReadOnly = true;
1371	else if (!strcmp(psz, "rw"))
1372	fReadOnly = false;
1373	else
1374	{
1375	*poffError = pElement->paArgs[0].offSpec;
1376	return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument");
1377	}
1378	}
1379	}
1380
1381	pElement->uProvider = fReadOnly;
1382	return VINF_SUCCESS;
1383	}
1384
1385
1386	/**
1387	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
1388	*/
1389	static DECLCALLBACK(int) rtDvmVfsChain_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
1390	PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
1391	PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
1392	{
1393	RT_NOREF(pProviderReg, pSpec, poffError, pErrInfo);
1394	AssertReturn(hPrevVfsObj != NIL_RTVFSOBJ, VERR_VFS_CHAIN_IPE);
1395
1396	/*
1397	* Instantiate the volume manager and open the map stuff.
1398	*/
1399	RTVFSFILE hPrevVfsFile = RTVfsObjToFile(hPrevVfsObj);
1400	AssertReturn(hPrevVfsFile != NIL_RTVFSFILE, VERR_VFS_CHAIN_CAST_FAILED);
1401
1402	RTDVM hVolMgr;
1403	int rc = RTDvmCreate(&hVolMgr, hPrevVfsFile, 512, 0 /fFlags/);
1404	RTVfsFileRelease(hPrevVfsFile);
1405	if (RT_SUCCESS(rc))
1406	{
1407	rc = RTDvmMapOpen(hVolMgr);
1408	if (RT_SUCCESS(rc))
1409	{
1410	/*
1411	* Create a VFS instance for the volume manager.
1412	*/
1413	RTVFS hVfs = NIL_RTVFS;
1414	PRTDVMVFSVOL pThis = NULL;
1415	rc = RTVfsNew(&g_rtDvmVfsVolOps, sizeof(RTDVMVFSVOL), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis);
1416	if (RT_SUCCESS(rc))
1417	{
1418	pThis->hVolMgr = hVolMgr;
1419	pThis->fCloseDvm = true;
1420	pThis->fReadOnly = pElement->uProvider == (uint64_t)true;
1421	pThis->cVolumes = RTDvmMapGetValidVolumes(hVolMgr);
1422	pThis->hVfsSelf = hVfs;
1423
1424	*phVfsObj = RTVfsObjFromVfs(hVfs);
1425	RTVfsRelease(hVfs);
1426	return *phVfsObj != NIL_RTVFSOBJ ? VINF_SUCCESS : VERR_VFS_CHAIN_CAST_FAILED;
1427	}
1428	}
1429	else
1430	rc = RTErrInfoSetF(pErrInfo, rc, "RTDvmMapOpen failed: %Rrc", rc);
1431	RTDvmRelease(hVolMgr);
1432	}
1433	else
1434	rc = RTErrInfoSetF(pErrInfo, rc, "RTDvmCreate failed: %Rrc", rc);
1435	return rc;
1436	}
1437
1438
1439	/**
1440	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
1441	*/
1442	static DECLCALLBACK(bool) rtDvmVfsChain_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
1443	PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
1444	PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
1445	{
1446	RT_NOREF(pProviderReg, pSpec, pElement, pReuseSpec, pReuseElement);
1447	return false;
1448	}
1449
1450
1451	/** VFS chain element 'file'. */
1452	static RTVFSCHAINELEMENTREG g_rtVfsChainIsoFsVolReg =
1453	{
1454	/* uVersion = */ RTVFSCHAINELEMENTREG_VERSION,
1455	/* fReserved = */ 0,
1456	/* pszName = */ "dvm",
1457	/* ListEntry = */ { NULL, NULL },
1458	/* pszHelp = */ "Opens a container image using the VD API.\n"
1459	"Optionally takes one parameter 'ro' (read only) or 'rw' (read write).\n",
1460	/* pfnValidate = */ rtDvmVfsChain_Validate,
1461	/* pfnInstantiate = */ rtDvmVfsChain_Instantiate,
1462	/* pfnCanReuseElement = */ rtDvmVfsChain_CanReuseElement,
1463	/* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION
1464	};
1465
1466	RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainIsoFsVolReg, rtVfsChainIsoFsVolReg);
1467

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

source: vbox/trunk/src/VBox/Runtime/common/dvm/dvmvfs.cpp@ 98392

Download in other formats: