vfslowlevel.h@ 36555

Last change on this file since 36555 was 36555, checked in by vboxsync, 14 years ago
Use DECLHIDDEN, especially in IPRT.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 43.9 KB

Line
1	/** @file
2	* IPRT - Virtual Filesystem.
3	*/
4
5	/*
6	* Copyright (C) 2010 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef ___iprt_vfslowlevel_h
27	#define ___iprt_vfslowlevel_h
28
29	#include <iprt/vfs.h>
30	#include <iprt/err.h>
31	#include <iprt/list.h>
32	#include <iprt/param.h>
33
34
35	RT_C_DECLS_BEGIN
36
37	/** @defgroup grp_rt_vfs_lowlevel RTVfs - Low-level Interface.
38	* @ingroup grp_rt_vfs
39	* @{
40	*/
41
42
43	/** @name VFS Lock Abstraction
44	* @todo This should be moved somewhere else as it is of general use.
45	* @{ */
46
47	/**
48	* VFS lock types.
49	*/
50	typedef enum RTVFSLOCKTYPE
51	{
52	/** Invalid lock type. */
53	RTVFSLOCKTYPE_INVALID = 0,
54	/** Read write semaphore. */
55	RTVFSLOCKTYPE_RW,
56	/** Fast mutex semaphore (critical section in ring-3). */
57	RTVFSLOCKTYPE_FASTMUTEX,
58	/** Full fledged mutex semaphore. */
59	RTVFSLOCKTYPE_MUTEX,
60	/** The end of valid lock types. */
61	RTVFSLOCKTYPE_END,
62	/** The customary 32-bit type hack. */
63	RTVFSLOCKTYPE_32BIT_HACK = 0x7fffffff
64	} RTVFSLOCKTYPE;
65
66	/** VFS lock handle. */
67	typedef struct RTVFSLOCKINTERNAL *RTVFSLOCK;
68	/** Pointer to a VFS lock handle. */
69	typedef RTVFSLOCK *PRTVFSLOCK;
70	/** Nil VFS lock handle. */
71	#define NIL_RTVFSLOCK ((RTVFSLOCK)~(uintptr_t)0)
72
73	/** Special handle value for creating a new read/write semaphore based lock. */
74	#define RTVFSLOCK_CREATE_RW ((RTVFSLOCK)~(uintptr_t)1)
75	/** Special handle value for creating a new fast mutex semaphore based lock. */
76	#define RTVFSLOCK_CREATE_FASTMUTEX ((RTVFSLOCK)~(uintptr_t)2)
77	/** Special handle value for creating a new mutex semaphore based lock. */
78	#define RTVFSLOCK_CREATE_MUTEX ((RTVFSLOCK)~(uintptr_t)3)
79
80	/**
81	* Retains a reference to the VFS lock handle.
82	*
83	* @returns New reference count on success, UINT32_MAX on failure.
84	* @param hLock The VFS lock handle.
85	*/
86	RTDECL(uint32_t) RTVfsLockRetain(RTVFSLOCK hLock);
87
88	/**
89	* Releases a reference to the VFS lock handle.
90	*
91	* @returns New reference count on success (0 if closed), UINT32_MAX on failure.
92	* @param hLock The VFS lock handle.
93	*/
94	RTDECL(uint32_t) RTVfsLockRelease(RTVFSLOCK hLock);
95
96	/**
97	* Gets the lock type.
98	*
99	* @returns The lock type on success, RTVFSLOCKTYPE_INVALID if the handle is
100	* not valid.
101	* @param hLock The lock handle.
102	*/
103	RTDECL(RTVFSLOCKTYPE) RTVfsLockGetType(RTVFSLOCK hLock);
104
105
106
107	RTDECL(void) RTVfsLockAcquireReadSlow(RTVFSLOCK hLock);
108	RTDECL(void) RTVfsLockReleaseReadSlow(RTVFSLOCK hLock);
109	RTDECL(void) RTVfsLockAcquireWriteSlow(RTVFSLOCK hLock);
110	RTDECL(void) RTVfsLockReleaseWriteSlow(RTVFSLOCK hLock);
111
112	/**
113	* Acquire a read lock.
114	*
115	* @param hLock The lock handle, can be NIL.
116	*/
117	DECLINLINE(void) RTVfsLockAcquireRead(RTVFSLOCK hLock)
118	{
119	if (hLock != NIL_RTVFSLOCK)
120	RTVfsLockAcquireReadSlow(hLock);
121	}
122
123
124	/**
125	* Release a read lock.
126	*
127	* @param hLock The lock handle, can be NIL.
128	*/
129	DECLINLINE(void) RTVfsLockReleaseRead(RTVFSLOCK hLock)
130	{
131	if (hLock != NIL_RTVFSLOCK)
132	RTVfsLockReleaseReadSlow(hLock);
133	}
134
135
136	/**
137	* Acquire a write lock.
138	*
139	* @param hLock The lock handle, can be NIL.
140	*/
141	DECLINLINE(void) RTVfsLockAcquireWrite(RTVFSLOCK hLock)
142	{
143	if (hLock != NIL_RTVFSLOCK)
144	RTVfsLockAcquireWriteSlow(hLock);
145	}
146
147
148	/**
149	* Release a write lock.
150	*
151	* @param hLock The lock handle, can be NIL.
152	*/
153	DECLINLINE(void) RTVfsLockReleaseWrite(RTVFSLOCK hLock)
154	{
155	if (hLock != NIL_RTVFSLOCK)
156	RTVfsLockReleaseWriteSlow(hLock);
157	}
158
159	/** @} */
160
161	/**
162	* The VFS operations.
163	*/
164	typedef struct RTVFSOPS
165	{
166	/** The structure version (RTVFSOPS_VERSION). */
167	uint32_t uVersion;
168	/** The virtual file system feature mask. */
169	uint32_t fFeatures;
170	/** The name of the operations. */
171	const char *pszName;
172
173	/**
174	* Destructor.
175	*
176	* @param pvThis The implementation specific data.
177	*/
178	DECLCALLBACKMEMBER(void, pfnDestroy)(void *pvThis);
179
180	/**
181	* Opens the root directory.
182	*
183	* @returns IPRT status code.
184	* @param pvThis The implementation specific data.
185	* @param phVfsDir Where to return the handle to the root directory.
186	*/
187	DECLCALLBACKMEMBER(int, pfnOpenRoot)(void *pvThis, PRTVFSDIR phVfsDir);
188
189	/** @todo There will be more methods here to optimize opening and
190	* querying. */
191
192	#if 0
193	/**
194	* Optional entry point for optimizing path traversal within the file system.
195	*
196	* @returns IPRT status code.
197	* @param pvThis The implementation specific data.
198	* @param pszPath The path to resolve.
199	* @param poffPath The current path offset on input, what we've
200	* traversed to on successful return.
201	* @param phVfs??? Return handle to what we've traversed.
202	* @param p??? Return other stuff...
203	*/
204	DECLCALLBACKMEMBER(int, pfnTraverse)(void pvThis, const char pszPath, size_t poffPath, PRTVFS??? phVfs?, ??? p???);
205	#endif
206
207	/** Marks the end of the structure (RTVFSOPS_VERSION). */
208	uintptr_t uEndMarker;
209	} RTVFSOPS;
210	/** Pointer to constant VFS operations. */
211	typedef RTVFSOPS const *PCRTVFSOPS;
212
213	/** The RTVFSOPS structure version. */
214	#define RTVFSOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x0f,1,0)
215
216	/** @name RTVFSOPS::fFeatures
217	* @{ */
218	/** The VFS supports attaching other systems. */
219	#define RTVFSOPS_FEAT_ATTACH RT_BIT_32(0)
220	/** @} */
221
222
223	/**
224	* The basis for all virtual file system objects except RTVFS.
225	*/
226	typedef struct RTVFSOBJOPS
227	{
228	/** The structure version (RTVFSOBJOPS_VERSION). */
229	uint32_t uVersion;
230	/** The object type for type introspection. */
231	RTVFSOBJTYPE enmType;
232	/** The name of the operations. */
233	const char *pszName;
234
235	/**
236	* Close the object.
237	*
238	* @returns IPRT status code.
239	* @param pvThis The implementation specific file data.
240	*/
241	DECLCALLBACKMEMBER(int, pfnClose)(void *pvThis);
242
243	/**
244	* Get information about the file.
245	*
246	* @returns IPRT status code. See RTVfsObjQueryInfo.
247	* @param pvThis The implementation specific file data.
248	* @param pObjInfo Where to return the object info on success.
249	* @param enmAddAttr Which set of additional attributes to request.
250	* @sa RTVfsObjQueryInfo, RTFileQueryInfo, RTPathQueryInfo
251	*/
252	DECLCALLBACKMEMBER(int, pfnQueryInfo)(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr);
253
254	/** Marks the end of the structure (RTVFSOBJOPS_VERSION). */
255	uintptr_t uEndMarker;
256	} RTVFSOBJOPS;
257	/** Pointer to constant VFS object operations. */
258	typedef RTVFSOBJOPS const *PCRTVFSOBJOPS;
259
260	/** The RTVFSOBJOPS structure version. */
261	#define RTVFSOBJOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x1f,1,0)
262
263
264	/**
265	* Creates a new VFS base object handle.
266	*
267	* @returns IPRT status code
268	* @param pObjOps The base object operations.
269	* @param cbInstance The size of the instance data.
270	* @param hVfs The VFS handle to associate this base object
271	* with. NIL_VFS is ok.
272	* @param hLock Handle to a custom lock to be used with the new
273	* object. The reference is consumed. NIL and
274	* special lock handles are fine.
275	* @param phVfsFss Where to return the new handle.
276	* @param ppvInstance Where to return the pointer to the instance data
277	* (size is @a cbInstance).
278	*/
279	RTDECL(int) RTVfsNewBaseObj(PCRTVFSOBJOPS pObjOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
280	PRTVFSOBJ phVfsObj, void **ppvInstance);
281
282
283	/**
284	* Additional operations for setting object attributes.
285	*/
286	typedef struct RTVFSOBJSETOPS
287	{
288	/** The structure version (RTVFSOBJSETOPS_VERSION). */
289	uint32_t uVersion;
290	/** The offset to the RTVFSOBJOPS structure. */
291	int32_t offObjOps;
292
293	/**
294	* Set the unix style owner and group.
295	*
296	* @returns IPRT status code.
297	* @param pvThis The implementation specific file data.
298	* @param fMode The new mode bits.
299	* @param fMask The mask indicating which bits we are
300	* changing.
301	* @sa RTFileSetMode
302	*/
303	DECLCALLBACKMEMBER(int, pfnSetMode)(void *pvThis, RTFMODE fMode, RTFMODE fMask);
304
305	/**
306	* Set the timestamps associated with the object.
307	*
308	* @returns IPRT status code.
309	* @param pvThis The implementation specific file data.
310	* @param pAccessTime Pointer to the new access time. NULL if not
311	* to be changed.
312	* @param pModificationTime Pointer to the new modifcation time. NULL if
313	* not to be changed.
314	* @param pChangeTime Pointer to the new change time. NULL if not
315	* to be changed.
316	* @param pBirthTime Pointer to the new time of birth. NULL if
317	* not to be changed.
318	* @remarks See RTFileSetTimes for restrictions and behavior imposed by the
319	* host OS or underlying VFS provider.
320	* @sa RTFileSetTimes
321	*/
322	DECLCALLBACKMEMBER(int, pfnSetTimes)(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
323	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime);
324
325	/**
326	* Set the unix style owner and group.
327	*
328	* @returns IPRT status code.
329	* @param pvThis The implementation specific file data.
330	* @param uid The user ID of the new owner. NIL_RTUID if
331	* unchanged.
332	* @param gid The group ID of the new owner group. NIL_RTGID if
333	* unchanged.
334	* @sa RTFileSetOwner
335	*/
336	DECLCALLBACKMEMBER(int, pfnSetOwner)(void *pvThis, RTUID uid, RTGID gid);
337
338	/** Marks the end of the structure (RTVFSOBJSETOPS_VERSION). */
339	uintptr_t uEndMarker;
340	} RTVFSOBJSETOPS;
341	/** Pointer to const object attribute setter operations. */
342	typedef RTVFSOBJSETOPS const *PCRTVFSOBJSETOPS;
343
344	/** The RTVFSOBJSETOPS structure version. */
345	#define RTVFSOBJSETOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x2f,1,0)
346
347
348	/**
349	* The filesystem stream operations.
350	*
351	* @extends RTVFSOBJOPS
352	*/
353	typedef struct RTVFSFSSTREAMOPS
354	{
355	/** The basic object operation. */
356	RTVFSOBJOPS Obj;
357	/** The structure version (RTVFSFSSTREAMOPS_VERSION). */
358	uint32_t uVersion;
359	/** Reserved field, MBZ. */
360	uint32_t fReserved;
361
362	/**
363	* Gets the next object in the stream.
364	*
365	* @returns IPRT status code.
366	* @retval VINF_SUCCESS if a new object was retrieved.
367	* @retval VERR_EOF when there are no more objects.
368	* @param pvThis The implementation specific directory data.
369	* @param ppszName Where to return the object name. Must be freed by
370	* calling RTStrFree.
371	* @param penmType Where to return the object type.
372	* @param hVfsObj Where to return the object handle (referenced).
373	* This must be cast to the desired type before use.
374	* @sa RTVfsFsStrmNext
375	*/
376	DECLCALLBACKMEMBER(int, pfnNext)(void pvThis, char ppszName, RTVFSOBJTYPE penmType, PRTVFSOBJ phVfsObj);
377
378	/** Marks the end of the structure (RTVFSFSSTREAMOPS_VERSION). */
379	uintptr_t uEndMarker;
380	} RTVFSFSSTREAMOPS;
381	/** Pointer to const object attribute setter operations. */
382	typedef RTVFSFSSTREAMOPS const *PCRTVFSFSSTREAMOPS;
383
384	/** The RTVFSFSSTREAMOPS structure version. */
385	#define RTVFSFSSTREAMOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x3f,1,0)
386
387
388	/**
389	* Creates a new VFS filesystem stream handle.
390	*
391	* @returns IPRT status code
392	* @param pFsStreamOps The filesystem stream operations.
393	* @param cbInstance The size of the instance data.
394	* @param hVfs The VFS handle to associate this filesystem
395	* stream with. NIL_VFS is ok.
396	* @param hLock Handle to a custom lock to be used with the new
397	* object. The reference is consumed. NIL and
398	* special lock handles are fine.
399	* @param phVfsFss Where to return the new handle.
400	* @param ppvInstance Where to return the pointer to the instance data
401	* (size is @a cbInstance).
402	*/
403	RTDECL(int) RTVfsNewFsStream(PCRTVFSFSSTREAMOPS pFsStreamOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
404	PRTVFSFSSTREAM phVfsFss, void **ppvInstance);
405
406
407	/**
408	* The directory operations.
409	*
410	* @extends RTVFSOBJOPS
411	* @extends RTVFSOBJSETOPS
412	*/
413	typedef struct RTVFSDIROPS
414	{
415	/** The basic object operation. */
416	RTVFSOBJOPS Obj;
417	/** The structure version (RTVFSDIROPS_VERSION). */
418	uint32_t uVersion;
419	/** Reserved field, MBZ. */
420	uint32_t fReserved;
421	/** The object setter operations. */
422	RTVFSOBJSETOPS ObjSet;
423
424	/**
425	* Opens a directory entry for traversal purposes.
426	*
427	* Method which sole purpose is helping the path traversal. Only one of
428	* the three output variables will be set, the others will left untouched
429	* (caller sets them to NIL).
430	*
431	* @returns IPRT status code.
432	* @retval VERR_PATH_NOT_FOUND if @a pszEntry was not found.
433	* @param pvThis The implementation specific directory data.
434	* @param pszEntry The name of the directory entry to remove.
435	* @param phVfsDir If not NULL and it is a directory, open it and
436	* return the handle here.
437	* @param phVfsSymlink If not NULL and it is a symbolic link, open it
438	* and return the handle here.
439	* @param phVfsMounted If not NULL and it is a mounted VFS directory,
440	* reference it and return the handle here.
441	* @todo Should com dir, symlinks and mount points using some common
442	* ancestor "class".
443	*/
444	DECLCALLBACKMEMBER(int, pfnTraversalOpen)(void pvThis, const char pszEntry, PRTVFSDIR phVfsDir,
445	PRTVFSSYMLINK phVfsSymlink, PRTVFS phVfsMounted);
446
447	/**
448	* Open or create a file.
449	*
450	* @returns IPRT status code.
451	* @param pvThis The implementation specific directory data.
452	* @param pszFilename The name of the immediate file to open or create.
453	* @param fOpen The open flags (RTFILE_O_XXX).
454	* @param phVfsFile Where to return the thandle to the opened file.
455	* @sa RTFileOpen.
456	*/
457	DECLCALLBACKMEMBER(int, pfnOpenFile)(void pvThis, const char pszFilename, uint32_t fOpen, PRTVFSFILE phVfsFile);
458
459	/**
460	* Open an existing subdirectory.
461	*
462	* @returns IPRT status code.
463	* @param pvThis The implementation specific directory data.
464	* @param pszSubDir The name of the immediate subdirectory to open.
465	* @param phVfsDir Where to return the handle to the opened directory.
466	* @sa RTDirOpen.
467	*/
468	DECLCALLBACKMEMBER(int, pfnOpenDir)(void pvThis, const char pszSubDir, PRTVFSDIR phVfsDir);
469
470	/**
471	* Creates a new subdirectory.
472	*
473	* @returns IPRT status code.
474	* @param pvThis The implementation specific directory data.
475	* @param pszSubDir The name of the immediate subdirectory to create.
476	* @param fMode The mode mask of the new directory.
477	* @param phVfsDir Where to optionally return the handle to the newly
478	* create directory.
479	* @sa RTDirCreate.
480	*/
481	DECLCALLBACKMEMBER(int, pfnCreateDir)(void pvThis, const char pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir);
482
483	/**
484	* Opens an existing symbolic link.
485	*
486	* @returns IPRT status code.
487	* @param pvThis The implementation specific directory data.
488	* @param pszSymlink The name of the immediate symbolic link to open.
489	* @param phVfsSymlink Where to optionally return the handle to the
490	* newly create symbolic link.
491	* @sa RTSymlinkCreate.
492	*/
493	DECLCALLBACKMEMBER(int, pfnOpenSymlink)(void pvThis, const char pszSymlink, PRTVFSSYMLINK phVfsSymlink);
494
495	/**
496	* Creates a new symbolic link.
497	*
498	* @returns IPRT status code.
499	* @param pvThis The implementation specific directory data.
500	* @param pszSymlink The name of the immediate symbolic link to create.
501	* @param pszTarget The symbolic link target.
502	* @param enmType The symbolic link type.
503	* @param phVfsSymlink Where to optionally return the handle to the
504	* newly create symbolic link.
505	* @sa RTSymlinkCreate.
506	*/
507	DECLCALLBACKMEMBER(int, pfnCreateSymlink)(void pvThis, const char pszSymlink, const char *pszTarget,
508	RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink);
509
510	/**
511	* Removes a directory entry.
512	*
513	* @returns IPRT status code.
514	* @param pvThis The implementation specific directory data.
515	* @param pszEntry The name of the directory entry to remove.
516	* @param fType If non-zero, this restricts the type of the entry to
517	* the object type indicated by the mask
518	* (RTFS_TYPE_XXX).
519	* @sa RTFileRemove, RTDirRemove, RTSymlinkRemove.
520	*/
521	DECLCALLBACKMEMBER(int, pfnUnlinkEntry)(void pvThis, const char pszEntry, RTFMODE fType, PRTVFSDIR phVfsDir);
522
523	/**
524	* Rewind the directory stream so that the next read returns the first
525	* entry.
526	*
527	* @returns IPRT status code.
528	* @param pvThis The implementation specific directory data.
529	*/
530	DECLCALLBACKMEMBER(int, pfnRewindDir)(void *pvThis);
531
532	/**
533	* Rewind the directory stream so that the next read returns the first
534	* entry.
535	*
536	* @returns IPRT status code.
537	* @param pvThis The implementation specific directory data.
538	* @param pDirEntry Output buffer.
539	* @param pcbDirEntry Complicated, see RTDirReadEx.
540	* @param enmAddAttr Which set of additional attributes to request.
541	* @sa RTDirReadEx
542	*/
543	DECLCALLBACKMEMBER(int, pfnReadDir)(void pvThis, PRTDIRENTRYEX pDirEntry, size_t pcbDirEntry, RTFSOBJATTRADD enmAddAttr);
544
545	/** Marks the end of the structure (RTVFSDIROPS_VERSION). */
546	uintptr_t uEndMarker;
547	} RTVFSDIROPS;
548	/** Pointer to const directory operations. */
549	typedef RTVFSDIROPS const *PCRTVFSDIROPS;
550	/** The RTVFSDIROPS structure version. */
551	#define RTVFSDIROPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x4f,1,0)
552
553
554	/**
555	* The symbolic link operations.
556	*
557	* @extends RTVFSOBJOPS
558	* @extends RTVFSOBJSETOPS
559	*/
560	typedef struct RTVFSSYMLINKOPS
561	{
562	/** The basic object operation. */
563	RTVFSOBJOPS Obj;
564	/** The structure version (RTVFSSYMLINKOPS_VERSION). */
565	uint32_t uVersion;
566	/** Reserved field, MBZ. */
567	uint32_t fReserved;
568	/** The object setter operations. */
569	RTVFSOBJSETOPS ObjSet;
570
571	/**
572	* Read the symbolic link target.
573	*
574	* @returns IPRT status code.
575	* @param pvThis The implementation specific symbolic link data.
576	* @param pszTarget The target buffer.
577	* @param cbTarget The size of the target buffer.
578	* @sa RTSymlinkRead
579	*/
580	DECLCALLBACKMEMBER(int, pfnRead)(void pvThis, char pszTarget, size_t cbTarget);
581
582	/** Marks the end of the structure (RTVFSSYMLINKOPS_VERSION). */
583	uintptr_t uEndMarker;
584	} RTVFSSYMLINKOPS;
585	/** Pointer to const symbolic link operations. */
586	typedef RTVFSSYMLINKOPS const *PCRTVFSSYMLINKOPS;
587	/** The RTVFSSYMLINKOPS structure version. */
588	#define RTVFSSYMLINKOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x5f,1,0)
589
590
591	/**
592	* Creates a new VFS symlink handle.
593	*
594	* @returns IPRT status code
595	* @param pSymlinkOps The symlink operations.
596	* @param cbInstance The size of the instance data.
597	* @param hVfs The VFS handle to associate this symlink object
598	* with. NIL_VFS is ok.
599	* @param hLock Handle to a custom lock to be used with the new
600	* object. The reference is consumed. NIL and
601	* special lock handles are fine.
602	* @param phVfsSym Where to return the new handle.
603	* @param ppvInstance Where to return the pointer to the instance data
604	* (size is @a cbInstance).
605	*/
606	RTDECL(int) RTVfsNewSymlink(PCRTVFSSYMLINKOPS pSymlinkOps, size_t cbInstance, RTVFS hVfs, RTVFSLOCK hLock,
607	PRTVFSSYMLINK phVfsSym, void **ppvInstance);
608
609
610	/**
611	* The basis for all I/O objects (files, pipes, sockets, devices, ++).
612	*
613	* @extends RTVFSOBJOPS
614	*/
615	typedef struct RTVFSIOSTREAMOPS
616	{
617	/** The basic object operation. */
618	RTVFSOBJOPS Obj;
619	/** The structure version (RTVFSIOSTREAMOPS_VERSION). */
620	uint32_t uVersion;
621	/** Feature field. */
622	uint32_t fFeatures;
623
624	/**
625	* Reads from the file/stream.
626	*
627	* @returns IPRT status code. See RTVfsIoStrmRead.
628	* @param pvThis The implementation specific file data.
629	* @param off Where to read at, -1 for the current position.
630	* @param pSgBuf Gather buffer describing the bytes that are to be
631	* written.
632	* @param fBlocking If @c true, the call is blocking, if @c false it
633	* should not block.
634	* @param pcbRead Where return the number of bytes actually read.
635	* This is set it 0 by the caller. If NULL, try read
636	* all and fail if incomplete.
637	* @sa RTVfsIoStrmRead, RTVfsIoStrmSgRead, RTVfsFileRead,
638	* RTVfsFileReadAt, RTFileRead, RTFileReadAt.
639	*/
640	DECLCALLBACKMEMBER(int, pfnRead)(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead);
641
642	/**
643	* Writes to the file/stream.
644	*
645	* @returns IPRT status code.
646	* @param pvThis The implementation specific file data.
647	* @param off Where to start wrinting, -1 for the current
648	* position.
649	* @param pSgBuf Gather buffers describing the bytes that are to be
650	* written.
651	* @param fBlocking If @c true, the call is blocking, if @c false it
652	* should not block.
653	* @param pcbWritten Where to return the number of bytes actually
654	* written. This is set it 0 by the caller. If
655	* NULL, try write it all and fail if incomplete.
656	* @sa RTFileWrite, RTFileWriteAt.
657	*/
658	DECLCALLBACKMEMBER(int, pfnWrite)(void pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten);
659
660	/**
661	* Flushes any pending data writes to the stream.
662	*
663	* @returns IPRT status code.
664	* @param pvThis The implementation specific file data.
665	* @sa RTFileFlush.
666	*/
667	DECLCALLBACKMEMBER(int, pfnFlush)(void *pvThis);
668
669	/**
670	* Poll for events.
671	*
672	* @returns IPRT status code.
673	* @param pvThis The implementation specific file data.
674	* @param fEvents The events to poll for (RTPOLL_EVT_XXX).
675	* @param cMillies How long to wait for event to eventuate.
676	* @param fIntr Whether the wait is interruptible and can return
677	* VERR_INTERRUPTED (@c true) or if this condition
678	* should be hidden from the caller (@c false).
679	* @param pfRetEvents Where to return the event mask.
680	* @sa RTPollSetAdd, RTPoll, RTPollNoResume.
681	*/
682	DECLCALLBACKMEMBER(int, pfnPollOne)(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
683	uint32_t *pfRetEvents);
684
685	/**
686	* Tells the current file/stream position.
687	*
688	* @returns IPRT status code.
689	* @param pvThis The implementation specific file data.
690	* @param poffActual Where to return the actual offset.
691	* @sa RTFileTell
692	*/
693	DECLCALLBACKMEMBER(int, pfnTell)(void *pvThis, PRTFOFF poffActual);
694
695	/**
696	* Skips @a cb ahead in the stream.
697	*
698	* @returns IPRT status code.
699	* @param pvThis The implementation specific file data.
700	* @param cb The number bytes to skip.
701	* @remarks This is optional and can be NULL.
702	*/
703	DECLCALLBACKMEMBER(int, pfnSkip)(void *pvThis, RTFOFF cb);
704
705	/**
706	* Fills the stream with @a cb zeros.
707	*
708	* @returns IPRT status code.
709	* @param pvThis The implementation specific file data.
710	* @param cb The number of zero bytes to insert.
711	* @remarks This is optional and can be NULL.
712	*/
713	DECLCALLBACKMEMBER(int, pfnZeroFill)(void *pvThis, RTFOFF cb);
714
715	/** Marks the end of the structure (RTVFSIOSTREAMOPS_VERSION). */
716	uintptr_t uEndMarker;
717	} RTVFSIOSTREAMOPS;
718	/** Pointer to const I/O stream operations. */
719	typedef RTVFSIOSTREAMOPS const *PCRTVFSIOSTREAMOPS;
720
721	/** The RTVFSIOSTREAMOPS structure version. */
722	#define RTVFSIOSTREAMOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x6f,1,0)
723
724	/** @name RTVFSIOSTREAMOPS::fFeatures
725	* @{ */
726	/** No scatter gather lists, thank you. */
727	#define RTVFSIOSTREAMOPS_FEAT_NO_SG RT_BIT_32(0)
728	/** Mask of the valid I/O stream feature flags. */
729	#define RTVFSIOSTREAMOPS_FEAT_VALID_MASK UINT32_C(0x00000001)
730	/** @} */
731
732
733	/**
734	* Creates a new VFS I/O stream handle.
735	*
736	* @returns IPRT status code
737	* @param pIoStreamOps The I/O stream operations.
738	* @param cbInstance The size of the instance data.
739	* @param fOpen The open flags. The minimum is the access mask.
740	* @param hVfs The VFS handle to associate this I/O stream
741	* with. NIL_VFS is ok.
742	* @param hLock Handle to a custom lock to be used with the new
743	* object. The reference is consumed. NIL and
744	* special lock handles are fine.
745	* @param phVfsIos Where to return the new handle.
746	* @param ppvInstance Where to return the pointer to the instance data
747	* (size is @a cbInstance).
748	*/
749	RTDECL(int) RTVfsNewIoStream(PCRTVFSIOSTREAMOPS pIoStreamOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
750	PRTVFSIOSTREAM phVfsIos, void **ppvInstance);
751
752
753	/**
754	* Gets the private data of an I/O stream.
755	*
756	* @returns Pointer to the private data. NULL if the handle is invalid in some
757	* way.
758	* @param hVfsIos The I/O stream handle.
759	* @param pIoStreamOps The I/O stream operations. This servers as a
760	* sort of password.
761	*/
762	RTDECL(void *) RTVfsIoStreamToPrivate(RTVFSIOSTREAM hVfsIos, PCRTVFSIOSTREAMOPS pIoStreamOps);
763
764
765	/**
766	* The file operations.
767	*
768	* @extends RTVFSIOSTREAMOPS
769	* @extends RTVFSOBJSETOPS
770	*/
771	typedef struct RTVFSFILEOPS
772	{
773	/** The I/O stream and basis object operations. */
774	RTVFSIOSTREAMOPS Stream;
775	/** The structure version (RTVFSFILEOPS_VERSION). */
776	uint32_t uVersion;
777	/** Reserved field, MBZ. */
778	uint32_t fReserved;
779	/** The object setter operations. */
780	RTVFSOBJSETOPS ObjSet;
781
782	/**
783	* Changes the current file position.
784	*
785	* @returns IPRT status code.
786	* @param pvThis The implementation specific file data.
787	* @param offSeek The offset to seek.
788	* @param uMethod The seek method, i.e. what the seek is relative to.
789	* @param poffActual Where to return the actual offset.
790	* @sa RTFileSeek
791	*/
792	DECLCALLBACKMEMBER(int, pfnSeek)(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual);
793
794	/**
795	* Get the current file/stream size.
796	*
797	* @returns IPRT status code.
798	* @param pvThis The implementation specific file data.
799	* @param pcbFile Where to store the current file size.
800	* @sa RTFileGetSize
801	*/
802	DECLCALLBACKMEMBER(int, pfnQuerySize)(void pvThis, uint64_t pcbFile);
803
804	/** @todo There will be more methods here. */
805
806	/** Marks the end of the structure (RTVFSFILEOPS_VERSION). */
807	uintptr_t uEndMarker;
808	} RTVFSFILEOPS;
809	/** Pointer to const file operations. */
810	typedef RTVFSFILEOPS const *PCRTVFSFILEOPS;
811
812	/** The RTVFSFILEOPS structure version. */
813	#define RTVFSFILEOPS_VERSION RT_MAKE_U32_FROM_U8(0xff,0x7f,1,0)
814
815	/**
816	* Creates a new VFS file handle.
817	*
818	* @returns IPRT status code
819	* @param pFileOps The file operations.
820	* @param cbInstance The size of the instance data.
821	* @param fOpen The open flags. The minimum is the access mask.
822	* @param hVfs The VFS handle to associate this file with.
823	* NIL_VFS is ok.
824	* @param hLock Handle to a custom lock to be used with the new
825	* object. The reference is consumed. NIL and
826	* special lock handles are fine.
827	* @param phVfsFile Where to return the new handle.
828	* @param ppvInstance Where to return the pointer to the instance data
829	* (size is @a cbInstance).
830	*/
831	RTDECL(int) RTVfsNewFile(PCRTVFSFILEOPS pFileOps, size_t cbInstance, uint32_t fOpen, RTVFS hVfs, RTVFSLOCK hLock,
832	PRTVFSFILE phVfsFile, void **ppvInstance);
833
834
835	/** @defgroup grp_rt_vfs_ll_util VFS Utility APIs
836	* @{ */
837
838	/**
839	* Parsed path.
840	*/
841	typedef struct RTVFSPARSEDPATH
842	{
843	/** The length of the path in szCopy. */
844	uint16_t cch;
845	/** The number of path components. */
846	uint16_t cComponents;
847	/** Set if the path ends with slash, indicating that it's a directory
848	* reference and not a file reference. The slash has been removed from
849	* the copy. */
850	bool fDirSlash;
851	/** The offset where each path component starts, i.e. the char after the
852	* slash. The array has cComponents + 1 entries, where the final one is
853	* cch + 1 so that one can always terminate the current component by
854	* szPath[aoffComponent[i] - 1] = '\0'. */
855	uint16_t aoffComponents[RTPATH_MAX / 2 + 1];
856	/** A normalized copy of the path.
857	* Reserve some extra space so we can be more relaxed about overflow
858	* checks and terminator paddings, especially when recursing. */
859	char szPath[RTPATH_MAX];
860	} RTVFSPARSEDPATH;
861	/** Pointer to a parsed path. */
862	typedef RTVFSPARSEDPATH *PRTVFSPARSEDPATH;
863
864	/** The max accepted path length.
865	* This must be a few chars shorter than RTVFSPARSEDPATH::szPath because we
866	* use two terminators and wish be a little bit lazy with checking. */
867	#define RTVFSPARSEDPATH_MAX (RTPATH_MAX - 4)
868
869	/**
870	* Appends @a pszPath (relative) to the already parsed path @a pPath.
871	*
872	* @retval VINF_SUCCESS
873	* @retval VERR_FILENAME_TOO_LONG
874	* @retval VERR_INTERNAL_ERROR_4
875	* @param pPath The parsed path to append @a pszPath onto.
876	* This is both input and output.
877	* @param pszPath The path to append. This must be relative.
878	* @param piRestartComp The component to restart parsing at. This is
879	* input/output. The input does not have to be
880	* within the valid range. Optional.
881	*/
882	RTDECL(int) RTVfsParsePathAppend(PRTVFSPARSEDPATH pPath, const char pszPath, uint16_t piRestartComp);
883
884	/**
885	* Parses a path.
886	*
887	* @retval VINF_SUCCESS
888	* @retval VERR_FILENAME_TOO_LONG
889	* @param pPath Where to store the parsed path.
890	* @param pszPath The path to parse. Absolute or relative to @a
891	* pszCwd.
892	* @param pszCwd The current working directory. Must be
893	* absolute.
894	*/
895	RTDECL(int) RTVfsParsePath(PRTVFSPARSEDPATH pPath, const char pszPath, const char pszCwd);
896
897	/**
898	* Same as RTVfsParsePath except that it allocates a temporary buffer.
899	*
900	* @retval VINF_SUCCESS
901	* @retval VERR_NO_TMP_MEMORY
902	* @retval VERR_FILENAME_TOO_LONG
903	* @param pszPath The path to parse. Absolute or relative to @a
904	* pszCwd.
905	* @param pszCwd The current working directory. Must be
906	* absolute.
907	* @param ppPath Where to store the pointer to the allocated
908	* buffer containing the parsed path. This must
909	* be freed by calling RTVfsParsePathFree. NULL
910	* will be stored on failured.
911	*/
912	RTDECL(int) RTVfsParsePathA(const char pszPath, const char pszCwd, PRTVFSPARSEDPATH *ppPath);
913
914	/**
915	* Frees a buffer returned by RTVfsParsePathA.
916	*
917	* @param pPath The parsed path buffer to free. NULL is fine.
918	*/
919	RTDECL(void) RTVfsParsePathFree(PRTVFSPARSEDPATH pPath);
920
921	/**
922	* Dummy implementation of RTVFSIOSTREAMOPS::pfnPollOne.
923	*
924	* This handles the case where there is no chance any events my be raised and
925	* all that is required is to wait according to the parameters.
926	*
927	* @returns IPRT status code.
928	* @param pvThis The implementation specific file data.
929	* @param fEvents The events to poll for (RTPOLL_EVT_XXX).
930	* @param cMillies How long to wait for event to eventuate.
931	* @param fIntr Whether the wait is interruptible and can return
932	* VERR_INTERRUPTED (@c true) or if this condition
933	* should be hidden from the caller (@c false).
934	* @param pfRetEvents Where to return the event mask.
935	* @sa RTVFSIOSTREAMOPS::pfnPollOne, RTPollSetAdd, RTPoll, RTPollNoResume.
936	*/
937	RTDECL(int) RTVfsUtilDummyPollOne(uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, uint32_t *pfRetEvents);
938
939	/** @} */
940
941
942	/** @defgroup grp_rt_vfs_lowlevel_chain VFS Chains
943	* @ref grp_rt_vfs_chain
944	* @{
945	*/
946
947
948	/**
949	* Chain element input actions.
950	*/
951	typedef enum RTVFSCHAINACTION
952	{
953	/** Invalid action. */
954	RTVFSCHAINACTION_INVALID = 0,
955	/** No action (start of the chain). */
956	RTVFSCHAINACTION_NONE,
957	/** Passive filtering (expressed by pipe symbol). */
958	RTVFSCHAINACTION_PASSIVE,
959	/** Push filtering (expressed by redirection-out symbol). */
960	RTVFSCHAINACTION_PUSH,
961	/** The end of the valid actions. */
962	RTVFSCHAINACTION_END,
963	/** Make sure it's a 32-bit type. */
964	RTVFSCHAINACTION_32BIT_HACK = 0x7fffffff
965	} RTVFSCHAINACTION;
966
967
968	/**
969	* VFS chain element specification.
970	*/
971	typedef struct RTVFSCHAINELEMSPEC
972	{
973	/** The provider name. */
974	char *pszProvider;
975	/** The input type. */
976	RTVFSOBJTYPE enmTypeIn;
977	/** The output type. */
978	RTVFSOBJTYPE enmTypeOut;
979	/** The action to take (or not). */
980	RTVFSCHAINACTION enmAction;
981	/** The number of arguments. */
982	uint32_t cArgs;
983	/** Arguments. */
984	char **papszArgs;
985	} RTVFSCHAINELEMSPEC;
986	/** Pointer to a chain element specification. */
987	typedef RTVFSCHAINELEMSPEC *PRTVFSCHAINELEMSPEC;
988	/** Pointer to a const chain element specification. */
989	typedef RTVFSCHAINELEMSPEC const *PCRTVFSCHAINELEMSPEC;
990
991
992	/**
993	* Parsed VFS chain specification.
994	*/
995	typedef struct RTVFSCHAINSPEC
996	{
997	/** The action element, UINT32_MAX if none.
998	* Currently we only support one action element (RTVFSCHAINACTION_PASSIVE
999	* is not considered). */
1000	uint32_t iActionElement;
1001	/** The number of elements. */
1002	uint32_t cElements;
1003	/** The elements. */
1004	PRTVFSCHAINELEMSPEC paElements;
1005	} RTVFSCHAINSPEC;
1006	/** Pointer to a parsed VFS chain specification. */
1007	typedef RTVFSCHAINSPEC *PRTVFSCHAINSPEC;
1008	/** Pointer to a const, parsed VFS chain specification. */
1009	typedef RTVFSCHAINSPEC const *PCRTVFSCHAINSPEC;
1010
1011
1012	/**
1013	* A chain element provider registration record.
1014	*/
1015	typedef struct RTVFSCHAINELEMENTREG
1016	{
1017	/** The version (RTVFSCHAINELEMENTREG_VERSION). */
1018	uint32_t uVersion;
1019	/** Reserved, MBZ. */
1020	uint32_t fReserved;
1021	/** The provider name (unique). */
1022	const char *pszName;
1023	/** For chaining the providers. */
1024	RTLISTNODE ListEntry;
1025
1026	/**
1027	* Create a VFS from the given chain element specficiation.
1028	*
1029	* @returns IPRT status code.
1030	* @param pSpec The chain element specification.
1031	* @param phVfs Where to returned the VFS handle.
1032	*/
1033	DECLCALLBACKMEMBER(int, pfnOpenVfs)( PCRTVFSCHAINELEMSPEC pSpec, PRTVFS phVfs);
1034
1035	/**
1036	* Open a directory from the given chain element specficiation.
1037	*
1038	* @returns IPRT status code.
1039	* @param pSpec The chain element specification.
1040	* @param phVfsDir Where to returned the directory handle.
1041	*/
1042	DECLCALLBACKMEMBER(int, pfnOpenDir)( PCRTVFSCHAINELEMSPEC pSpec, PRTVFSDIR phVfsDir);
1043
1044	/**
1045	* Open a file from the given chain element specficiation.
1046	*
1047	* @returns IPRT status code.
1048	* @param pSpec The chain element specification.
1049	* @param fOpen The open flag. Can be zero and the
1050	* specification may modify it.
1051	* @param phVfsFile Where to returned the file handle.
1052	*/
1053	DECLCALLBACKMEMBER(int, pfnOpenFile)( PCRTVFSCHAINELEMSPEC pSpec, uint32_t fOpen, PRTVFSFILE phVfsFile);
1054
1055	/**
1056	* Open a symlink from the given chain element specficiation.
1057	*
1058	* @returns IPRT status code.
1059	* @param pSpec The chain element specification.
1060	* @param phVfsSym Where to returned the symlink handle.
1061	*/
1062	DECLCALLBACKMEMBER(int, pfnOpenSymlink)( PCRTVFSCHAINELEMSPEC pSpec, PRTVFSSYMLINK phVfsSym);
1063
1064	/**
1065	* Open a I/O stream from the given chain element specficiation.
1066	*
1067	* @returns IPRT status code.
1068	* @param pSpec The chain element specification.
1069	* @param fOpen The open flag. Can be zero and the
1070	* specification may modify it.
1071	* @param phVfsIos Where to returned the I/O stream handle.
1072	*/
1073	DECLCALLBACKMEMBER(int, pfnOpenIoStream)(PCRTVFSCHAINELEMSPEC pSpec, uint32_t fOpen, PRTVFSIOSTREAM phVfsIos);
1074
1075	/**
1076	* Open a filesystem stream from the given chain element specficiation.
1077	*
1078	* @returns IPRT status code.
1079	* @param pSpec The chain element specification.
1080	* @param phVfsFss Where to returned the filesystem stream handle.
1081	*/
1082	DECLCALLBACKMEMBER(int, pfnOpenFsStream)(PCRTVFSCHAINELEMSPEC pSpec, PRTVFSFSSTREAM phVfsFss);
1083
1084	/** End marker (RTVFSCHAINELEMENTREG_VERSION). */
1085	uintptr_t uEndMarker;
1086	} RTVFSCHAINELEMENTREG;
1087	/** Pointer to a VFS chain element registration record. */
1088	typedef RTVFSCHAINELEMENTREG *PRTVFSCHAINELEMENTREG;
1089	/** Pointer to a const VFS chain element registration record. */
1090	typedef RTVFSCHAINELEMENTREG const *PCRTVFSCHAINELEMENTREG;
1091
1092	/** The VFS chain element registration record version number. */
1093	#define RTVFSCHAINELEMENTREG_VERSION RT_MAKE_U32_FROM_U8(0xff, 0x7f, 1, 0)
1094
1095
1096	/**
1097	* Parses the specification.
1098	*
1099	* @returns IPRT status code.
1100	* @param pszSpec The specification string to parse.
1101	* @param fFlags Flags, see RTVFSCHAIN_PF_XXX.
1102	* @param enmLeadingAction The only allowed leading action type.
1103	* @param enmTrailingAction The only allowed trailing action type.
1104	* @param ppSpec Where to return the pointer to the parsed
1105	* specification. This must be freed by calling
1106	* RTVfsChainSpecFree. Will always be set (unless
1107	* invalid parameters.)
1108	* @param ppszError On failure, this will point at the error
1109	* location in @a pszSpec. Optional.
1110	*/
1111	RTDECL(int) RTVfsChainSpecParse(const char *pszSpec, uint32_t fFlags, RTVFSCHAINACTION enmLeadingAction,
1112	RTVFSCHAINACTION enmTrailingAction,
1113	PRTVFSCHAINSPEC ppSpec, const char *ppszError);
1114
1115	/** @name RTVfsChainSpecParse
1116	* @{ */
1117	/** No real action is permitted, i.e. only passive filtering (aka pipe). */
1118	#define RTVFSCHAIN_PF_NO_REAL_ACTION RT_BIT_32(0)
1119	/** The specified leading action is optional. */
1120	#define RTVFSCHAIN_PF_LEADING_ACTION_OPTIONAL RT_BIT_32(1)
1121	/** The specified trailing action is optional. */
1122	#define RTVFSCHAIN_PF_TRAILING_ACTION_OPTIONAL RT_BIT_32(2)
1123	/** Mask of valid flags. */
1124	#define RTVFSCHAIN_PF_VALID_MASK UINT32_C(0x00000007)
1125	/** @}*/
1126
1127	/**
1128	* Frees a parsed chain specification.
1129	*
1130	* @param pSpec What RTVfsChainSpecParse returned. NULL is
1131	* quietly ignored.
1132	*/
1133	RTDECL(void) RTVfsChainSpecFree(PRTVFSCHAINSPEC pSpec);
1134
1135	/**
1136	* Registers a chain element provider.
1137	*
1138	* @returns IPRT status code
1139	* @param pRegRec The registration record.
1140	* @param fFromCtor Indicates where we're called from.
1141	*/
1142	RTDECL(int) RTVfsChainElementRegisterProvider(PRTVFSCHAINELEMENTREG pRegRec, bool fFromCtor);
1143
1144	/**
1145	* Deregisters a chain element provider.
1146	*
1147	* @returns IPRT status code
1148	* @param pRegRec The registration record.
1149	* @param fFromDtor Indicates where we're called from.
1150	*/
1151	RTDECL(int) RTVfsChainElementDeregisterProvider(PRTVFSCHAINELEMENTREG pRegRec, bool fFromDtor);
1152
1153
1154	/** @def RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER
1155	* Automatically registers a chain element provider using a global constructor
1156	* and destructor hack.
1157	*
1158	* @param pRegRec Pointer to the registration record.
1159	* @param name Some unique variable name prefix.
1160	*/
1161
1162	#ifdef __cplusplus
1163	/**
1164	* Class used for registering a VFS chain element provider.
1165	*/
1166	class RTVfsChainElementAutoRegisterHack
1167	{
1168	private:
1169	/** The registration record, NULL if registration failed. */
1170	PRTVFSCHAINELEMENTREG m_pRegRec;
1171
1172	public:
1173	RTVfsChainElementAutoRegisterHack(PRTVFSCHAINELEMENTREG a_pRegRec)
1174	: m_pRegRec(a_pRegRec)
1175	{
1176	int rc = RTVfsChainElementRegisterProvider(m_pRegRec, true);
1177	if (RT_FAILURE(rc))
1178	m_pRegRec = NULL;
1179	}
1180
1181	~RTVfsChainElementAutoRegisterHack()
1182	{
1183	RTVfsChainElementDeregisterProvider(m_pRegRec, true);
1184	m_pRegRec = NULL;
1185	}
1186	};
1187
1188	# define RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(pRegRec, name) \
1189	static RTVfsChainElementAutoRegisterHack name ## AutoRegistrationHack(pRegRec)
1190
1191	#else
1192	# define RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(pRegRec, name) \
1193	extern void *name ## AutoRegistrationHack = \
1194	&Sorry_but_RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER_does_not_work_in_c_source_files
1195	#endif
1196
1197
1198	/** @} */
1199
1200
1201	/** @} */
1202
1203	RT_C_DECLS_END
1204
1205	#endif /* !___iprt_vfslowlevel_h */
1206

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

source: vbox/trunk/include/iprt/vfslowlevel.h@ 36555

Download in other formats: