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