xref: /freebsd/sys/sys/mount.h (revision 2496fb72cf37bb9aa0cbd108ded06324ea52bd11) 
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1989, 1991, 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 
32 #ifndef _SYS_MOUNT_H_
33 #define _SYS_MOUNT_H_
34 
35 #include <sys/ucred.h>
36 #include <sys/queue.h>
37 #ifdef _KERNEL
38 #include <sys/types.h>
39 #include <sys/lock.h>
40 #include <sys/lockmgr.h>
41 #include <sys/tslog.h>
42 #include <sys/_mutex.h>
43 #include <sys/_sx.h>
44 #endif
45 
46 /*
47  * NOTE: When changing statfs structure, mount structure, MNT_* flags or
48  * MNTK_* flags also update DDB show mount command in vfs_subr.c.
49  */
50 
51 typedef struct fsid { int32_t val[2]; } fsid_t;	/* filesystem id type */
52 
53 /* Returns non-zero if fsids are different. */
54 static __inline int
fsidcmp(const fsid_t * a,const fsid_t * b)55 fsidcmp(const fsid_t *a, const fsid_t *b)
56 {
57 	return (a->val[0] != b->val[0] || a->val[1] != b->val[1]);
58 }
59 
60 /*
61  * File identifier.
62  * These are unique per filesystem on a single machine.
63  *
64  * Note that the offset of fid_data is 4 bytes, so care must be taken to avoid
65  * undefined behavior accessing unaligned fields within an embedded struct.
66  */
67 #define	MAXFIDSZ	16
68 
69 struct fid {
70 	u_short		fid_len;		/* length of data in bytes */
71 	u_short		fid_data0;		/* force longword alignment */
72 	char		fid_data[MAXFIDSZ];	/* data (variable length) */
73 };
74 
75 /*
76  * filesystem statistics
77  */
78 #define	MFSNAMELEN	16		/* length of type name including null */
79 #define	MNAMELEN	1024		/* size of on/from name bufs */
80 #define	STATFS_VERSION	0x20140518	/* current version number */
81 struct statfs {
82 	uint32_t f_version;		/* structure version number */
83 	uint32_t f_type;		/* type of filesystem */
84 	uint64_t f_flags;		/* copy of mount exported flags */
85 	uint64_t f_bsize;		/* filesystem fragment size */
86 	uint64_t f_iosize;		/* optimal transfer block size */
87 	uint64_t f_blocks;		/* total data blocks in filesystem */
88 	uint64_t f_bfree;		/* free blocks in filesystem */
89 	int64_t	 f_bavail;		/* free blocks avail to non-superuser */
90 	uint64_t f_files;		/* total file nodes in filesystem */
91 	int64_t	 f_ffree;		/* free nodes avail to non-superuser */
92 	uint64_t f_syncwrites;		/* count of sync writes since mount */
93 	uint64_t f_asyncwrites;		/* count of async writes since mount */
94 	uint64_t f_syncreads;		/* count of sync reads since mount */
95 	uint64_t f_asyncreads;		/* count of async reads since mount */
96 	uint32_t f_nvnodelistsize;	/* # of vnodes */
97 	uint32_t f_spare0;		/* unused spare */
98 	uint64_t f_spare[9];		/* unused spare */
99 	uint32_t f_namemax;		/* maximum filename length */
100 	uid_t	  f_owner;		/* user that mounted the filesystem */
101 	fsid_t	  f_fsid;		/* filesystem id */
102 	char	  f_charspare[80];	    /* spare string space */
103 	char	  f_fstypename[MFSNAMELEN]; /* filesystem type name */
104 	char	  f_mntfromname[MNAMELEN];  /* mounted filesystem */
105 	char	  f_mntonname[MNAMELEN];    /* directory on which mounted */
106 };
107 
108 #if defined(_WANT_FREEBSD11_STATFS) || defined(_KERNEL)
109 #define	FREEBSD11_STATFS_VERSION	0x20030518 /* current version number */
110 struct freebsd11_statfs {
111 	uint32_t f_version;		/* structure version number */
112 	uint32_t f_type;		/* type of filesystem */
113 	uint64_t f_flags;		/* copy of mount exported flags */
114 	uint64_t f_bsize;		/* filesystem fragment size */
115 	uint64_t f_iosize;		/* optimal transfer block size */
116 	uint64_t f_blocks;		/* total data blocks in filesystem */
117 	uint64_t f_bfree;		/* free blocks in filesystem */
118 	int64_t	 f_bavail;		/* free blocks avail to non-superuser */
119 	uint64_t f_files;		/* total file nodes in filesystem */
120 	int64_t	 f_ffree;		/* free nodes avail to non-superuser */
121 	uint64_t f_syncwrites;		/* count of sync writes since mount */
122 	uint64_t f_asyncwrites;		/* count of async writes since mount */
123 	uint64_t f_syncreads;		/* count of sync reads since mount */
124 	uint64_t f_asyncreads;		/* count of async reads since mount */
125 	uint64_t f_spare[10];		/* unused spare */
126 	uint32_t f_namemax;		/* maximum filename length */
127 	uid_t	  f_owner;		/* user that mounted the filesystem */
128 	fsid_t	  f_fsid;		/* filesystem id */
129 	char	  f_charspare[80];	/* spare string space */
130 	char	  f_fstypename[16];	/* filesystem type name */
131 	char	  f_mntfromname[88];	/* mounted filesystem */
132 	char	  f_mntonname[88];	/* directory on which mounted */
133 };
134 #endif /* _WANT_FREEBSD11_STATFS || _KERNEL */
135 
136 #ifdef _KERNEL
137 #define	OMFSNAMELEN	16	/* length of fs type name, including null */
138 #define	OMNAMELEN	(88 - 2 * sizeof(long))	/* size of on/from name bufs */
139 
140 /* XXX getfsstat.2 is out of date with write and read counter changes here. */
141 /* XXX statfs.2 is out of date with read counter changes here. */
142 struct ostatfs {
143 	long	f_spare2;		/* placeholder */
144 	long	f_bsize;		/* fundamental filesystem block size */
145 	long	f_iosize;		/* optimal transfer block size */
146 	long	f_blocks;		/* total data blocks in filesystem */
147 	long	f_bfree;		/* free blocks in fs */
148 	long	f_bavail;		/* free blocks avail to non-superuser */
149 	long	f_files;		/* total file nodes in filesystem */
150 	long	f_ffree;		/* free file nodes in fs */
151 	fsid_t	f_fsid;			/* filesystem id */
152 	uid_t	f_owner;		/* user that mounted the filesystem */
153 	int	f_type;			/* type of filesystem */
154 	int	f_flags;		/* copy of mount exported flags */
155 	long	f_syncwrites;		/* count of sync writes since mount */
156 	long	f_asyncwrites;		/* count of async writes since mount */
157 	char	f_fstypename[OMFSNAMELEN]; /* fs type name */
158 	char	f_mntonname[OMNAMELEN];	/* directory on which mounted */
159 	long	f_syncreads;		/* count of sync reads since mount */
160 	long	f_asyncreads;		/* count of async reads since mount */
161 	short	f_spares1;		/* unused spare */
162 	char	f_mntfromname[OMNAMELEN];/* mounted filesystem */
163 	short	f_spares2;		/* unused spare */
164 	/*
165 	 * XXX on machines where longs are aligned to 8-byte boundaries, there
166 	 * is an unnamed int32_t here.  This spare was after the apparent end
167 	 * of the struct until we bit off the read counters from f_mntonname.
168 	 */
169 	long	f_spare[2];		/* unused spare */
170 };
171 #endif	/* _KERNEL */
172 
173 #if defined(_WANT_MOUNT) || defined(_KERNEL)
174 TAILQ_HEAD(vnodelst, vnode);
175 
176 /* Mount options list */
177 TAILQ_HEAD(vfsoptlist, vfsopt);
178 struct vfsopt {
179 	TAILQ_ENTRY(vfsopt) link;
180 	char	*name;
181 	void	*value;
182 	int	len;
183 	int	pos;
184 	int	seen;
185 };
186 
187 struct mount_pcpu {
188 	int		mntp_thread_in_ops;
189 	int		mntp_ref;
190 	int		mntp_lockref;
191 	int		mntp_writeopcount;
192 };
193 
194 _Static_assert(sizeof(struct mount_pcpu) == 16,
195     "the struct is allocated from pcpu 16 zone");
196 
197 /*
198  * Structure for tracking a stacked filesystem mounted above another
199  * filesystem.  This is expected to be stored in the upper FS' per-mount data.
200  *
201  * Lock reference:
202  *	i - lower mount interlock
203  *	c - constant from node initialization
204  */
205 struct mount_upper_node {
206 	struct mount 	*mp;	/* (c) mount object for upper FS */
207 	TAILQ_ENTRY(mount_upper_node) mnt_upper_link;	/* (i) position in uppers list */
208 };
209 
210 /*
211  * Structure per mounted filesystem.  Each mounted filesystem has an
212  * array of operations and an instance record.  The filesystems are
213  * put on a doubly linked list.
214  *
215  * Lock reference:
216  * 	l - mnt_listmtx
217  *	m - mountlist_mtx
218  *	i - interlock
219  *	v - vnode freelist mutex
220  *	d - deferred unmount list mutex
221  *	e - mnt_explock
222  *
223  * Unmarked fields are considered stable as long as a ref is held.
224  *
225  */
226 struct mount {
227 	int 		mnt_vfs_ops;		/* (i) pending vfs ops */
228 	int		mnt_kern_flag;		/* (i) kernel only flags */
229 	uint64_t	mnt_flag;		/* (i) flags shared with user */
230 	struct mount_pcpu *mnt_pcpu;		/* per-CPU data */
231 	struct vnode	*mnt_rootvnode;
232 	struct vnode	*mnt_vnodecovered;	/* vnode we mounted on */
233 	struct vfsops	*mnt_op;		/* operations on fs */
234 	struct vfsconf	*mnt_vfc;		/* configuration info */
235 	struct mtx __aligned(CACHE_LINE_SIZE)	mnt_mtx; /* mount structure interlock */
236 	int		mnt_gen;		/* struct mount generation */
237 #define	mnt_startzero	mnt_list
238 	TAILQ_ENTRY(mount) mnt_list;		/* (m) mount list */
239 	struct vnode	*mnt_syncer;		/* syncer vnode */
240 	int		mnt_ref;		/* (i) Reference count */
241 	struct vnodelst	mnt_nvnodelist;		/* (i) list of vnodes */
242 	int		mnt_nvnodelistsize;	/* (i) # of vnodes */
243 	int		mnt_writeopcount;	/* (i) write syscalls pending */
244 	struct vfsoptlist *mnt_opt;		/* current mount options */
245 	struct vfsoptlist *mnt_optnew;		/* new options passed to fs */
246 	struct statfs	mnt_stat;		/* cache of filesystem stats */
247 	struct ucred	*mnt_cred;		/* credentials of mounter */
248 	void *		mnt_data;		/* private data */
249 	time_t		mnt_time;		/* last time written*/
250 	int		mnt_iosize_max;		/* max size for clusters, etc */
251 	struct netexport *mnt_export;		/* (e) export list */
252 	struct label	*mnt_label;		/* MAC label for the fs */
253 	u_int		mnt_hashseed;		/* Random seed for vfs_hash */
254 	int		mnt_lockref;		/* (i) Lock reference count */
255 	int		mnt_secondary_writes;   /* (i) # of secondary writes */
256 	int		mnt_secondary_accwrites;/* (i) secondary wr. starts */
257 	struct thread	*mnt_susp_owner;	/* (i) thread owning suspension */
258 	struct ucred	*mnt_exjail;		/* (i) jail which did exports */
259 #define	mnt_endzero	mnt_gjprovider
260 	char		*mnt_gjprovider;	/* gjournal provider name */
261 	struct mtx	mnt_listmtx;
262 	struct vnodelst	mnt_lazyvnodelist;	/* (l) list of lazy vnodes */
263 	int		mnt_lazyvnodelistsize;	/* (l) # of lazy vnodes */
264 	int		mnt_upper_pending;	/* (i) # of pending ops on mnt_uppers */
265 	struct lock	mnt_explock;		/* vfs_export walkers lock */
266 	TAILQ_HEAD(, mount_upper_node) mnt_uppers; /* (i) upper mounts over us */
267 	TAILQ_HEAD(, mount_upper_node) mnt_notify; /* (i) upper mounts for notification */
268 	STAILQ_ENTRY(mount) mnt_taskqueue_link;	/* (d) our place in deferred unmount list */
269 	uint64_t	mnt_taskqueue_flags;	/* (d) unmount flags passed from taskqueue */
270 	unsigned int	mnt_unmount_retries;	/* (d) # of failed deferred unmount attempts */
271 };
272 #endif	/* _WANT_MOUNT || _KERNEL */
273 
274 #ifdef _KERNEL
275 /*
276  * Definitions for MNT_VNODE_FOREACH_ALL.
277  */
278 struct vnode *__mnt_vnode_next_all(struct vnode **mvp, struct mount *mp);
279 struct vnode *__mnt_vnode_first_all(struct vnode **mvp, struct mount *mp);
280 void          __mnt_vnode_markerfree_all(struct vnode **mvp, struct mount *mp);
281 
282 #define MNT_VNODE_FOREACH_ALL(vp, mp, mvp)				\
283 	for (vp = __mnt_vnode_first_all(&(mvp), (mp));			\
284 		(vp) != NULL; vp = __mnt_vnode_next_all(&(mvp), (mp)))
285 
286 #define MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp)				\
287 	do {								\
288 		MNT_ILOCK(mp);						\
289 		__mnt_vnode_markerfree_all(&(mvp), (mp));		\
290 		/* MNT_IUNLOCK(mp); -- done in above function */	\
291 		mtx_assert(MNT_MTX(mp), MA_NOTOWNED);			\
292 	} while (0)
293 
294 /*
295  * Definitions for MNT_VNODE_FOREACH_LAZY.
296  */
297 typedef int mnt_lazy_cb_t(struct vnode *, void *);
298 struct vnode *__mnt_vnode_next_lazy(struct vnode **mvp, struct mount *mp,
299     mnt_lazy_cb_t *cb, void *cbarg);
300 struct vnode *__mnt_vnode_first_lazy(struct vnode **mvp, struct mount *mp,
301     mnt_lazy_cb_t *cb, void *cbarg);
302 void          __mnt_vnode_markerfree_lazy(struct vnode **mvp, struct mount *mp);
303 
304 #define MNT_VNODE_FOREACH_LAZY(vp, mp, mvp, cb, cbarg)			\
305 	for (vp = __mnt_vnode_first_lazy(&(mvp), (mp), (cb), (cbarg));	\
306 		(vp) != NULL; 						\
307 		vp = __mnt_vnode_next_lazy(&(mvp), (mp), (cb), (cbarg)))
308 
309 #define MNT_VNODE_FOREACH_LAZY_ABORT(mp, mvp)				\
310 	__mnt_vnode_markerfree_lazy(&(mvp), (mp))
311 
312 #define	MNT_ILOCK(mp)	mtx_lock(&(mp)->mnt_mtx)
313 #define	MNT_ITRYLOCK(mp) mtx_trylock(&(mp)->mnt_mtx)
314 #define	MNT_IUNLOCK(mp)	mtx_unlock(&(mp)->mnt_mtx)
315 #define	MNT_MTX(mp)	(&(mp)->mnt_mtx)
316 
317 #define	MNT_REF(mp)	do {						\
318 	mtx_assert(MNT_MTX(mp), MA_OWNED);				\
319 	mp->mnt_ref++;							\
320 } while (0)
321 #define	MNT_REL(mp)	do {						\
322 	mtx_assert(MNT_MTX(mp), MA_OWNED);				\
323 	(mp)->mnt_ref--;						\
324 	if ((mp)->mnt_vfs_ops && (mp)->mnt_ref < 0)		\
325 		vfs_dump_mount_counters(mp);				\
326 	if ((mp)->mnt_ref == 0 && (mp)->mnt_vfs_ops)		\
327 		wakeup((mp));						\
328 } while (0)
329 
330 #endif /* _KERNEL */
331 
332 #if defined(_WANT_MNTOPTNAMES) || defined(_KERNEL)
333 struct mntoptnames {
334 	uint64_t o_opt;
335 	const char *o_name;
336 };
337 #define MNTOPT_NAMES							\
338 	{ MNT_ASYNC,		"asynchronous" },			\
339 	{ MNT_EXPORTED,		"NFS exported" },			\
340 	{ MNT_LOCAL,		"local" },				\
341 	{ MNT_NOATIME,		"noatime" },				\
342 	{ MNT_NOEXEC,		"noexec" },				\
343 	{ MNT_NOSUID,		"nosuid" },				\
344 	{ MNT_NOSYMFOLLOW,	"nosymfollow" },			\
345 	{ MNT_QUOTA,		"with quotas" },			\
346 	{ MNT_RDONLY,		"read-only" },				\
347 	{ MNT_SYNCHRONOUS,	"synchronous" },			\
348 	{ MNT_UNION,		"union" },				\
349 	{ MNT_NOCLUSTERR,	"noclusterr" },				\
350 	{ MNT_NOCLUSTERW,	"noclusterw" },				\
351 	{ MNT_SUIDDIR,		"suiddir" },				\
352 	{ MNT_SOFTDEP,		"soft-updates" },			\
353 	{ MNT_SUJ,		"journaled soft-updates" },		\
354 	{ MNT_MULTILABEL,	"multilabel" },				\
355 	{ MNT_ACLS,		"acls" },				\
356 	{ MNT_NFS4ACLS,		"nfsv4acls" },				\
357 	{ MNT_GJOURNAL,		"gjournal" },				\
358 	{ MNT_AUTOMOUNTED,	"automounted" },			\
359 	{ MNT_VERIFIED,		"verified" },				\
360 	{ MNT_UNTRUSTED,	"untrusted" },				\
361 	{ MNT_NOCOVER,		"nocover" },				\
362 	{ MNT_EMPTYDIR,		"emptydir" },				\
363 	{ MNT_UPDATE,		"update" },				\
364 	{ MNT_DELEXPORT,	"delexport" },				\
365 	{ MNT_RELOAD,		"reload" },				\
366 	{ MNT_FORCE,		"force" },				\
367 	{ MNT_SNAPSHOT,		"snapshot" },				\
368 	{ 0, NULL }
369 #endif
370 
371 /*
372  * User specifiable flags, stored in mnt_flag.
373  */
374 #define	MNT_RDONLY	0x0000000000000001ULL /* read only filesystem */
375 #define	MNT_SYNCHRONOUS	0x0000000000000002ULL /* fs written synchronously */
376 #define	MNT_NOEXEC	0x0000000000000004ULL /* can't exec from filesystem */
377 #define	MNT_NOSUID	0x0000000000000008ULL /* don't honor setuid fs bits */
378 #define	MNT_NFS4ACLS	0x0000000000000010ULL /* enable NFS version 4 ACLs */
379 #define	MNT_UNION	0x0000000000000020ULL /* union with underlying fs */
380 #define	MNT_ASYNC	0x0000000000000040ULL /* fs written asynchronously */
381 #define	MNT_SUIDDIR	0x0000000000100000ULL /* special SUID dir handling */
382 #define	MNT_SOFTDEP	0x0000000000200000ULL /* using soft updates */
383 #define	MNT_NOSYMFOLLOW	0x0000000000400000ULL /* do not follow symlinks */
384 #define	MNT_GJOURNAL	0x0000000002000000ULL /* GEOM journal support enabled */
385 #define	MNT_MULTILABEL	0x0000000004000000ULL /* MAC support for objects */
386 #define	MNT_ACLS	0x0000000008000000ULL /* ACL support enabled */
387 #define	MNT_NOATIME	0x0000000010000000ULL /* dont update file access time */
388 #define	MNT_NOCLUSTERR	0x0000000040000000ULL /* disable cluster read */
389 #define	MNT_NOCLUSTERW	0x0000000080000000ULL /* disable cluster write */
390 #define	MNT_SUJ		0x0000000100000000ULL /* using journaled soft updates */
391 #define	MNT_AUTOMOUNTED	0x0000000200000000ULL /* mounted by automountd(8) */
392 #define	MNT_UNTRUSTED	0x0000000800000000ULL /* filesys metadata untrusted */
393 
394 /*
395  * NFS export related mount flags.
396  */
397 #define	MNT_EXRDONLY	0x0000000000000080ULL	/* exported read only */
398 #define	MNT_EXPORTED	0x0000000000000100ULL	/* filesystem is exported */
399 #define	MNT_DEFEXPORTED	0x0000000000000200ULL	/* exported to the world */
400 #define	MNT_EXPORTANON	0x0000000000000400ULL	/* anon uid mapping for all */
401 #define	MNT_EXKERB	0x0000000000000800ULL	/* exported with Kerberos */
402 #define	MNT_EXPUBLIC	0x0000000020000000ULL	/* public export (WebNFS) */
403 #define	MNT_EXTLS	0x0000004000000000ULL /* require TLS */
404 #define	MNT_EXTLSCERT	0x0000008000000000ULL /* require TLS with client cert */
405 #define	MNT_EXTLSCERTUSER 0x0000010000000000ULL /* require TLS with user cert */
406 
407 /*
408  * Flags set by internal operations, but visible to the user.
409  */
410 #define	MNT_LOCAL	0x0000000000001000ULL /* filesystem is stored locally */
411 #define	MNT_QUOTA	0x0000000000002000ULL /* quotas are enabled on fs */
412 #define	MNT_ROOTFS	0x0000000000004000ULL /* identifies the root fs */
413 #define	MNT_USER	0x0000000000008000ULL /* mounted by a user */
414 #define	MNT_IGNORE	0x0000000000800000ULL /* do not show entry in df */
415 #define	MNT_VERIFIED	0x0000000400000000ULL /* filesystem is verified */
416 
417 /*
418  * Mask of flags that are visible to statfs().
419  * XXX I think that this could now become (~(MNT_CMDFLAGS))
420  * but the 'mount' program may need changing to handle this.
421  */
422 #define	MNT_VISFLAGMASK	(MNT_RDONLY	| MNT_SYNCHRONOUS | MNT_NOEXEC	| \
423 			MNT_NOSUID	| MNT_UNION	| MNT_SUJ	| \
424 			MNT_ASYNC	| MNT_EXRDONLY	| MNT_EXPORTED	| \
425 			MNT_DEFEXPORTED	| MNT_EXPORTANON| MNT_EXKERB	| \
426 			MNT_LOCAL	| MNT_USER	| MNT_QUOTA	| \
427 			MNT_ROOTFS	| MNT_NOATIME	| MNT_NOCLUSTERR| \
428 			MNT_NOCLUSTERW	| MNT_SUIDDIR	| MNT_SOFTDEP	| \
429 			MNT_IGNORE	| MNT_EXPUBLIC	| MNT_NOSYMFOLLOW | \
430 			MNT_GJOURNAL	| MNT_MULTILABEL | MNT_ACLS	| \
431 			MNT_NFS4ACLS	| MNT_AUTOMOUNTED | MNT_VERIFIED | \
432 			MNT_UNTRUSTED)
433 
434 /* Mask of flags that can be updated. */
435 #define	MNT_UPDATEMASK (MNT_NOSUID	| MNT_NOEXEC	| \
436 			MNT_SYNCHRONOUS	| MNT_UNION	| MNT_ASYNC	| \
437 			MNT_NOATIME | \
438 			MNT_NOSYMFOLLOW	| MNT_IGNORE	| \
439 			MNT_NOCLUSTERR	| MNT_NOCLUSTERW | MNT_SUIDDIR	| \
440 			MNT_ACLS	| MNT_USER	| MNT_NFS4ACLS	| \
441 			MNT_AUTOMOUNTED | MNT_UNTRUSTED)
442 
443 /*
444  * External filesystem command modifier flags.
445  * Unmount can use the MNT_FORCE flag.
446  * XXX: These are not STATES and really should be somewhere else.
447  * XXX: MNT_BYFSID and MNT_NONBUSY collide with MNT_ACLS and MNT_MULTILABEL,
448  *      but because MNT_ACLS and MNT_MULTILABEL are only used for mount(2),
449  *      and MNT_BYFSID and MNT_NONBUSY are only used for unmount(2),
450  *      it's harmless.
451  */
452 #define	MNT_UPDATE	0x0000000000010000ULL /* not real mount, just update */
453 #define	MNT_DELEXPORT	0x0000000000020000ULL /* delete export host lists */
454 #define	MNT_RELOAD	0x0000000000040000ULL /* reload filesystem data */
455 #define	MNT_FORCE	0x0000000000080000ULL /* force unmount or readonly */
456 #define	MNT_SNAPSHOT	0x0000000001000000ULL /* snapshot the filesystem */
457 #define	MNT_NONBUSY	0x0000000004000000ULL /* check vnode use counts. */
458 #define	MNT_BYFSID	0x0000000008000000ULL /* specify filesystem by ID. */
459 #define	MNT_NOCOVER	0x0000001000000000ULL /* Do not cover a mount point */
460 #define	MNT_EMPTYDIR	0x0000002000000000ULL /* Only mount on empty dir */
461 #define	MNT_RECURSE	0x0000100000000000ULL /* recursively unmount uppers */
462 #define	MNT_DEFERRED    0x0000200000000000ULL /* unmount in async context */
463 #define	MNT_CMDFLAGS   (MNT_UPDATE	| MNT_DELEXPORT	| MNT_RELOAD	| \
464 			MNT_FORCE	| MNT_SNAPSHOT	| MNT_NONBUSY	| \
465 			MNT_BYFSID	| MNT_NOCOVER	| MNT_EMPTYDIR	| \
466 			MNT_RECURSE	| MNT_DEFERRED)
467 
468 /*
469  * Internal filesystem control flags stored in mnt_kern_flag.
470  *
471  * MNTK_UNMOUNT locks the mount entry so that name lookup cannot
472  * proceed past the mount point.  This keeps the subtree stable during
473  * mounts and unmounts.  When non-forced unmount flushes all vnodes
474  * from the mp queue, the MNTK_UNMOUNT flag prevents insmntque() from
475  * queueing new vnodes.
476  *
477  * MNTK_UNMOUNTF permits filesystems to detect a forced unmount while
478  * dounmount() is still waiting to lock the mountpoint. This allows
479  * the filesystem to cancel operations that might otherwise deadlock
480  * with the unmount attempt (used by NFS).
481  */
482 #define MNTK_UNMOUNTF		0x00000001 /* forced unmount in progress */
483 #define MNTK_ASYNC		0x00000002 /* filtered async flag */
484 #define MNTK_SOFTDEP		0x00000004 /* async disabled by softdep */
485 #define MNTK_NOMSYNC		0x00000008 /* don't do msync */
486 #define	MNTK_DRAINING		0x00000010 /* lock draining is happening */
487 #define	MNTK_REFEXPIRE		0x00000020 /* refcount expiring is happening */
488 #define MNTK_EXTENDED_SHARED	0x00000040 /* Allow shared locking for more ops */
489 #define	MNTK_SHARED_WRITES	0x00000080 /* Allow shared locking for writes */
490 #define	MNTK_NO_IOPF		0x00000100 /* Disallow page faults during reads
491 					      and writes. Filesystem shall
492 					      properly handle i/o state on
493 					      EFAULT. */
494 #define	MNTK_RECURSE		0x00000200 /* pending recursive unmount */
495 #define	MNTK_UPPER_WAITER	0x00000400 /* waiting to drain MNTK_UPPER_PENDING */
496 /* UNUSED 			0x00000800 */
497 #define	MNTK_UNLOCKED_INSMNTQUE	0x00001000 /* fs does not lock the vnode for
498 					      insmntque */
499 #define	MNTK_UNMAPPED_BUFS	0x00002000
500 #define	MNTK_USES_BCACHE	0x00004000 /* FS uses the buffer cache. */
501 /* UNUSED			0x00008000 */
502 #define	MNTK_VMSETSIZE_BUG	0x00010000
503 #define	MNTK_UNIONFS		0x00020000 /* A hack for F_ISUNIONSTACK */
504 #define	MNTK_FPLOOKUP		0x00040000 /* fast path lookup is supported */
505 #define	MNTK_SUSPEND_ALL	0x00080000 /* Suspended by all-fs suspension */
506 #define	MNTK_TASKQUEUE_WAITER	0x00100000 /* Waiting on unmount taskqueue */
507 /* UNUSED			0x00200000 */
508 /* UNUSED			0x00400000 */
509 #define	MNTK_NOASYNC		0x00800000 /* disable async */
510 #define	MNTK_UNMOUNT		0x01000000 /* unmount in progress */
511 #define	MNTK_MWAIT		0x02000000 /* waiting for unmount to finish */
512 #define	MNTK_SUSPEND		0x08000000 /* request write suspension */
513 #define	MNTK_SUSPEND2		0x04000000 /* block secondary writes */
514 #define	MNTK_SUSPENDED		0x10000000 /* write operations are suspended */
515 #define	MNTK_NULL_NOCACHE	0x20000000 /* auto disable cache for nullfs
516 					      mounts over this fs */
517 #define MNTK_LOOKUP_SHARED	0x40000000 /* FS supports shared lock lookups */
518 /* UNUSED			0x80000000 */
519 
520 #ifdef _KERNEL
521 static inline int
MNT_SHARED_WRITES(struct mount * mp)522 MNT_SHARED_WRITES(struct mount *mp)
523 {
524 
525 	return (mp != NULL && (mp->mnt_kern_flag & MNTK_SHARED_WRITES) != 0);
526 }
527 
528 static inline int
MNT_EXTENDED_SHARED(struct mount * mp)529 MNT_EXTENDED_SHARED(struct mount *mp)
530 {
531 
532 	return (mp != NULL && (mp->mnt_kern_flag & MNTK_EXTENDED_SHARED) != 0);
533 }
534 #endif
535 
536 /*
537  * Sysctl CTL_VFS definitions.
538  *
539  * Second level identifier specifies which filesystem. Second level
540  * identifier VFS_VFSCONF returns information about all filesystems.
541  * Second level identifier VFS_GENERIC is non-terminal.
542  */
543 #define	VFS_VFSCONF		0	/* get configured filesystems */
544 #define	VFS_GENERIC		0	/* generic filesystem information */
545 /*
546  * Third level identifiers for VFS_GENERIC are given below; third
547  * level identifiers for specific filesystems are given in their
548  * mount specific header files.
549  */
550 #define VFS_MAXTYPENUM	1	/* int: highest defined filesystem type */
551 #define VFS_CONF	2	/* struct: vfsconf for filesystem given
552 				   as next argument */
553 
554 /*
555  * Flags for various system call interfaces.
556  *
557  * waitfor flags to vfs_sync() and getfsstat()
558  */
559 #define MNT_WAIT	1	/* synchronously wait for I/O to complete */
560 #define MNT_NOWAIT	2	/* start all I/O, but do not wait for it */
561 #define MNT_LAZY	3	/* push data not written by filesystem syncer */
562 #define MNT_SUSPEND	4	/* Suspend file system after sync */
563 
564 /*
565  * Generic file handle
566  */
567 struct fhandle {
568 	fsid_t	fh_fsid;	/* Filesystem id of mount point */
569 	struct	fid fh_fid;	/* Filesys specific id */
570 };
571 typedef struct fhandle	fhandle_t;
572 
573 /*
574  * Old export arguments without security flavor list
575  */
576 struct oexport_args {
577 	int	ex_flags;		/* export related flags */
578 	uid_t	ex_root;		/* mapping for root uid */
579 	struct	xucred ex_anon;		/* mapping for anonymous user */
580 	struct	sockaddr *ex_addr;	/* net address to which exported */
581 	u_char	ex_addrlen;		/* and the net address length */
582 	struct	sockaddr *ex_mask;	/* mask of valid bits in saddr */
583 	u_char	ex_masklen;		/* and the smask length */
584 	char	*ex_indexfile;		/* index file for WebNFS URLs */
585 };
586 
587 /*
588  * Not quite so old export arguments with 32bit ex_flags and xucred ex_anon.
589  */
590 #define	MAXSECFLAVORS	5
591 struct o2export_args {
592 	int	ex_flags;		/* export related flags */
593 	uid_t	ex_root;		/* mapping for root uid */
594 	struct	xucred ex_anon;		/* mapping for anonymous user */
595 	struct	sockaddr *ex_addr;	/* net address to which exported */
596 	u_char	ex_addrlen;		/* and the net address length */
597 	struct	sockaddr *ex_mask;	/* mask of valid bits in saddr */
598 	u_char	ex_masklen;		/* and the smask length */
599 	char	*ex_indexfile;		/* index file for WebNFS URLs */
600 	int	ex_numsecflavors;	/* security flavor count */
601 	int	ex_secflavors[MAXSECFLAVORS]; /* list of security flavors */
602 };
603 
604 /*
605  * Export arguments for local filesystem mount calls.
606  */
607 struct export_args {
608 	uint64_t ex_flags;		/* export related flags */
609 	uid_t	ex_root;		/* mapping for root uid */
610 	uid_t	ex_uid;			/* mapping for anonymous user */
611 	int	ex_ngroups;
612 	gid_t	*ex_groups;
613 	struct	sockaddr *ex_addr;	/* net address to which exported */
614 	u_char	ex_addrlen;		/* and the net address length */
615 	struct	sockaddr *ex_mask;	/* mask of valid bits in saddr */
616 	u_char	ex_masklen;		/* and the smask length */
617 	char	*ex_indexfile;		/* index file for WebNFS URLs */
618 	int	ex_numsecflavors;	/* security flavor count */
619 	int	ex_secflavors[MAXSECFLAVORS]; /* list of security flavors */
620 };
621 
622 /*
623  * Structure holding information for a publicly exported filesystem
624  * (WebNFS). Currently the specs allow just for one such filesystem.
625  */
626 struct nfs_public {
627 	int		np_valid;	/* Do we hold valid information */
628 	fhandle_t	np_handle;	/* Filehandle for pub fs (internal) */
629 	struct mount	*np_mount;	/* Mountpoint of exported fs */
630 	char		*np_index;	/* Index file */
631 };
632 
633 /*
634  * Filesystem configuration information. One of these exists for each
635  * type of filesystem supported by the kernel. These are searched at
636  * mount time to identify the requested filesystem.
637  *
638  * XXX: Never change the first two arguments!
639  */
640 struct vfsconf {
641 	u_int	vfc_version;		/* ABI version number */
642 	char	vfc_name[MFSNAMELEN];	/* filesystem type name */
643 	struct	vfsops *vfc_vfsops;	/* filesystem operations vector */
644 	struct	vfsops *vfc_vfsops_sd;	/* ... signal-deferred */
645 	int	vfc_typenum;		/* historic filesystem type number */
646 	int	vfc_refcount;		/* number mounted of this type */
647 	int	vfc_flags;		/* permanent flags */
648 	int	vfc_prison_flag;	/* prison allow.mount.* flag */
649 	struct	vfsoptdecl *vfc_opts;	/* mount options */
650 	TAILQ_ENTRY(vfsconf) vfc_list;	/* list of vfscons */
651 };
652 
653 /* Userland version of the struct vfsconf. */
654 struct xvfsconf {
655 	struct	vfsops *vfc_vfsops;	/* filesystem operations vector */
656 	char	vfc_name[MFSNAMELEN];	/* filesystem type name */
657 	int	vfc_typenum;		/* historic filesystem type number */
658 	int	vfc_refcount;		/* number mounted of this type */
659 	int	vfc_flags;		/* permanent flags */
660 	struct	vfsconf *vfc_next;	/* next in list */
661 };
662 
663 #ifndef BURN_BRIDGES
664 struct ovfsconf {
665 	void	*vfc_vfsops;
666 	char	vfc_name[32];
667 	int	vfc_index;
668 	int	vfc_refcount;
669 	int	vfc_flags;
670 };
671 #endif
672 
673 /*
674  * NB: these flags refer to IMPLEMENTATION properties, not properties of
675  * any actual mounts; i.e., it does not make sense to change the flags.
676  */
677 #define	VFCF_STATIC	0x00010000	/* statically compiled into kernel */
678 #define	VFCF_NETWORK	0x00020000	/* may get data over the network */
679 #define	VFCF_READONLY	0x00040000	/* writes are not implemented */
680 #define	VFCF_SYNTHETIC	0x00080000	/* data does not represent real files */
681 #define	VFCF_LOOPBACK	0x00100000	/* aliases some other mounted FS */
682 #define	VFCF_UNICODE	0x00200000	/* stores file names as Unicode */
683 #define	VFCF_JAIL	0x00400000	/* can be mounted from within a jail */
684 #define	VFCF_DELEGADMIN	0x00800000	/* supports delegated administration */
685 #define	VFCF_SBDRY	0x01000000	/* Stop at Boundary: defer stop requests
686 					   to kernel->user (AST) transition */
687 #define	VFCF_FILEMOUNT	0x02000000	/* allow mounting files */
688 
689 typedef uint32_t fsctlop_t;
690 
691 struct vfsidctl {
692 	int		vc_vers;	/* should be VFSIDCTL_VERS1 (below) */
693 	fsid_t		vc_fsid;	/* fsid to operate on */
694 	char		vc_fstypename[MFSNAMELEN];
695 					/* type of fs 'nfs' or '*' */
696 	fsctlop_t	vc_op;		/* operation VFS_CTL_* (below) */
697 	void		*vc_ptr;	/* pointer to data structure */
698 	size_t		vc_len;		/* sizeof said structure */
699 	u_int32_t	vc_spare[12];	/* spare (must be zero) */
700 };
701 
702 /* vfsidctl API version. */
703 #define VFS_CTL_VERS1	0x01
704 
705 /*
706  * New style VFS sysctls, do not reuse/conflict with the namespace for
707  * private sysctls.
708  * All "global" sysctl ops have the 33rd bit set:
709  * 0x...1....
710  * Private sysctl ops should have the 33rd bit unset.
711  */
712 #define VFS_CTL_QUERY	0x00010001	/* anything wrong? (vfsquery) */
713 #define VFS_CTL_TIMEO	0x00010002	/* set timeout for vfs notification */
714 #define VFS_CTL_NOLOCKS	0x00010003	/* disable file locking */
715 
716 struct vfsquery {
717 	u_int32_t	vq_flags;
718 	u_int32_t	vq_spare[31];
719 };
720 
721 /* vfsquery flags */
722 #define VQ_NOTRESP	0x0001	/* server down */
723 #define VQ_NEEDAUTH	0x0002	/* server bad auth */
724 #define VQ_LOWDISK	0x0004	/* we're low on space */
725 #define VQ_MOUNT	0x0008	/* new filesystem arrived */
726 #define VQ_UNMOUNT	0x0010	/* filesystem has left */
727 #define VQ_DEAD		0x0020	/* filesystem is dead, needs force unmount */
728 #define VQ_ASSIST	0x0040	/* filesystem needs assistance from external
729 				   program */
730 #define VQ_NOTRESPLOCK	0x0080	/* server lockd down */
731 #define VQ_FLAG0100	0x0100	/* placeholder */
732 #define VQ_FLAG0200	0x0200	/* placeholder */
733 #define VQ_FLAG0400	0x0400	/* placeholder */
734 #define VQ_FLAG0800	0x0800	/* placeholder */
735 #define VQ_FLAG1000	0x1000	/* placeholder */
736 #define VQ_FLAG2000	0x2000	/* placeholder */
737 #define VQ_FLAG4000	0x4000	/* placeholder */
738 #define VQ_FLAG8000	0x8000	/* placeholder */
739 
740 #ifdef _KERNEL
741 /* Point a sysctl request at a vfsidctl's data. */
742 #define VCTLTOREQ(vc, req)						\
743 	do {								\
744 		(req)->newptr = (vc)->vc_ptr;				\
745 		(req)->newlen = (vc)->vc_len;				\
746 		(req)->newidx = 0;					\
747 	} while (0)
748 #endif
749 
750 struct iovec;
751 struct uio;
752 
753 #ifdef _KERNEL
754 
755 /*
756  * vfs_busy specific flags and mask.
757  */
758 #define	MBF_NOWAIT	0x01
759 #define	MBF_MNTLSTLOCK	0x02
760 #define	MBF_MASK	(MBF_NOWAIT | MBF_MNTLSTLOCK)
761 
762 #ifdef MALLOC_DECLARE
763 MALLOC_DECLARE(M_MOUNT);
764 MALLOC_DECLARE(M_STATFS);
765 #endif
766 extern int maxvfsconf;		/* highest defined filesystem type */
767 
768 TAILQ_HEAD(vfsconfhead, vfsconf);
769 extern struct vfsconfhead vfsconf;
770 
771 /*
772  * Operations supported on mounted filesystem.
773  */
774 struct mount_args;
775 struct nameidata;
776 struct sysctl_req;
777 struct mntarg;
778 
779 /*
780  * N.B., vfs_cmount is the ancient vfsop invoked by the old mount(2) syscall.
781  * The new way is vfs_mount.
782  *
783  * vfs_cmount implementations typically translate arguments from their
784  * respective old per-FS structures into the key-value list supported by
785  * nmount(2), then use kernel_mount(9) to mimic nmount(2) from kernelspace.
786  *
787  * Filesystems with mounters that use nmount(2) do not need to and should not
788  * implement vfs_cmount.  Hopefully a future cleanup can remove vfs_cmount and
789  * mount(2) entirely.
790  */
791 typedef int vfs_cmount_t(struct mntarg *ma, void *data, uint64_t flags);
792 typedef int vfs_unmount_t(struct mount *mp, int mntflags);
793 typedef int vfs_root_t(struct mount *mp, int flags, struct vnode **vpp);
794 typedef	int vfs_quotactl_t(struct mount *mp, int cmds, uid_t uid, void *arg,
795 		    bool *mp_busy);
796 typedef	int vfs_statfs_t(struct mount *mp, struct statfs *sbp);
797 typedef	int vfs_sync_t(struct mount *mp, int waitfor);
798 typedef	int vfs_vget_t(struct mount *mp, ino_t ino, int flags,
799 		    struct vnode **vpp);
800 typedef	int vfs_fhtovp_t(struct mount *mp, struct fid *fhp,
801 		    int flags, struct vnode **vpp);
802 typedef	int vfs_checkexp_t(struct mount *mp, struct sockaddr *nam,
803 		    uint64_t *extflagsp, struct ucred **credanonp,
804 		    int *numsecflavors, int *secflavors);
805 typedef	int vfs_init_t(struct vfsconf *);
806 typedef	int vfs_uninit_t(struct vfsconf *);
807 typedef	int vfs_extattrctl_t(struct mount *mp, int cmd,
808 		    struct vnode *filename_vp, int attrnamespace,
809 		    const char *attrname);
810 typedef	int vfs_mount_t(struct mount *mp);
811 typedef int vfs_sysctl_t(struct mount *mp, fsctlop_t op,
812 		    struct sysctl_req *req);
813 typedef void vfs_susp_clean_t(struct mount *mp);
814 typedef void vfs_notify_lowervp_t(struct mount *mp, struct vnode *lowervp);
815 typedef void vfs_purge_t(struct mount *mp);
816 struct sbuf;
817 typedef int vfs_report_lockf_t(struct mount *mp, struct sbuf *sb);
818 
819 struct vfsops {
820 	vfs_mount_t		*vfs_mount;
821 	vfs_cmount_t		*vfs_cmount;
822 	vfs_unmount_t		*vfs_unmount;
823 	vfs_root_t		*vfs_root;
824 	vfs_root_t		*vfs_cachedroot;
825 	vfs_quotactl_t		*vfs_quotactl;
826 	vfs_statfs_t		*vfs_statfs;
827 	vfs_sync_t		*vfs_sync;
828 	vfs_vget_t		*vfs_vget;
829 	vfs_fhtovp_t		*vfs_fhtovp;
830 	vfs_checkexp_t		*vfs_checkexp;
831 	vfs_init_t		*vfs_init;
832 	vfs_uninit_t		*vfs_uninit;
833 	vfs_extattrctl_t	*vfs_extattrctl;
834 	vfs_sysctl_t		*vfs_sysctl;
835 	vfs_susp_clean_t	*vfs_susp_clean;
836 	vfs_notify_lowervp_t	*vfs_reclaim_lowervp;
837 	vfs_notify_lowervp_t	*vfs_unlink_lowervp;
838 	vfs_purge_t		*vfs_purge;
839 	vfs_report_lockf_t	*vfs_report_lockf;
840 	vfs_mount_t		*vfs_spare[6];	/* spares for ABI compat */
841 };
842 
843 vfs_statfs_t	__vfs_statfs;
844 
845 #define	VFS_MOUNT(MP) ({						\
846 	int _rc;							\
847 									\
848 	TSRAW(curthread, TS_ENTER, "VFS_MOUNT", (MP)->mnt_vfc->vfc_name);\
849 	_rc = (*(MP)->mnt_op->vfs_mount)(MP);				\
850 	TSRAW(curthread, TS_EXIT, "VFS_MOUNT", (MP)->mnt_vfc->vfc_name);\
851 	_rc; })
852 
853 #define	VFS_UNMOUNT(MP, FORCE) ({					\
854 	int _rc;							\
855 									\
856 	_rc = (*(MP)->mnt_op->vfs_unmount)(MP, FORCE);			\
857 	_rc; })
858 
859 #define	VFS_ROOT(MP, FLAGS, VPP) ({					\
860 	int _rc;							\
861 									\
862 	_rc = (*(MP)->mnt_op->vfs_root)(MP, FLAGS, VPP);		\
863 	_rc; })
864 
865 #define	VFS_CACHEDROOT(MP, FLAGS, VPP) ({				\
866 	int _rc;							\
867 									\
868 	_rc = (*(MP)->mnt_op->vfs_cachedroot)(MP, FLAGS, VPP);		\
869 	_rc; })
870 
871 #define	VFS_QUOTACTL(MP, C, U, A, MP_BUSY) ({				\
872 	int _rc;							\
873 									\
874 	_rc = (*(MP)->mnt_op->vfs_quotactl)(MP, C, U, A, MP_BUSY);	\
875 	_rc; })
876 
877 #define	VFS_STATFS(MP, SBP) ({						\
878 	int _rc;							\
879 									\
880 	_rc = __vfs_statfs((MP), (SBP));				\
881 	_rc; })
882 
883 #define	VFS_SYNC(MP, WAIT) ({						\
884 	int _rc;							\
885 									\
886 	_rc = (*(MP)->mnt_op->vfs_sync)(MP, WAIT);			\
887 	_rc; })
888 
889 #define	VFS_VGET(MP, INO, FLAGS, VPP) ({				\
890 	int _rc;							\
891 									\
892 	_rc = (*(MP)->mnt_op->vfs_vget)(MP, INO, FLAGS, VPP);		\
893 	_rc; })
894 
895 #define	VFS_FHTOVP(MP, FIDP, FLAGS, VPP) ({				\
896 	int _rc;							\
897 									\
898 	_rc = (*(MP)->mnt_op->vfs_fhtovp)(MP, FIDP, FLAGS, VPP);	\
899 	_rc; })
900 
901 #define	VFS_CHECKEXP(MP, NAM, EXFLG, CRED, NUMSEC, SEC) ({		\
902 	int _rc;							\
903 									\
904 	_rc = (*(MP)->mnt_op->vfs_checkexp)(MP, NAM, EXFLG, CRED, NUMSEC,\
905 	    SEC);							\
906 	_rc; })
907 
908 #define	VFS_EXTATTRCTL(MP, C, FN, NS, N) ({				\
909 	int _rc;							\
910 									\
911 	_rc = (*(MP)->mnt_op->vfs_extattrctl)(MP, C, FN, NS, N);	\
912 	_rc; })
913 
914 #define	VFS_SYSCTL(MP, OP, REQ) ({					\
915 	int _rc;							\
916 									\
917 	_rc = (*(MP)->mnt_op->vfs_sysctl)(MP, OP, REQ);			\
918 	_rc; })
919 
920 #define	VFS_SUSP_CLEAN(MP) do {						\
921 	if (*(MP)->mnt_op->vfs_susp_clean != NULL) {			\
922 		(*(MP)->mnt_op->vfs_susp_clean)(MP);			\
923 	}								\
924 } while (0)
925 
926 #define	VFS_RECLAIM_LOWERVP(MP, VP) do {				\
927 	if (*(MP)->mnt_op->vfs_reclaim_lowervp != NULL) {		\
928 		(*(MP)->mnt_op->vfs_reclaim_lowervp)((MP), (VP));	\
929 	}								\
930 } while (0)
931 
932 #define	VFS_UNLINK_LOWERVP(MP, VP) do {					\
933 	if (*(MP)->mnt_op->vfs_unlink_lowervp != NULL) {		\
934 		(*(MP)->mnt_op->vfs_unlink_lowervp)((MP), (VP));	\
935 	}								\
936 } while (0)
937 
938 #define	VFS_PURGE(MP) do {						\
939 	if (*(MP)->mnt_op->vfs_purge != NULL) {				\
940 		(*(MP)->mnt_op->vfs_purge)(MP);				\
941 	}								\
942 } while (0)
943 
944 #define VFS_KNOTE_LOCKED(vp, hint) do					\
945 {									\
946 	VN_KNOTE((vp), (hint), KNF_LISTLOCKED);				\
947 } while (0)
948 
949 #define VFS_KNOTE_UNLOCKED(vp, hint) do					\
950 {									\
951 	VN_KNOTE((vp), (hint), 0);					\
952 } while (0)
953 
954 #include <sys/module.h>
955 
956 /*
957  * Version numbers.
958  */
959 #define VFS_VERSION_00	0x19660120
960 #define VFS_VERSION_01	0x20121030
961 #define VFS_VERSION_02	0x20180504
962 #define VFS_VERSION	VFS_VERSION_02
963 
964 #define VFS_SET(vfsops, fsname, flags) \
965 	static struct vfsconf fsname ## _vfsconf = {		\
966 		.vfc_version = VFS_VERSION,			\
967 		.vfc_name = #fsname,				\
968 		.vfc_vfsops = &vfsops,				\
969 		.vfc_typenum = -1,				\
970 		.vfc_flags = flags,				\
971 	};							\
972 	static moduledata_t fsname ## _mod = {			\
973 		#fsname,					\
974 		vfs_modevent,					\
975 		& fsname ## _vfsconf				\
976 	};							\
977 	DECLARE_MODULE(fsname, fsname ## _mod, SI_SUB_VFS, SI_ORDER_MIDDLE)
978 
979 enum vfs_notify_upper_type {
980 	VFS_NOTIFY_UPPER_RECLAIM,
981 	VFS_NOTIFY_UPPER_UNLINK,
982 };
983 
984 /*
985  * exported vnode operations
986  */
987 
988 /* Define this to indicate that vfs_exjail_clone() exists for ZFS to use. */
989 #define	VFS_SUPPORTS_EXJAIL_CLONE	1
990 
991 int	dounmount(struct mount *, uint64_t, struct thread *);
992 
993 int	kernel_mount(struct mntarg *ma, uint64_t flags);
994 struct mntarg *mount_arg(struct mntarg *ma, const char *name, const void *val, int len);
995 struct mntarg *mount_argb(struct mntarg *ma, int flag, const char *name);
996 struct mntarg *mount_argf(struct mntarg *ma, const char *name, const char *fmt, ...);
997 struct mntarg *mount_argsu(struct mntarg *ma, const char *name, const void *val, int len);
998 void	statfs_scale_blocks(struct statfs *sf, long max_size);
999 struct vfsconf *vfs_byname(const char *);
1000 struct vfsconf *vfs_byname_kld(const char *, struct thread *td, int *);
1001 void	vfs_mount_destroy(struct mount *);
1002 void	vfs_event_signal(fsid_t *, u_int32_t, intptr_t);
1003 void	vfs_freeopts(struct vfsoptlist *opts);
1004 void	vfs_deleteopt(struct vfsoptlist *opts, const char *name);
1005 int	vfs_buildopts(struct uio *auio, struct vfsoptlist **options);
1006 int	vfs_flagopt(struct vfsoptlist *opts, const char *name, uint64_t *w,
1007 	    uint64_t val);
1008 int	vfs_getopt(struct vfsoptlist *, const char *, void **, int *);
1009 int	vfs_getopt_pos(struct vfsoptlist *opts, const char *name);
1010 int	vfs_getopt_size(struct vfsoptlist *opts, const char *name,
1011 	    off_t *value);
1012 char	*vfs_getopts(struct vfsoptlist *, const char *, int *error);
1013 int	vfs_copyopt(struct vfsoptlist *, const char *, void *, int);
1014 int	vfs_filteropt(struct vfsoptlist *, const char **legal);
1015 void	vfs_opterror(struct vfsoptlist *opts, const char *fmt, ...);
1016 int	vfs_scanopt(struct vfsoptlist *opts, const char *name, const char *fmt, ...);
1017 int	vfs_setopt(struct vfsoptlist *opts, const char *name, void *value,
1018 	    int len);
1019 int	vfs_setopt_part(struct vfsoptlist *opts, const char *name, void *value,
1020 	    int len);
1021 int	vfs_setopts(struct vfsoptlist *opts, const char *name,
1022 	    const char *value);
1023 int	vfs_setpublicfs			    /* set publicly exported fs */
1024 	    (struct mount *, struct netexport *, struct export_args *);
1025 void	vfs_periodic(struct mount *, int);
1026 int	vfs_busy(struct mount *, int);
1027 void	vfs_exjail_clone(struct mount *, struct mount *);
1028 void	vfs_exjail_delete(struct prison *);
1029 int	vfs_export			 /* process mount export info */
1030 	    (struct mount *, struct export_args *, bool);
1031 void	vfs_free_addrlist(struct netexport *);
1032 void	vfs_allocate_syncvnode(struct mount *);
1033 void	vfs_deallocate_syncvnode(struct mount *);
1034 int	vfs_donmount(struct thread *td, uint64_t fsflags,
1035 	    struct uio *fsoptions);
1036 void	vfs_getnewfsid(struct mount *);
1037 struct	mount *vfs_getvfs(fsid_t *);      /* return vfs given fsid */
1038 struct	mount *vfs_busyfs(fsid_t *);
1039 int	vfs_modevent(module_t, int, void *);
1040 void	vfs_mount_error(struct mount *, const char *, ...);
1041 void	vfs_mountroot(void);			/* mount our root filesystem */
1042 void	vfs_mountedfrom(struct mount *, const char *from);
1043 void	vfs_notify_upper(struct vnode *, enum vfs_notify_upper_type);
1044 struct mount *vfs_ref_from_vp(struct vnode *);
1045 void	vfs_ref(struct mount *);
1046 void	vfs_rel(struct mount *);
1047 struct mount *vfs_mount_alloc(struct vnode *, struct vfsconf *, const char *,
1048 	    struct ucred *);
1049 int	vfs_suser(struct mount *, struct thread *);
1050 void	vfs_unbusy(struct mount *);
1051 void	vfs_unmountall(void);
1052 struct mount *vfs_register_upper_from_vp(struct vnode *,
1053 	    struct mount *ump, struct mount_upper_node *);
1054 void	vfs_register_for_notification(struct mount *, struct mount *,
1055 	    struct mount_upper_node *);
1056 void	vfs_unregister_for_notification(struct mount *,
1057 	    struct mount_upper_node *);
1058 void	vfs_unregister_upper(struct mount *, struct mount_upper_node *);
1059 int	vfs_remount_ro(struct mount *mp);
1060 int	vfs_report_lockf(struct mount *mp, struct sbuf *sb);
1061 
1062 extern	TAILQ_HEAD(mntlist, mount) mountlist;	/* mounted filesystem list */
1063 extern	struct mtx_padalign mountlist_mtx;
1064 extern	struct nfs_public nfs_pub;
1065 extern	struct sx vfsconf_sx;
1066 #define	vfsconf_lock()		sx_xlock(&vfsconf_sx)
1067 #define	vfsconf_unlock()	sx_xunlock(&vfsconf_sx)
1068 #define	vfsconf_slock()		sx_slock(&vfsconf_sx)
1069 #define	vfsconf_sunlock()	sx_sunlock(&vfsconf_sx)
1070 struct vnode *mntfs_allocvp(struct mount *, struct vnode *);
1071 void   mntfs_freevp(struct vnode *);
1072 
1073 /*
1074  * Declarations for these vfs default operations are located in
1075  * kern/vfs_default.c.  They will be automatically used to replace
1076  * null entries in VFS ops tables when registering a new filesystem
1077  * type in the global table.
1078  */
1079 vfs_root_t		vfs_stdroot;
1080 vfs_quotactl_t		vfs_stdquotactl;
1081 vfs_statfs_t		vfs_stdstatfs;
1082 vfs_sync_t		vfs_stdsync;
1083 vfs_sync_t		vfs_stdnosync;
1084 vfs_vget_t		vfs_stdvget;
1085 vfs_fhtovp_t		vfs_stdfhtovp;
1086 vfs_checkexp_t		vfs_stdcheckexp;
1087 vfs_init_t		vfs_stdinit;
1088 vfs_uninit_t		vfs_stduninit;
1089 vfs_extattrctl_t	vfs_stdextattrctl;
1090 vfs_sysctl_t		vfs_stdsysctl;
1091 
1092 void	syncer_suspend(void);
1093 void	syncer_resume(void);
1094 
1095 struct vnode *vfs_cache_root_clear(struct mount *);
1096 void	vfs_cache_root_set(struct mount *, struct vnode *);
1097 
1098 void	vfs_op_barrier_wait(struct mount *);
1099 void	vfs_op_enter(struct mount *);
1100 void	vfs_op_exit_locked(struct mount *);
1101 void	vfs_op_exit(struct mount *);
1102 
1103 #ifdef DIAGNOSTIC
1104 void	vfs_assert_mount_counters(struct mount *);
1105 void	vfs_dump_mount_counters(struct mount *);
1106 #else
1107 #define vfs_assert_mount_counters(mp) do { } while (0)
1108 #define vfs_dump_mount_counters(mp) do { } while (0)
1109 #endif
1110 
1111 enum mount_counter { MNT_COUNT_REF, MNT_COUNT_LOCKREF, MNT_COUNT_WRITEOPCOUNT };
1112 int	vfs_mount_fetch_counter(struct mount *, enum mount_counter);
1113 
1114 void suspend_all_fs(void);
1115 void resume_all_fs(void);
1116 
1117 /*
1118  * Code transitioning mnt_vfs_ops to > 0 issues IPIs until it observes
1119  * all CPUs not executing code enclosed by thread_in_ops_pcpu variable.
1120  *
1121  * This provides an invariant that by the time the last CPU is observed not
1122  * executing, everyone else entering will see the counter > 0 and exit.
1123  *
1124  * Note there is no barrier between vfs_ops and the rest of the code in the
1125  * section. It is not necessary as the writer has to wait for everyone to drain
1126  * before making any changes or only make changes safe while the section is
1127  * executed.
1128  */
1129 #define	vfs_mount_pcpu(mp)		zpcpu_get(mp->mnt_pcpu)
1130 #define	vfs_mount_pcpu_remote(mp, cpu)	zpcpu_get_cpu(mp->mnt_pcpu, cpu)
1131 
1132 #define vfs_op_thread_entered(mp) ({				\
1133 	MPASS(curthread->td_critnest > 0);			\
1134 	struct mount_pcpu *_mpcpu = vfs_mount_pcpu(mp);		\
1135 	_mpcpu->mntp_thread_in_ops == 1;			\
1136 })
1137 
1138 #define vfs_op_thread_enter_crit(mp, _mpcpu) ({			\
1139 	bool _retval_crit = true;				\
1140 	MPASS(curthread->td_critnest > 0);			\
1141 	_mpcpu = vfs_mount_pcpu(mp);				\
1142 	MPASS(mpcpu->mntp_thread_in_ops == 0);			\
1143 	_mpcpu->mntp_thread_in_ops = 1;				\
1144 	atomic_interrupt_fence();					\
1145 	if (__predict_false(mp->mnt_vfs_ops > 0)) {		\
1146 		vfs_op_thread_exit_crit(mp, _mpcpu);		\
1147 		_retval_crit = false;				\
1148 	}							\
1149 	_retval_crit;						\
1150 })
1151 
1152 #define vfs_op_thread_enter(mp, _mpcpu) ({			\
1153 	bool _retval;						\
1154 	critical_enter();					\
1155 	_retval = vfs_op_thread_enter_crit(mp, _mpcpu);		\
1156 	if (__predict_false(!_retval))				\
1157 		critical_exit();				\
1158 	_retval;						\
1159 })
1160 
1161 #define vfs_op_thread_exit_crit(mp, _mpcpu) do {		\
1162 	MPASS(_mpcpu == vfs_mount_pcpu(mp));			\
1163 	MPASS(_mpcpu->mntp_thread_in_ops == 1);			\
1164 	atomic_interrupt_fence();					\
1165 	_mpcpu->mntp_thread_in_ops = 0;				\
1166 } while (0)
1167 
1168 #define vfs_op_thread_exit(mp, _mpcpu) do {			\
1169 	vfs_op_thread_exit_crit(mp, _mpcpu);			\
1170 	critical_exit();					\
1171 } while (0)
1172 
1173 #define vfs_mp_count_add_pcpu(_mpcpu, count, val) do {		\
1174 	MPASS(_mpcpu->mntp_thread_in_ops == 1);			\
1175 	_mpcpu->mntp_##count += val;				\
1176 } while (0)
1177 
1178 #define vfs_mp_count_sub_pcpu(_mpcpu, count, val) do {		\
1179 	MPASS(_mpcpu->mntp_thread_in_ops == 1);			\
1180 	_mpcpu->mntp_##count -= val;				\
1181 } while (0)
1182 
1183 #else /* !_KERNEL */
1184 
1185 #include <sys/cdefs.h>
1186 
1187 struct stat;
1188 
1189 __BEGIN_DECLS
1190 int	fhlink(struct fhandle *, const char *);
1191 int	fhlinkat(struct fhandle *, int, const char *);
1192 int	fhopen(const struct fhandle *, int);
1193 int	fhreadlink(struct fhandle *, char *, size_t);
1194 int	fhstat(const struct fhandle *, struct stat *);
1195 int	fhstatfs(const struct fhandle *, struct statfs *);
1196 int	fstatfs(int, struct statfs *);
1197 int	getfh(const char *, fhandle_t *);
1198 int	getfhat(int, char *, struct fhandle *, int);
1199 int	getfsstat(struct statfs *, long, int);
1200 int	getmntinfo(struct statfs **, int);
1201 int	lgetfh(const char *, fhandle_t *);
1202 int	mount(const char *, const char *, int, void *);
1203 int	nmount(struct iovec *, unsigned int, int);
1204 int	statfs(const char *, struct statfs *);
1205 int	unmount(const char *, int);
1206 
1207 /* C library stuff */
1208 int	getvfsbyname(const char *, struct xvfsconf *);
1209 __END_DECLS
1210 
1211 #endif /* _KERNEL */
1212 
1213 #endif /* !_SYS_MOUNT_H_ */
1214