Context Navigation

source: rtems-libbsd/freebsd/sys/sys/vnode.h @ 66659ff

4.1155-freebsd-126-freebsd-12freebsd-9.3

Last change on this file since 66659ff was 66659ff, checked in by Sebastian Huber <sebastian.huber@…>, on 11/06/13 at 15:20:21
Update to FreeBSD 9.2
Property mode set to `100644`
File size: 30.2 KB

Line
1	/*-
2	* Copyright (c) 1989, 1993
3	* The Regents of the University of California. All rights reserved.
4	*
5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions
7	* are met:
8	* 1. Redistributions of source code must retain the above copyright
9	* notice, this list of conditions and the following disclaimer.
10	* 2. Redistributions in binary form must reproduce the above copyright
11	* notice, this list of conditions and the following disclaimer in the
12	* documentation and/or other materials provided with the distribution.
13	* 4. Neither the name of the University nor the names of its contributors
14	* may be used to endorse or promote products derived from this software
15	* without specific prior written permission.
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27	* SUCH DAMAGE.
28	*
29	* @(#)vnode.h 8.7 (Berkeley) 2/4/94
30	* $FreeBSD$
31	*/
32
33	#ifndef _SYS_VNODE_H_
34	#define _SYS_VNODE_H_
35
36	#include <sys/bufobj.h>
37	#include <sys/queue.h>
38	#include <rtems/bsd/sys/lock.h>
39	#include <sys/lockmgr.h>
40	#include <sys/mutex.h>
41	#include <sys/rangelock.h>
42	#include <sys/selinfo.h>
43	#include <sys/uio.h>
44	#include <sys/acl.h>
45	#include <sys/ktr.h>
46
47	#ifndef __rtems__
48	/*
49	* The vnode is the focus of all file activity in UNIX. There is a
50	* unique vnode allocated for each active file, each current directory,
51	* each mounted-on file, text file, and the root.
52	*/
53
54	/*
55	* Vnode types. VNON means no type.
56	*/
57	enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD,
58	VMARKER };
59
60	/*
61	* Each underlying filesystem allocates its own private area and hangs
62	* it from v_data. If non-null, this area is freed in getnewvnode().
63	*/
64
65	struct namecache;
66
67	struct vpollinfo {
68	struct mtx vpi_lock; /* lock to protect below */
69	struct selinfo vpi_selinfo; /* identity of poller(s) */
70	short vpi_events; /* what they are looking for */
71	short vpi_revents; /* what has happened */
72	};
73
74	/*
75	* Reading or writing any of these items requires holding the appropriate lock.
76	*
77	* Lock reference:
78	* c - namecache mutex
79	* f - freelist mutex
80	* i - interlock
81	* m - mount point interlock
82	* p - pollinfo lock
83	* u - Only a reference to the vnode is needed to read.
84	* v - vnode lock
85	*
86	* Vnodes may be found on many lists. The general way to deal with operating
87	* on a vnode that is on a list is:
88	* 1) Lock the list and find the vnode.
89	* 2) Lock interlock so that the vnode does not go away.
90	* 3) Unlock the list to avoid lock order reversals.
91	* 4) vget with LK_INTERLOCK and check for ENOENT, or
92	* 5) Check for DOOMED if the vnode lock is not required.
93	* 6) Perform your operation, then vput().
94	*/
95
96	#if defined(_KERNEL) \|\| defined(_KVM_VNODE)
97
98	struct vnode {
99	/*
100	* Fields which define the identity of the vnode. These fields are
101	* owned by the filesystem (XXX: and vgone() ?)
102	*/
103	enum vtype v_type; /* u vnode type */
104	const char v_tag; / u type of underlying data */
105	struct vop_vector v_op; / u vnode operations vector */
106	void v_data; / u private data for fs */
107
108	/*
109	* Filesystem instance stuff
110	*/
111	struct mount v_mount; / u ptr to vfs we are in */
112	TAILQ_ENTRY(vnode) v_nmntvnodes; /* m vnodes for mount point */
113
114	/*
115	* Type specific fields, only one applies to any given vnode.
116	* See #defines below for renaming to v_* namespace.
117	*/
118	union {
119	struct mount vu_mount; / v ptr to mountpoint (VDIR) */
120	struct socket vu_socket; / v unix domain net (VSOCK) */
121	struct cdev vu_cdev; / v device (VCHR, VBLK) */
122	struct fifoinfo vu_fifoinfo; / v fifo (VFIFO) */
123	} v_un;
124
125	/*
126	* vfs_hash: (mount + inode) -> vnode hash.
127	*/
128	LIST_ENTRY(vnode) v_hashlist;
129	u_int v_hash;
130
131	/*
132	* VFS_namecache stuff
133	*/
134	LIST_HEAD(, namecache) v_cache_src; /* c Cache entries from us */
135	TAILQ_HEAD(, namecache) v_cache_dst; /* c Cache entries to us */
136	struct namecache v_cache_dd; / c Cache entry for .. vnode */
137
138	/*
139	* clustering stuff
140	*/
141	daddr_t v_cstart; /* v start block of cluster */
142	daddr_t v_lasta; /* v last allocation */
143	daddr_t v_lastw; /* v last write */
144	int v_clen; /* v length of cur. cluster */
145
146	/*
147	* Locking
148	*/
149	struct lock v_lock; /* u (if fs don't have one) */
150	struct mtx v_interlock; /* lock for "i" things */
151	struct lock v_vnlock; / u pointer to vnode lock */
152	int v_holdcnt; /* i prevents recycling. */
153	int v_usecount; /* i ref count of users */
154	u_long v_iflag; /* i vnode flags (see below) */
155	u_long v_vflag; /* v vnode flags */
156	int v_writecount; /* v ref count of writers */
157
158	/*
159	* The machinery of being a vnode
160	*/
161	TAILQ_ENTRY(vnode) v_actfreelist; /* f vnode active/free lists */
162	struct bufobj v_bufobj; /* * Buffer cache object */
163
164	/*
165	* Hooks for various subsystems and features.
166	*/
167	struct vpollinfo v_pollinfo; / i Poll events, p for v_pi /
168	struct label v_label; / MAC label for vnode */
169	struct lockf v_lockf; / Byte-level advisory lock list */
170	struct rangelock v_rl; /* Byte-range lock */
171	};
172
173	#endif /* defined(_KERNEL) \|\| defined(_KVM_VNODE) */
174
175	#define v_mountedhere v_un.vu_mount
176	#define v_socket v_un.vu_socket
177	#define v_rdev v_un.vu_cdev
178	#define v_fifoinfo v_un.vu_fifoinfo
179
180	/* XXX: These are temporary to avoid a source sweep at this time */
181	#define v_object v_bufobj.bo_object
182
183	/*
184	* Userland version of struct vnode, for sysctl.
185	*/
186	struct xvnode {
187	size_t xv_size; /* sizeof(struct xvnode) */
188	void xv_vnode; / address of real vnode */
189	u_long xv_flag; /* vnode vflags */
190	int xv_usecount; /* reference count of users */
191	int xv_writecount; /* reference count of writers */
192	int xv_holdcnt; /* page & buffer references */
193	u_long xv_id; /* capability identifier */
194	void xv_mount; / address of parent mount */
195	long xv_numoutput; /* num of writes in progress */
196	enum vtype xv_type; /* vnode type */
197	union {
198	void xvu_socket; / socket, if VSOCK */
199	void xvu_fifo; / fifo, if VFIFO */
200	dev_t xvu_rdev; /* maj/min, if VBLK/VCHR */
201	struct {
202	dev_t xvu_dev; /* device, if VDIR/VREG/VLNK */
203	ino_t xvu_ino; /* id, if VDIR/VREG/VLNK */
204	} xv_uns;
205	} xv_un;
206	};
207	#define xv_socket xv_un.xvu_socket
208	#define xv_fifo xv_un.xvu_fifo
209	#define xv_rdev xv_un.xvu_rdev
210	#define xv_dev xv_un.xv_uns.xvu_dev
211	#define xv_ino xv_un.xv_uns.xvu_ino
212
213	/* We don't need to lock the knlist */
214	#define VN_KNLIST_EMPTY(vp) ((vp)->v_pollinfo == NULL \|\| \
215	KNLIST_EMPTY(&(vp)->v_pollinfo->vpi_selinfo.si_note))
216
217	#define VN_KNOTE(vp, b, a) \
218	do { \
219	if (!VN_KNLIST_EMPTY(vp)) \
220	KNOTE(&vp->v_pollinfo->vpi_selinfo.si_note, (b), \
221	(a) \| KNF_NOKQLOCK); \
222	} while (0)
223	#define VN_KNOTE_LOCKED(vp, b) VN_KNOTE(vp, b, KNF_LISTLOCKED)
224	#define VN_KNOTE_UNLOCKED(vp, b) VN_KNOTE(vp, b, 0)
225
226	/*
227	* Vnode flags.
228	* VI flags are protected by interlock and live in v_iflag
229	* VV flags are protected by the vnode lock and live in v_vflag
230	*
231	* VI_DOOMED is doubly protected by the interlock and vnode lock. Both
232	* are required for writing but the status may be checked with either.
233	*/
234	#define VI_MOUNT 0x0020 /* Mount in progress */
235	#define VI_AGE 0x0040 /* Insert vnode at head of free list */
236	#define VI_DOOMED 0x0080 /* This vnode is being recycled */
237	#define VI_FREE 0x0100 /* This vnode is on the freelist */
238	#define VI_ACTIVE 0x0200 /* This vnode is on the active list */
239	#define VI_DOINGINACT 0x0800 /* VOP_INACTIVE is in progress */
240	#define VI_OWEINACT 0x1000 /* Need to call inactive */
241
242	#define VV_ROOT 0x0001 /* root of its filesystem */
243	#define VV_ISTTY 0x0002 /* vnode represents a tty */
244	#define VV_NOSYNC 0x0004 /* unlinked, stop syncing */
245	#define VV_ETERNALDEV 0x0008 /* device that is never destroyed */
246	#define VV_CACHEDLABEL 0x0010 /* Vnode has valid cached MAC label */
247	#define VV_TEXT 0x0020 /* vnode is a pure text prototype */
248	#define VV_COPYONWRITE 0x0040 /* vnode is doing copy-on-write */
249	#define VV_SYSTEM 0x0080 /* vnode being used by kernel */
250	#define VV_PROCDEP 0x0100 /* vnode is process dependent */
251	#define VV_NOKNOTE 0x0200 /* don't activate knotes on this vnode */
252	#define VV_DELETED 0x0400 /* should be removed */
253	#define VV_MD 0x0800 /* vnode backs the md device */
254	#define VV_FORCEINSMQ 0x1000 /* force the insmntque to succeed */
255
256	/*
257	* Vnode attributes. A field value of VNOVAL represents a field whose value
258	* is unavailable (getattr) or which is not to be changed (setattr).
259	*/
260	struct vattr {
261	enum vtype va_type; /* vnode type (for create) */
262	u_short va_mode; /* files access mode and type */
263	short va_nlink; /* number of references to file */
264	uid_t va_uid; /* owner user id */
265	gid_t va_gid; /* owner group id */
266	dev_t va_fsid; /* filesystem id */
267	long va_fileid; /* file id */
268	u_quad_t va_size; /* file size in bytes */
269	long va_blocksize; /* blocksize preferred for i/o */
270	struct timespec va_atime; /* time of last access */
271	struct timespec va_mtime; /* time of last modification */
272	struct timespec va_ctime; /* time file changed */
273	struct timespec va_birthtime; /* time file created */
274	u_long va_gen; /* generation number of file */
275	u_long va_flags; /* flags defined for file */
276	dev_t va_rdev; /* device the special file represents */
277	u_quad_t va_bytes; /* bytes of disk space held by file */
278	u_quad_t va_filerev; /* file modification number */
279	u_int va_vaflags; /* operations flags, see below */
280	long va_spare; /* remain quad aligned */
281	};
282
283	/*
284	* Flags for va_vaflags.
285	*/
286	#define VA_UTIMES_NULL 0x01 /* utimes argument was NULL */
287	#define VA_EXCLUSIVE 0x02 /* exclusive create request */
288
289	/*
290	* Flags for ioflag. (high 16 bits used to ask for read-ahead and
291	* help with write clustering)
292	* NB: IO_NDELAY and IO_DIRECT are linked to fcntl.h
293	*/
294	#define IO_UNIT 0x0001 /* do I/O as atomic unit */
295	#define IO_APPEND 0x0002 /* append write to end */
296	#define IO_NDELAY 0x0004 /* FNDELAY flag set in file table */
297	#define IO_NODELOCKED 0x0008 /* underlying node already locked */
298	#define IO_ASYNC 0x0010 /* bawrite rather then bdwrite */
299	#define IO_VMIO 0x0020 /* data already in VMIO space */
300	#define IO_INVAL 0x0040 /* invalidate after I/O */
301	#define IO_SYNC 0x0080 /* do I/O synchronously */
302	#define IO_DIRECT 0x0100 /* attempt to bypass buffer cache */
303	#define IO_EXT 0x0400 /* operate on external attributes */
304	#define IO_NORMAL 0x0800 /* operate on regular data */
305	#define IO_NOMACCHECK 0x1000 /* MAC checks unnecessary */
306	#define IO_BUFLOCKED 0x2000 /* ffs flag; indir buf is locked */
307
308	#define IO_SEQMAX 0x7F /* seq heuristic max value */
309	#define IO_SEQSHIFT 16 /* seq heuristic in upper 16 bits */
310
311	/*
312	* Flags for accmode_t.
313	*/
314	#define VEXEC 000000000100 /* execute/search permission */
315	#define VWRITE 000000000200 /* write permission */
316	#define VREAD 000000000400 /* read permission */
317	#define VADMIN 000000010000 /* being the file owner */
318	#define VAPPEND 000000040000 /* permission to write/append */
319	/*
320	* VEXPLICIT_DENY makes VOP_ACCESSX(9) return EPERM or EACCES only
321	* if permission was denied explicitly, by a "deny" rule in NFSv4 ACL,
322	* and 0 otherwise. This never happens with ordinary unix access rights
323	* or POSIX.1e ACLs. Obviously, VEXPLICIT_DENY must be OR-ed with
324	* some other V* constant.
325	*/
326	#define VEXPLICIT_DENY 000000100000
327	#define VREAD_NAMED_ATTRS 000000200000 /* not used */
328	#define VWRITE_NAMED_ATTRS 000000400000 /* not used */
329	#define VDELETE_CHILD 000001000000
330	#define VREAD_ATTRIBUTES 000002000000 /* permission to stat(2) */
331	#define VWRITE_ATTRIBUTES 000004000000 /* change {m,c,a}time */
332	#define VDELETE 000010000000
333	#define VREAD_ACL 000020000000 /* read ACL and file mode */
334	#define VWRITE_ACL 000040000000 /* change ACL and/or file mode */
335	#define VWRITE_OWNER 000100000000 /* change file owner */
336	#define VSYNCHRONIZE 000200000000 /* not used */
337
338	/*
339	* Permissions that were traditionally granted only to the file owner.
340	*/
341	#define VADMIN_PERMS (VADMIN \| VWRITE_ATTRIBUTES \| VWRITE_ACL \| \
342	VWRITE_OWNER)
343
344	/*
345	* Permissions that were traditionally granted to everyone.
346	*/
347	#define VSTAT_PERMS (VREAD_ATTRIBUTES \| VREAD_ACL)
348
349	/*
350	* Permissions that allow to change the state of the file in any way.
351	*/
352	#define VMODIFY_PERMS (VWRITE \| VAPPEND \| VADMIN_PERMS \| VDELETE_CHILD \| \
353	VDELETE)
354
355	/*
356	* Token indicating no attribute value yet assigned.
357	*/
358	#define VNOVAL (-1)
359
360	/*
361	* LK_TIMELOCK timeout for vnode locks (used mainly by the pageout daemon)
362	*/
363	#define VLKTIMEOUT (hz / 20 + 1)
364
365	#ifdef _KERNEL
366
367	#ifdef MALLOC_DECLARE
368	MALLOC_DECLARE(M_VNODE);
369	#endif
370
371	/*
372	* Convert between vnode types and inode formats (since POSIX.1
373	* defines mode word of stat structure in terms of inode formats).
374	*/
375	extern enum vtype iftovt_tab[];
376	extern int vttoif_tab[];
377	#define IFTOVT(mode) (iftovt_tab[((mode) & S_IFMT) >> 12])
378	#define VTTOIF(indx) (vttoif_tab[(int)(indx)])
379	#define MAKEIMODE(indx, mode) (int)(VTTOIF(indx) \| (mode))
380
381	/*
382	* Flags to various vnode functions.
383	*/
384	#define SKIPSYSTEM 0x0001 /* vflush: skip vnodes marked VSYSTEM */
385	#define FORCECLOSE 0x0002 /* vflush: force file closure */
386	#define WRITECLOSE 0x0004 /* vflush: only close writable files */
387	#define EARLYFLUSH 0x0008 /* vflush: early call for ffs_flushfiles */
388	#define V_SAVE 0x0001 /* vinvalbuf: sync file first */
389	#define V_ALT 0x0002 /* vinvalbuf: invalidate only alternate bufs */
390	#define V_NORMAL 0x0004 /* vinvalbuf: invalidate only regular bufs */
391	#define V_CLEANONLY 0x0008 /* vinvalbuf: invalidate only clean bufs */
392	#define REVOKEALL 0x0001 /* vop_revoke: revoke all aliases */
393	#define V_WAIT 0x0001 /* vn_start_write: sleep for suspend */
394	#define V_NOWAIT 0x0002 /* vn_start_write: don't sleep for suspend */
395	#define V_XSLEEP 0x0004 /* vn_start_write: just return after sleep */
396
397	#define VR_START_WRITE 0x0001 /* vfs_write_resume: start write atomically */
398	#define VR_NO_SUSPCLR 0x0002 /* vfs_write_resume: do not clear suspension */
399
400	#define VREF(vp) vref(vp)
401
402	#ifdef DIAGNOSTIC
403	#define VATTR_NULL(vap) vattr_null(vap)
404	#else
405	#define VATTR_NULL(vap) ((vap) = va_null) / initialize a vattr */
406	#endif /* DIAGNOSTIC */
407
408	#define NULLVP ((struct vnode *)NULL)
409
410	/*
411	* Global vnode data.
412	*/
413	extern struct vnode rootvnode; / root (i.e. "/") vnode */
414	extern int async_io_version; /* 0 or POSIX version of AIO i'face */
415	extern int desiredvnodes; /* number of vnodes desired */
416	extern struct uma_zone *namei_zone;
417	extern struct vattr va_null; /* predefined null vattr structure */
418
419	#define VI_LOCK(vp) mtx_lock(&(vp)->v_interlock)
420	#define VI_LOCK_FLAGS(vp, flags) mtx_lock_flags(&(vp)->v_interlock, (flags))
421	#define VI_TRYLOCK(vp) mtx_trylock(&(vp)->v_interlock)
422	#define VI_UNLOCK(vp) mtx_unlock(&(vp)->v_interlock)
423	#define VI_MTX(vp) (&(vp)->v_interlock)
424
425	#define VN_LOCK_AREC(vp) lockallowrecurse((vp)->v_vnlock)
426	#define VN_LOCK_ASHARE(vp) lockallowshare((vp)->v_vnlock)
427
428	#endif /* _KERNEL */
429
430	/*
431	* Mods for extensibility.
432	*/
433
434	/*
435	* Flags for vdesc_flags:
436	*/
437	#define VDESC_MAX_VPS 16
438	/* Low order 16 flag bits are reserved for willrele flags for vp arguments. */
439	#define VDESC_VP0_WILLRELE 0x0001
440	#define VDESC_VP1_WILLRELE 0x0002
441	#define VDESC_VP2_WILLRELE 0x0004
442	#define VDESC_VP3_WILLRELE 0x0008
443	#define VDESC_NOMAP_VPP 0x0100
444	#define VDESC_VPP_WILLRELE 0x0200
445
446	/*
447	* A generic structure.
448	* This can be used by bypass routines to identify generic arguments.
449	*/
450	struct vop_generic_args {
451	struct vnodeop_desc *a_desc;
452	/* other random data follows, presumably */
453	};
454
455	typedef int vop_bypass_t(struct vop_generic_args *);
456
457	/*
458	* VDESC_NO_OFFSET is used to identify the end of the offset list
459	* and in places where no such field exists.
460	*/
461	#define VDESC_NO_OFFSET -1
462
463	/*
464	* This structure describes the vnode operation taking place.
465	*/
466	struct vnodeop_desc {
467	char vdesc_name; / a readable name for debugging */
468	int vdesc_flags; /* VDESC_* flags */
469	vop_bypass_t vdesc_call; / Function to call */
470
471	/*
472	* These ops are used by bypass routines to map and locate arguments.
473	* Creds and procs are not needed in bypass routines, but sometimes
474	* they are useful to (for example) transport layers.
475	* Nameidata is useful because it has a cred in it.
476	*/
477	int vdesc_vp_offsets; / list ended by VDESC_NO_OFFSET */
478	int vdesc_vpp_offset; /* return vpp location */
479	int vdesc_cred_offset; /* cred location, if any */
480	int vdesc_thread_offset; /* thread location, if any */
481	int vdesc_componentname_offset; /* if any */
482	};
483
484	#ifdef _KERNEL
485	/*
486	* A list of all the operation descs.
487	*/
488	extern struct vnodeop_desc *vnodeop_descs[];
489
490	#define VOPARG_OFFSETOF(s_type, field) __offsetof(s_type, field)
491	#define VOPARG_OFFSETTO(s_type, s_offset, struct_p) \
492	((s_type)(((char*)(struct_p)) + (s_offset)))
493
494
495	#ifdef DEBUG_VFS_LOCKS
496	/*
497	* Support code to aid in debugging VFS locking problems. Not totally
498	* reliable since if the thread sleeps between changing the lock
499	* state and checking it with the assert, some other thread could
500	* change the state. They are good enough for debugging a single
501	* filesystem using a single-threaded test.
502	*/
503	void assert_vi_locked(struct vnode vp, const char str);
504	void assert_vi_unlocked(struct vnode vp, const char str);
505	void assert_vop_elocked(struct vnode vp, const char str);
506	#if 0
507	void assert_vop_elocked_other(struct vnode vp, const char str);
508	#endif
509	void assert_vop_locked(struct vnode vp, const char str);
510	#if 0
511	voi0 assert_vop_slocked(struct vnode vp, const char str);
512	#endif
513	void assert_vop_unlocked(struct vnode vp, const char str);
514
515	#define ASSERT_VI_LOCKED(vp, str) assert_vi_locked((vp), (str))
516	#define ASSERT_VI_UNLOCKED(vp, str) assert_vi_unlocked((vp), (str))
517	#define ASSERT_VOP_ELOCKED(vp, str) assert_vop_elocked((vp), (str))
518	#if 0
519	#define ASSERT_VOP_ELOCKED_OTHER(vp, str) assert_vop_locked_other((vp), (str))
520	#endif
521	#define ASSERT_VOP_LOCKED(vp, str) assert_vop_locked((vp), (str))
522	#if 0
523	#define ASSERT_VOP_SLOCKED(vp, str) assert_vop_slocked((vp), (str))
524	#endif
525	#define ASSERT_VOP_UNLOCKED(vp, str) assert_vop_unlocked((vp), (str))
526
527	#else /* !DEBUG_VFS_LOCKS */
528
529	#define ASSERT_VI_LOCKED(vp, str) ((void)0)
530	#define ASSERT_VI_UNLOCKED(vp, str) ((void)0)
531	#define ASSERT_VOP_ELOCKED(vp, str) ((void)0)
532	#if 0
533	#define ASSERT_VOP_ELOCKED_OTHER(vp, str)
534	#endif
535	#define ASSERT_VOP_LOCKED(vp, str) ((void)0)
536	#if 0
537	#define ASSERT_VOP_SLOCKED(vp, str)
538	#endif
539	#define ASSERT_VOP_UNLOCKED(vp, str) ((void)0)
540	#endif /* DEBUG_VFS_LOCKS */
541
542
543	/*
544	* This call works for vnodes in the kernel.
545	*/
546	#define VCALL(c) ((c)->a_desc->vdesc_call(c))
547
548	#define DOINGASYNC(vp) \
549	(((vp)->v_mount->mnt_kern_flag & MNTK_ASYNC) != 0 && \
550	((curthread->td_pflags & TDP_SYNCIO) == 0))
551
552	/*
553	* VMIO support inline
554	*/
555
556	extern int vmiodirenable;
557
558	static __inline int
559	vn_canvmio(struct vnode *vp)
560	{
561	if (vp && (vp->v_type == VREG \|\| (vmiodirenable && vp->v_type == VDIR)))
562	return(TRUE);
563	return(FALSE);
564	}
565
566	/*
567	* Finally, include the default set of vnode operations.
568	*/
569	#include <rtems/bsd/local/vnode_if.h>
570
571	/* vn_open_flags */
572	#define VN_OPEN_NOAUDIT 0x00000001
573
574	/*
575	* Public vnode manipulation functions.
576	*/
577	struct componentname;
578	struct file;
579	struct mount;
580	struct nameidata;
581	struct ostat;
582	struct thread;
583	struct proc;
584	struct stat;
585	struct nstat;
586	struct ucred;
587	struct uio;
588	struct vattr;
589	struct vnode;
590
591	/* cache_* may belong in namei.h. */
592	#define cache_enter(dvp, vp, cnp) \
593	cache_enter_time(dvp, vp, cnp, NULL, NULL)
594	void cache_enter_time(struct vnode dvp, struct vnode vp,
595	struct componentname cnp, struct timespec tsp,
596	struct timespec *dtsp);
597	#define cache_lookup(dvp, vpp, cnp) \
598	cache_lookup_times(dvp, vpp, cnp, NULL, NULL)
599	int cache_lookup_times(struct vnode dvp, struct vnode *vpp,
600	struct componentname cnp, struct timespec tsp, int *ticksp);
601	void cache_purge(struct vnode *vp);
602	void cache_purge_negative(struct vnode *vp);
603	void cache_purgevfs(struct mount *mp);
604	int change_dir(struct vnode vp, struct thread td);
605	int change_root(struct vnode vp, struct thread td);
606	void cvtstat(struct stat st, struct ostat ost);
607	void cvtnstat(struct stat sb, struct nstat nsb);
608	int getnewvnode(const char tag, struct mount mp, struct vop_vector *vops,
609	struct vnode **vpp);
610	void getnewvnode_reserve(u_int count);
611	void getnewvnode_drop_reserve(void);
612	int insmntque1(struct vnode vp, struct mount mp,
613	void (dtr)(struct vnode , void ), void dtr_arg);
614	int insmntque(struct vnode vp, struct mount mp);
615	u_quad_t init_va_filerev(void);
616	int speedup_syncer(void);
617	int vn_vptocnp(struct vnode *vp, struct ucred cred, char *buf,
618	u_int *buflen);
619	#define textvp_fullpath(p, rb, rfb) \
620	vn_fullpath(FIRST_THREAD_IN_PROC(p), (p)->p_textvp, rb, rfb)
621	int vn_fullpath(struct thread td, struct vnode vn,
622	char retbuf, char freebuf);
623	int vn_fullpath_global(struct thread td, struct vnode vn,
624	char retbuf, char freebuf);
625	struct vnode *
626	vn_dir_dd_ino(struct vnode *vp);
627	int vn_commname(struct vnode vn, char buf, u_int buflen);
628	int vn_path_to_global_path(struct thread td, struct vnode vp,
629	char *path, u_int pathlen);
630	int vaccess(enum vtype type, mode_t file_mode, uid_t file_uid,
631	gid_t file_gid, accmode_t accmode, struct ucred *cred,
632	int *privused);
633	int vaccess_acl_nfs4(enum vtype type, uid_t file_uid, gid_t file_gid,
634	struct acl aclp, accmode_t accmode, struct ucred cred,
635	int *privused);
636	int vaccess_acl_posix1e(enum vtype type, uid_t file_uid,
637	gid_t file_gid, struct acl *acl, accmode_t accmode,
638	struct ucred cred, int privused);
639	void vattr_null(struct vattr *vap);
640	int vcount(struct vnode *vp);
641	void vdrop(struct vnode *);
642	void vdropl(struct vnode *);
643	int vflush(struct mount mp, int rootrefs, int flags, struct thread td);
644	int vget(struct vnode vp, int lockflag, struct thread td);
645	void vgone(struct vnode *vp);
646	void vhold(struct vnode *);
647	void vholdl(struct vnode *);
648	void vinactive(struct vnode , struct thread );
649	int vinvalbuf(struct vnode *vp, int save, int slpflag, int slptimeo);
650	int vtruncbuf(struct vnode vp, struct ucred cred, struct thread *td,
651	off_t length, int blksize);
652	void vunref(struct vnode *);
653	void vn_printf(struct vnode vp, const char fmt, ...) __printflike(2,3);
654	#define vprint(label, vp) vn_printf((vp), "%s\n", (label))
655	int vrecycle(struct vnode vp, struct thread td);
656	int vn_bmap_seekhole(struct vnode vp, u_long cmd, off_t off,
657	struct ucred *cred);
658	int vn_close(struct vnode *vp,
659	int flags, struct ucred file_cred, struct thread td);
660	void vn_finished_write(struct mount *mp);
661	void vn_finished_secondary_write(struct mount *mp);
662	int vn_isdisk(struct vnode vp, int errp);
663	int _vn_lock(struct vnode vp, int flags, char file, int line);
664	#define vn_lock(vp, flags) _vn_lock(vp, flags, __FILE__, __LINE__)
665	int vn_open(struct nameidata ndp, int flagp, int cmode, struct file *fp);
666	int vn_open_cred(struct nameidata ndp, int flagp, int cmode,
667	u_int vn_open_flags, struct ucred cred, struct file fp);
668	void vn_pages_remove(struct vnode *vp, vm_pindex_t start, vm_pindex_t end);
669	int vn_pollrecord(struct vnode vp, struct thread p, int events);
670	int vn_rdwr(enum uio_rw rw, struct vnode vp, void base,
671	int len, off_t offset, enum uio_seg segflg, int ioflg,
672	struct ucred active_cred, struct ucred file_cred, ssize_t *aresid,
673	struct thread *td);
674	int vn_rdwr_inchunks(enum uio_rw rw, struct vnode vp, void base,
675	size_t len, off_t offset, enum uio_seg segflg, int ioflg,
676	struct ucred active_cred, struct ucred file_cred, size_t *aresid,
677	struct thread *td);
678	int vn_rlimit_fsize(const struct vnode vn, const struct uio uio,
679	const struct thread *td);
680	int vn_stat(struct vnode vp, struct stat sb, struct ucred *active_cred,
681	struct ucred file_cred, struct thread td);
682	int vn_start_write(struct vnode vp, struct mount *mpp, int flags);
683	int vn_start_secondary_write(struct vnode vp, struct mount *mpp,
684	int flags);
685	int vn_writechk(struct vnode *vp);
686	int vn_extattr_get(struct vnode *vp, int ioflg, int attrnamespace,
687	const char attrname, int buflen, char buf, struct thread td);
688	int vn_extattr_set(struct vnode *vp, int ioflg, int attrnamespace,
689	const char attrname, int buflen, char buf, struct thread *td);
690	int vn_extattr_rm(struct vnode *vp, int ioflg, int attrnamespace,
691	const char attrname, struct thread td);
692	int vn_vget_ino(struct vnode *vp, ino_t ino, int lkflags,
693	struct vnode **rvp);
694
695	int vn_io_fault_uiomove(char data, int xfersize, struct uio uio);
696	int vn_io_fault_pgmove(vm_page_t ma[], vm_offset_t offset, int xfersize,
697	struct uio *uio);
698
699	#define vn_rangelock_unlock(vp, cookie) \
700	rangelock_unlock(&(vp)->v_rl, (cookie), VI_MTX(vp))
701	#define vn_rangelock_unlock_range(vp, cookie, start, end) \
702	rangelock_unlock_range(&(vp)->v_rl, (cookie), (start), (end), \
703	VI_MTX(vp))
704	#define vn_rangelock_rlock(vp, start, end) \
705	rangelock_rlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
706	#define vn_rangelock_wlock(vp, start, end) \
707	rangelock_wlock(&(vp)->v_rl, (start), (end), VI_MTX(vp))
708
709	int vfs_cache_lookup(struct vop_lookup_args *ap);
710	void vfs_timestamp(struct timespec *);
711	void vfs_write_resume(struct mount *mp);
712	void vfs_write_resume_flags(struct mount *mp, int flags);
713	int vfs_write_suspend(struct mount *mp);
714	int vop_stdbmap(struct vop_bmap_args *);
715	int vop_stdfsync(struct vop_fsync_args *);
716	int vop_stdgetwritemount(struct vop_getwritemount_args *);
717	int vop_stdgetpages(struct vop_getpages_args *);
718	int vop_stdinactive(struct vop_inactive_args *);
719	int vop_stdislocked(struct vop_islocked_args *);
720	int vop_stdkqfilter(struct vop_kqfilter_args *);
721	int vop_stdlock(struct vop_lock1_args *);
722	int vop_stdputpages(struct vop_putpages_args *);
723	int vop_stdunlock(struct vop_unlock_args *);
724	int vop_nopoll(struct vop_poll_args *);
725	int vop_stdaccess(struct vop_access_args *ap);
726	int vop_stdaccessx(struct vop_accessx_args *ap);
727	int vop_stdadvise(struct vop_advise_args *ap);
728	int vop_stdadvlock(struct vop_advlock_args *ap);
729	int vop_stdadvlockasync(struct vop_advlockasync_args *ap);
730	int vop_stdadvlockpurge(struct vop_advlockpurge_args *ap);
731	int vop_stdallocate(struct vop_allocate_args *ap);
732	int vop_stdpathconf(struct vop_pathconf_args *);
733	int vop_stdpoll(struct vop_poll_args *);
734	int vop_stdvptocnp(struct vop_vptocnp_args *ap);
735	int vop_stdvptofh(struct vop_vptofh_args *ap);
736	int vop_stdunp_bind(struct vop_unp_bind_args *ap);
737	int vop_stdunp_connect(struct vop_unp_connect_args *ap);
738	int vop_stdunp_detach(struct vop_unp_detach_args *ap);
739	int vop_eopnotsupp(struct vop_generic_args *ap);
740	int vop_ebadf(struct vop_generic_args *ap);
741	int vop_einval(struct vop_generic_args *ap);
742	int vop_enoent(struct vop_generic_args *ap);
743	int vop_enotty(struct vop_generic_args *ap);
744	int vop_null(struct vop_generic_args *ap);
745	int vop_panic(struct vop_generic_args *ap);
746
747	/* These are called from within the actual VOPS. */
748	void vop_create_post(void *a, int rc);
749	void vop_deleteextattr_post(void *a, int rc);
750	void vop_link_post(void *a, int rc);
751	void vop_lock_pre(void *a);
752	void vop_lock_post(void *a, int rc);
753	void vop_lookup_post(void *a, int rc);
754	void vop_lookup_pre(void *a);
755	void vop_mkdir_post(void *a, int rc);
756	void vop_mknod_post(void *a, int rc);
757	void vop_remove_post(void *a, int rc);
758	void vop_rename_post(void *a, int rc);
759	void vop_rename_pre(void *a);
760	void vop_rmdir_post(void *a, int rc);
761	void vop_setattr_post(void *a, int rc);
762	void vop_setextattr_post(void *a, int rc);
763	void vop_strategy_pre(void *a);
764	void vop_symlink_post(void *a, int rc);
765	void vop_unlock_post(void *a, int rc);
766	void vop_unlock_pre(void *a);
767
768	void vop_rename_fail(struct vop_rename_args *ap);
769
770	#define VOP_WRITE_PRE(ap) \
771	struct vattr va; \
772	int error, osize, ooffset, noffset; \
773	\
774	osize = ooffset = noffset = 0; \
775	if (!VN_KNLIST_EMPTY((ap)->a_vp)) { \
776	error = VOP_GETATTR((ap)->a_vp, &va, (ap)->a_cred); \
777	if (error) \
778	return (error); \
779	ooffset = (ap)->a_uio->uio_offset; \
780	osize = va.va_size; \
781	}
782
783	#define VOP_WRITE_POST(ap, ret) \
784	noffset = (ap)->a_uio->uio_offset; \
785	if (noffset > ooffset && !VN_KNLIST_EMPTY((ap)->a_vp)) { \
786	VFS_KNOTE_LOCKED((ap)->a_vp, NOTE_WRITE \
787	\| (noffset > osize ? NOTE_EXTEND : 0)); \
788	}
789
790	#define VOP_LOCK(vp, flags) VOP_LOCK1(vp, flags, __FILE__, __LINE__)
791
792
793	void vput(struct vnode *vp);
794	void vrele(struct vnode *vp);
795	void vref(struct vnode *vp);
796	int vrefcnt(struct vnode *vp);
797	void v_addpollinfo(struct vnode *vp);
798
799	int vnode_create_vobject(struct vnode vp, off_t size, struct thread td);
800	void vnode_destroy_vobject(struct vnode *vp);
801
802	extern struct vop_vector fifo_specops;
803	extern struct vop_vector dead_vnodeops;
804	extern struct vop_vector default_vnodeops;
805
806	#define VOP_PANIC ((void*)(uintptr_t)vop_panic)
807	#define VOP_NULL ((void*)(uintptr_t)vop_null)
808	#define VOP_EBADF ((void*)(uintptr_t)vop_ebadf)
809	#define VOP_ENOTTY ((void*)(uintptr_t)vop_enotty)
810	#define VOP_EINVAL ((void*)(uintptr_t)vop_einval)
811	#define VOP_ENOENT ((void*)(uintptr_t)vop_enoent)
812	#define VOP_EOPNOTSUPP ((void*)(uintptr_t)vop_eopnotsupp)
813
814	/* vfs_hash.c */
815	typedef int vfs_hash_cmp_t(struct vnode vp, void arg);
816
817	int vfs_hash_get(const struct mount mp, u_int hash, int flags, struct thread td, struct vnode *vpp, vfs_hash_cmp_t fn, void *arg);
818	u_int vfs_hash_index(struct vnode *vp);
819	int vfs_hash_insert(struct vnode vp, u_int hash, int flags, struct thread td, struct vnode *vpp, vfs_hash_cmp_t fn, void *arg);
820	void vfs_hash_rehash(struct vnode *vp, u_int hash);
821	void vfs_hash_remove(struct vnode *vp);
822
823	int vfs_kqfilter(struct vop_kqfilter_args *);
824	void vfs_mark_atime(struct vnode vp, struct ucred cred);
825	struct dirent;
826	int vfs_read_dirent(struct vop_readdir_args ap, struct dirent dp, off_t off);
827
828	int vfs_unixify_accmode(accmode_t *accmode);
829
830	void vfs_unp_reclaim(struct vnode *vp);
831
832	int setfmode(struct thread td, struct ucred cred, struct vnode *vp, int mode);
833	int setfown(struct thread td, struct ucred cred, struct vnode *vp, uid_t uid,
834	gid_t gid);
835	int vn_chmod(struct file fp, mode_t mode, struct ucred active_cred,
836	struct thread *td);
837	int vn_chown(struct file fp, uid_t uid, gid_t gid, struct ucred active_cred,
838	struct thread *td);
839
840	#endif /* _KERNEL */
841	#endif /* __rtems__ */
842
843	#endif /* !_SYS_VNODE_H_ */

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

Download in other formats: