xref: /titanic_44/usr/src/uts/common/fs/vfs.c (revision f38cb554a534c6df738be3f4d23327e69888e634)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
26 /*	  All Rights Reserved  	*/
27 
28 /*
29  * University Copyright- Copyright (c) 1982, 1986, 1988
30  * The Regents of the University of California
31  * All Rights Reserved
32  *
33  * University Acknowledgment- Portions of this document are derived from
34  * software developed by the University of California, Berkeley, and its
35  * contributors.
36  */
37 
38 #include <sys/types.h>
39 #include <sys/t_lock.h>
40 #include <sys/param.h>
41 #include <sys/errno.h>
42 #include <sys/user.h>
43 #include <sys/fstyp.h>
44 #include <sys/kmem.h>
45 #include <sys/systm.h>
46 #include <sys/proc.h>
47 #include <sys/mount.h>
48 #include <sys/vfs.h>
49 #include <sys/vfs_opreg.h>
50 #include <sys/fem.h>
51 #include <sys/mntent.h>
52 #include <sys/stat.h>
53 #include <sys/statvfs.h>
54 #include <sys/statfs.h>
55 #include <sys/cred.h>
56 #include <sys/vnode.h>
57 #include <sys/rwstlock.h>
58 #include <sys/dnlc.h>
59 #include <sys/file.h>
60 #include <sys/time.h>
61 #include <sys/atomic.h>
62 #include <sys/cmn_err.h>
63 #include <sys/buf.h>
64 #include <sys/swap.h>
65 #include <sys/debug.h>
66 #include <sys/vnode.h>
67 #include <sys/modctl.h>
68 #include <sys/ddi.h>
69 #include <sys/pathname.h>
70 #include <sys/bootconf.h>
71 #include <sys/dumphdr.h>
72 #include <sys/dc_ki.h>
73 #include <sys/poll.h>
74 #include <sys/sunddi.h>
75 #include <sys/sysmacros.h>
76 #include <sys/zone.h>
77 #include <sys/policy.h>
78 #include <sys/ctfs.h>
79 #include <sys/objfs.h>
80 #include <sys/console.h>
81 #include <sys/reboot.h>
82 #include <sys/attr.h>
83 #include <sys/zio.h>
84 #include <sys/spa.h>
85 #include <sys/lofi.h>
86 #include <sys/bootprops.h>
87 
88 #include <vm/page.h>
89 
90 #include <fs/fs_subr.h>
91 /* Private interfaces to create vopstats-related data structures */
92 extern void		initialize_vopstats(vopstats_t *);
93 extern vopstats_t	*get_fstype_vopstats(struct vfs *, struct vfssw *);
94 extern vsk_anchor_t	*get_vskstat_anchor(struct vfs *);
95 
96 static void vfs_clearmntopt_nolock(mntopts_t *, const char *, int);
97 static void vfs_setmntopt_nolock(mntopts_t *, const char *,
98     const char *, int, int);
99 static int  vfs_optionisset_nolock(const mntopts_t *, const char *, char **);
100 static void vfs_freemnttab(struct vfs *);
101 static void vfs_freeopt(mntopt_t *);
102 static void vfs_swapopttbl_nolock(mntopts_t *, mntopts_t *);
103 static void vfs_swapopttbl(mntopts_t *, mntopts_t *);
104 static void vfs_copyopttbl_extend(const mntopts_t *, mntopts_t *, int);
105 static void vfs_createopttbl_extend(mntopts_t *, const char *,
106     const mntopts_t *);
107 static char **vfs_copycancelopt_extend(char **const, int);
108 static void vfs_freecancelopt(char **);
109 static void getrootfs(char **, char **);
110 static int getmacpath(dev_info_t *, void *);
111 static void vfs_mnttabvp_setup(void);
112 
113 struct ipmnt {
114 	struct ipmnt	*mip_next;
115 	dev_t		mip_dev;
116 	struct vfs	*mip_vfsp;
117 };
118 
119 static kmutex_t		vfs_miplist_mutex;
120 static struct ipmnt	*vfs_miplist = NULL;
121 static struct ipmnt	*vfs_miplist_end = NULL;
122 
123 static kmem_cache_t *vfs_cache;	/* Pointer to VFS kmem cache */
124 
125 /*
126  * VFS global data.
127  */
128 vnode_t *rootdir;		/* pointer to root inode vnode. */
129 vnode_t *devicesdir;		/* pointer to inode of devices root */
130 vnode_t	*devdir;		/* pointer to inode of dev root */
131 
132 char *server_rootpath;		/* root path for diskless clients */
133 char *server_hostname;		/* hostname of diskless server */
134 
135 static struct vfs root;
136 static struct vfs devices;
137 static struct vfs dev;
138 struct vfs *rootvfs = &root;	/* pointer to root vfs; head of VFS list. */
139 rvfs_t *rvfs_list;		/* array of vfs ptrs for vfs hash list */
140 int vfshsz = 512;		/* # of heads/locks in vfs hash arrays */
141 				/* must be power of 2!	*/
142 timespec_t vfs_mnttab_ctime;	/* mnttab created time */
143 timespec_t vfs_mnttab_mtime;	/* mnttab last modified time */
144 char *vfs_dummyfstype = "\0";
145 struct pollhead vfs_pollhd;	/* for mnttab pollers */
146 struct vnode *vfs_mntdummyvp;	/* to fake mnttab read/write for file events */
147 int	mntfstype;		/* will be set once mnt fs is mounted */
148 
149 /*
150  * Table for generic options recognized in the VFS layer and acted
151  * on at this level before parsing file system specific options.
152  * The nosuid option is stronger than any of the devices and setuid
153  * options, so those are canceled when nosuid is seen.
154  *
155  * All options which are added here need to be added to the
156  * list of standard options in usr/src/cmd/fs.d/fslib.c as well.
157  */
158 /*
159  * VFS Mount options table
160  */
161 static char *ro_cancel[] = { MNTOPT_RW, NULL };
162 static char *rw_cancel[] = { MNTOPT_RO, NULL };
163 static char *suid_cancel[] = { MNTOPT_NOSUID, NULL };
164 static char *nosuid_cancel[] = { MNTOPT_SUID, MNTOPT_DEVICES, MNTOPT_NODEVICES,
165     MNTOPT_NOSETUID, MNTOPT_SETUID, NULL };
166 static char *devices_cancel[] = { MNTOPT_NODEVICES, NULL };
167 static char *nodevices_cancel[] = { MNTOPT_DEVICES, NULL };
168 static char *setuid_cancel[] = { MNTOPT_NOSETUID, NULL };
169 static char *nosetuid_cancel[] = { MNTOPT_SETUID, NULL };
170 static char *nbmand_cancel[] = { MNTOPT_NONBMAND, NULL };
171 static char *nonbmand_cancel[] = { MNTOPT_NBMAND, NULL };
172 static char *exec_cancel[] = { MNTOPT_NOEXEC, NULL };
173 static char *noexec_cancel[] = { MNTOPT_EXEC, NULL };
174 
175 static const mntopt_t mntopts[] = {
176 /*
177  *	option name		cancel options		default arg	flags
178  */
179 	{ MNTOPT_REMOUNT,	NULL,			NULL,
180 		MO_NODISPLAY, (void *)0 },
181 	{ MNTOPT_RO,		ro_cancel,		NULL,		0,
182 		(void *)0 },
183 	{ MNTOPT_RW,		rw_cancel,		NULL,		0,
184 		(void *)0 },
185 	{ MNTOPT_SUID,		suid_cancel,		NULL,		0,
186 		(void *)0 },
187 	{ MNTOPT_NOSUID,	nosuid_cancel,		NULL,		0,
188 		(void *)0 },
189 	{ MNTOPT_DEVICES,	devices_cancel,		NULL,		0,
190 		(void *)0 },
191 	{ MNTOPT_NODEVICES,	nodevices_cancel,	NULL,		0,
192 		(void *)0 },
193 	{ MNTOPT_SETUID,	setuid_cancel,		NULL,		0,
194 		(void *)0 },
195 	{ MNTOPT_NOSETUID,	nosetuid_cancel,	NULL,		0,
196 		(void *)0 },
197 	{ MNTOPT_NBMAND,	nbmand_cancel,		NULL,		0,
198 		(void *)0 },
199 	{ MNTOPT_NONBMAND,	nonbmand_cancel,	NULL,		0,
200 		(void *)0 },
201 	{ MNTOPT_EXEC,		exec_cancel,		NULL,		0,
202 		(void *)0 },
203 	{ MNTOPT_NOEXEC,	noexec_cancel,		NULL,		0,
204 		(void *)0 },
205 };
206 
207 const mntopts_t vfs_mntopts = {
208 	sizeof (mntopts) / sizeof (mntopt_t),
209 	(mntopt_t *)&mntopts[0]
210 };
211 
212 /*
213  * File system operation dispatch functions.
214  */
215 
216 int
217 fsop_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
218 {
219 	return (*(vfsp)->vfs_op->vfs_mount)(vfsp, mvp, uap, cr);
220 }
221 
222 int
223 fsop_unmount(vfs_t *vfsp, int flag, cred_t *cr)
224 {
225 	return (*(vfsp)->vfs_op->vfs_unmount)(vfsp, flag, cr);
226 }
227 
228 int
229 fsop_root(vfs_t *vfsp, vnode_t **vpp)
230 {
231 	refstr_t *mntpt;
232 	int ret = (*(vfsp)->vfs_op->vfs_root)(vfsp, vpp);
233 	/*
234 	 * Make sure this root has a path.  With lofs, it is possible to have
235 	 * a NULL mountpoint.
236 	 */
237 	if (ret == 0 && vfsp->vfs_mntpt != NULL && (*vpp)->v_path == NULL) {
238 		mntpt = vfs_getmntpoint(vfsp);
239 		vn_setpath_str(*vpp, refstr_value(mntpt),
240 		    strlen(refstr_value(mntpt)));
241 		refstr_rele(mntpt);
242 	}
243 
244 	return (ret);
245 }
246 
247 int
248 fsop_statfs(vfs_t *vfsp, statvfs64_t *sp)
249 {
250 	return (*(vfsp)->vfs_op->vfs_statvfs)(vfsp, sp);
251 }
252 
253 int
254 fsop_sync(vfs_t *vfsp, short flag, cred_t *cr)
255 {
256 	return (*(vfsp)->vfs_op->vfs_sync)(vfsp, flag, cr);
257 }
258 
259 int
260 fsop_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
261 {
262 	/*
263 	 * In order to handle system attribute fids in a manner
264 	 * transparent to the underlying fs, we embed the fid for
265 	 * the sysattr parent object in the sysattr fid and tack on
266 	 * some extra bytes that only the sysattr layer knows about.
267 	 *
268 	 * This guarantees that sysattr fids are larger than other fids
269 	 * for this vfs. If the vfs supports the sysattr view interface
270 	 * (as indicated by VFSFT_SYSATTR_VIEWS), we cannot have a size
271 	 * collision with XATTR_FIDSZ.
272 	 */
273 	if (vfs_has_feature(vfsp, VFSFT_SYSATTR_VIEWS) &&
274 	    fidp->fid_len == XATTR_FIDSZ)
275 		return (xattr_dir_vget(vfsp, vpp, fidp));
276 
277 	return (*(vfsp)->vfs_op->vfs_vget)(vfsp, vpp, fidp);
278 }
279 
280 int
281 fsop_mountroot(vfs_t *vfsp, enum whymountroot reason)
282 {
283 	return (*(vfsp)->vfs_op->vfs_mountroot)(vfsp, reason);
284 }
285 
286 void
287 fsop_freefs(vfs_t *vfsp)
288 {
289 	(*(vfsp)->vfs_op->vfs_freevfs)(vfsp);
290 }
291 
292 int
293 fsop_vnstate(vfs_t *vfsp, vnode_t *vp, vntrans_t nstate)
294 {
295 	return ((*(vfsp)->vfs_op->vfs_vnstate)(vfsp, vp, nstate));
296 }
297 
298 int
299 fsop_sync_by_kind(int fstype, short flag, cred_t *cr)
300 {
301 	ASSERT((fstype >= 0) && (fstype < nfstype));
302 
303 	if (ALLOCATED_VFSSW(&vfssw[fstype]) && VFS_INSTALLED(&vfssw[fstype]))
304 		return (*vfssw[fstype].vsw_vfsops.vfs_sync) (NULL, flag, cr);
305 	else
306 		return (ENOTSUP);
307 }
308 
309 /*
310  * File system initialization.  vfs_setfsops() must be called from a file
311  * system's init routine.
312  */
313 
314 static int
315 fs_copyfsops(const fs_operation_def_t *template, vfsops_t *actual,
316     int *unused_ops)
317 {
318 	static const fs_operation_trans_def_t vfs_ops_table[] = {
319 		VFSNAME_MOUNT, offsetof(vfsops_t, vfs_mount),
320 			fs_nosys, fs_nosys,
321 
322 		VFSNAME_UNMOUNT, offsetof(vfsops_t, vfs_unmount),
323 			fs_nosys, fs_nosys,
324 
325 		VFSNAME_ROOT, offsetof(vfsops_t, vfs_root),
326 			fs_nosys, fs_nosys,
327 
328 		VFSNAME_STATVFS, offsetof(vfsops_t, vfs_statvfs),
329 			fs_nosys, fs_nosys,
330 
331 		VFSNAME_SYNC, offsetof(vfsops_t, vfs_sync),
332 			(fs_generic_func_p) fs_sync,
333 			(fs_generic_func_p) fs_sync,	/* No errors allowed */
334 
335 		VFSNAME_VGET, offsetof(vfsops_t, vfs_vget),
336 			fs_nosys, fs_nosys,
337 
338 		VFSNAME_MOUNTROOT, offsetof(vfsops_t, vfs_mountroot),
339 			fs_nosys, fs_nosys,
340 
341 		VFSNAME_FREEVFS, offsetof(vfsops_t, vfs_freevfs),
342 			(fs_generic_func_p)fs_freevfs,
343 			(fs_generic_func_p)fs_freevfs,	/* Shouldn't fail */
344 
345 		VFSNAME_VNSTATE, offsetof(vfsops_t, vfs_vnstate),
346 			(fs_generic_func_p)fs_nosys,
347 			(fs_generic_func_p)fs_nosys,
348 
349 		NULL, 0, NULL, NULL
350 	};
351 
352 	return (fs_build_vector(actual, unused_ops, vfs_ops_table, template));
353 }
354 
355 void
356 zfs_boot_init() {
357 
358 	if (strcmp(rootfs.bo_fstype, MNTTYPE_ZFS) == 0)
359 		spa_boot_init();
360 }
361 
362 int
363 vfs_setfsops(int fstype, const fs_operation_def_t *template, vfsops_t **actual)
364 {
365 	int error;
366 	int unused_ops;
367 
368 	/*
369 	 * Verify that fstype refers to a valid fs.  Note that
370 	 * 0 is valid since it's used to set "stray" ops.
371 	 */
372 	if ((fstype < 0) || (fstype >= nfstype))
373 		return (EINVAL);
374 
375 	if (!ALLOCATED_VFSSW(&vfssw[fstype]))
376 		return (EINVAL);
377 
378 	/* Set up the operations vector. */
379 
380 	error = fs_copyfsops(template, &vfssw[fstype].vsw_vfsops, &unused_ops);
381 
382 	if (error != 0)
383 		return (error);
384 
385 	vfssw[fstype].vsw_flag |= VSW_INSTALLED;
386 
387 	if (actual != NULL)
388 		*actual = &vfssw[fstype].vsw_vfsops;
389 
390 #if DEBUG
391 	if (unused_ops != 0)
392 		cmn_err(CE_WARN, "vfs_setfsops: %s: %d operations supplied "
393 		    "but not used", vfssw[fstype].vsw_name, unused_ops);
394 #endif
395 
396 	return (0);
397 }
398 
399 int
400 vfs_makefsops(const fs_operation_def_t *template, vfsops_t **actual)
401 {
402 	int error;
403 	int unused_ops;
404 
405 	*actual = (vfsops_t *)kmem_alloc(sizeof (vfsops_t), KM_SLEEP);
406 
407 	error = fs_copyfsops(template, *actual, &unused_ops);
408 	if (error != 0) {
409 		kmem_free(*actual, sizeof (vfsops_t));
410 		*actual = NULL;
411 		return (error);
412 	}
413 
414 	return (0);
415 }
416 
417 /*
418  * Free a vfsops structure created as a result of vfs_makefsops().
419  * NOTE: For a vfsops structure initialized by vfs_setfsops(), use
420  * vfs_freevfsops_by_type().
421  */
422 void
423 vfs_freevfsops(vfsops_t *vfsops)
424 {
425 	kmem_free(vfsops, sizeof (vfsops_t));
426 }
427 
428 /*
429  * Since the vfsops structure is part of the vfssw table and wasn't
430  * really allocated, we're not really freeing anything.  We keep
431  * the name for consistency with vfs_freevfsops().  We do, however,
432  * need to take care of a little bookkeeping.
433  * NOTE: For a vfsops structure created by vfs_setfsops(), use
434  * vfs_freevfsops_by_type().
435  */
436 int
437 vfs_freevfsops_by_type(int fstype)
438 {
439 
440 	/* Verify that fstype refers to a loaded fs (and not fsid 0). */
441 	if ((fstype <= 0) || (fstype >= nfstype))
442 		return (EINVAL);
443 
444 	WLOCK_VFSSW();
445 	if ((vfssw[fstype].vsw_flag & VSW_INSTALLED) == 0) {
446 		WUNLOCK_VFSSW();
447 		return (EINVAL);
448 	}
449 
450 	vfssw[fstype].vsw_flag &= ~VSW_INSTALLED;
451 	WUNLOCK_VFSSW();
452 
453 	return (0);
454 }
455 
456 /* Support routines used to reference vfs_op */
457 
458 /* Set the operations vector for a vfs */
459 void
460 vfs_setops(vfs_t *vfsp, vfsops_t *vfsops)
461 {
462 	vfsops_t	*op;
463 
464 	ASSERT(vfsp != NULL);
465 	ASSERT(vfsops != NULL);
466 
467 	op = vfsp->vfs_op;
468 	membar_consumer();
469 	if (vfsp->vfs_femhead == NULL &&
470 	    casptr(&vfsp->vfs_op, op, vfsops) == op) {
471 		return;
472 	}
473 	fsem_setvfsops(vfsp, vfsops);
474 }
475 
476 /* Retrieve the operations vector for a vfs */
477 vfsops_t *
478 vfs_getops(vfs_t *vfsp)
479 {
480 	vfsops_t	*op;
481 
482 	ASSERT(vfsp != NULL);
483 
484 	op = vfsp->vfs_op;
485 	membar_consumer();
486 	if (vfsp->vfs_femhead == NULL && op == vfsp->vfs_op) {
487 		return (op);
488 	} else {
489 		return (fsem_getvfsops(vfsp));
490 	}
491 }
492 
493 /*
494  * Returns non-zero (1) if the vfsops matches that of the vfs.
495  * Returns zero (0) if not.
496  */
497 int
498 vfs_matchops(vfs_t *vfsp, vfsops_t *vfsops)
499 {
500 	return (vfs_getops(vfsp) == vfsops);
501 }
502 
503 /*
504  * Returns non-zero (1) if the file system has installed a non-default,
505  * non-error vfs_sync routine.  Returns zero (0) otherwise.
506  */
507 int
508 vfs_can_sync(vfs_t *vfsp)
509 {
510 	/* vfs_sync() routine is not the default/error function */
511 	return (vfs_getops(vfsp)->vfs_sync != fs_sync);
512 }
513 
514 /*
515  * Initialize a vfs structure.
516  */
517 void
518 vfs_init(vfs_t *vfsp, vfsops_t *op, void *data)
519 {
520 	/* Other initialization has been moved to vfs_alloc() */
521 	vfsp->vfs_count = 0;
522 	vfsp->vfs_next = vfsp;
523 	vfsp->vfs_prev = vfsp;
524 	vfsp->vfs_zone_next = vfsp;
525 	vfsp->vfs_zone_prev = vfsp;
526 	vfsp->vfs_lofi_minor = 0;
527 	sema_init(&vfsp->vfs_reflock, 1, NULL, SEMA_DEFAULT, NULL);
528 	vfsimpl_setup(vfsp);
529 	vfsp->vfs_data = (data);
530 	vfs_setops((vfsp), (op));
531 }
532 
533 /*
534  * Allocate and initialize the vfs implementation private data
535  * structure, vfs_impl_t.
536  */
537 void
538 vfsimpl_setup(vfs_t *vfsp)
539 {
540 	int i;
541 
542 	if (vfsp->vfs_implp != NULL) {
543 		return;
544 	}
545 
546 	vfsp->vfs_implp = kmem_alloc(sizeof (vfs_impl_t), KM_SLEEP);
547 	/* Note that these are #define'd in vfs.h */
548 	vfsp->vfs_vskap = NULL;
549 	vfsp->vfs_fstypevsp = NULL;
550 
551 	/* Set size of counted array, then zero the array */
552 	vfsp->vfs_featureset[0] = VFS_FEATURE_MAXSZ - 1;
553 	for (i = 1; i <  VFS_FEATURE_MAXSZ; i++) {
554 		vfsp->vfs_featureset[i] = 0;
555 	}
556 }
557 
558 /*
559  * Release the vfs_impl_t structure, if it exists. Some unbundled
560  * filesystems may not use the newer version of vfs and thus
561  * would not contain this implementation private data structure.
562  */
563 void
564 vfsimpl_teardown(vfs_t *vfsp)
565 {
566 	vfs_impl_t	*vip = vfsp->vfs_implp;
567 
568 	if (vip == NULL)
569 		return;
570 
571 	kmem_free(vfsp->vfs_implp, sizeof (vfs_impl_t));
572 	vfsp->vfs_implp = NULL;
573 }
574 
575 /*
576  * VFS system calls: mount, umount, syssync, statfs, fstatfs, statvfs,
577  * fstatvfs, and sysfs moved to common/syscall.
578  */
579 
580 /*
581  * Update every mounted file system.  We call the vfs_sync operation of
582  * each file system type, passing it a NULL vfsp to indicate that all
583  * mounted file systems of that type should be updated.
584  */
585 void
586 vfs_sync(int flag)
587 {
588 	struct vfssw *vswp;
589 	RLOCK_VFSSW();
590 	for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
591 		if (ALLOCATED_VFSSW(vswp) && VFS_INSTALLED(vswp)) {
592 			vfs_refvfssw(vswp);
593 			RUNLOCK_VFSSW();
594 			(void) (*vswp->vsw_vfsops.vfs_sync)(NULL, flag,
595 			    CRED());
596 			vfs_unrefvfssw(vswp);
597 			RLOCK_VFSSW();
598 		}
599 	}
600 	RUNLOCK_VFSSW();
601 }
602 
603 void
604 sync(void)
605 {
606 	vfs_sync(0);
607 }
608 
609 /*
610  * External routines.
611  */
612 
613 krwlock_t vfssw_lock;	/* lock accesses to vfssw */
614 
615 /*
616  * Lock for accessing the vfs linked list.  Initialized in vfs_mountroot(),
617  * but otherwise should be accessed only via vfs_list_lock() and
618  * vfs_list_unlock().  Also used to protect the timestamp for mods to the list.
619  */
620 static krwlock_t vfslist;
621 
622 /*
623  * Mount devfs on /devices. This is done right after root is mounted
624  * to provide device access support for the system
625  */
626 static void
627 vfs_mountdevices(void)
628 {
629 	struct vfssw *vsw;
630 	struct vnode *mvp;
631 	struct mounta mounta = {	/* fake mounta for devfs_mount() */
632 		NULL,
633 		NULL,
634 		MS_SYSSPACE,
635 		NULL,
636 		NULL,
637 		0,
638 		NULL,
639 		0
640 	};
641 
642 	/*
643 	 * _init devfs module to fill in the vfssw
644 	 */
645 	if (modload("fs", "devfs") == -1)
646 		panic("Cannot _init devfs module");
647 
648 	/*
649 	 * Hold vfs
650 	 */
651 	RLOCK_VFSSW();
652 	vsw = vfs_getvfsswbyname("devfs");
653 	VFS_INIT(&devices, &vsw->vsw_vfsops, NULL);
654 	VFS_HOLD(&devices);
655 
656 	/*
657 	 * Locate mount point
658 	 */
659 	if (lookupname("/devices", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
660 		panic("Cannot find /devices");
661 
662 	/*
663 	 * Perform the mount of /devices
664 	 */
665 	if (VFS_MOUNT(&devices, mvp, &mounta, CRED()))
666 		panic("Cannot mount /devices");
667 
668 	RUNLOCK_VFSSW();
669 
670 	/*
671 	 * Set appropriate members and add to vfs list for mnttab display
672 	 */
673 	vfs_setresource(&devices, "/devices", 0);
674 	vfs_setmntpoint(&devices, "/devices", 0);
675 
676 	/*
677 	 * Hold the root of /devices so it won't go away
678 	 */
679 	if (VFS_ROOT(&devices, &devicesdir))
680 		panic("vfs_mountdevices: not devices root");
681 
682 	if (vfs_lock(&devices) != 0) {
683 		VN_RELE(devicesdir);
684 		cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /devices");
685 		return;
686 	}
687 
688 	if (vn_vfswlock(mvp) != 0) {
689 		vfs_unlock(&devices);
690 		VN_RELE(devicesdir);
691 		cmn_err(CE_NOTE, "Cannot acquire vfswlock of /devices");
692 		return;
693 	}
694 
695 	vfs_add(mvp, &devices, 0);
696 	vn_vfsunlock(mvp);
697 	vfs_unlock(&devices);
698 	VN_RELE(devicesdir);
699 }
700 
701 /*
702  * mount the first instance of /dev  to root and remain mounted
703  */
704 static void
705 vfs_mountdev1(void)
706 {
707 	struct vfssw *vsw;
708 	struct vnode *mvp;
709 	struct mounta mounta = {	/* fake mounta for sdev_mount() */
710 		NULL,
711 		NULL,
712 		MS_SYSSPACE | MS_OVERLAY,
713 		NULL,
714 		NULL,
715 		0,
716 		NULL,
717 		0
718 	};
719 
720 	/*
721 	 * _init dev module to fill in the vfssw
722 	 */
723 	if (modload("fs", "dev") == -1)
724 		cmn_err(CE_PANIC, "Cannot _init dev module\n");
725 
726 	/*
727 	 * Hold vfs
728 	 */
729 	RLOCK_VFSSW();
730 	vsw = vfs_getvfsswbyname("dev");
731 	VFS_INIT(&dev, &vsw->vsw_vfsops, NULL);
732 	VFS_HOLD(&dev);
733 
734 	/*
735 	 * Locate mount point
736 	 */
737 	if (lookupname("/dev", UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp))
738 		cmn_err(CE_PANIC, "Cannot find /dev\n");
739 
740 	/*
741 	 * Perform the mount of /dev
742 	 */
743 	if (VFS_MOUNT(&dev, mvp, &mounta, CRED()))
744 		cmn_err(CE_PANIC, "Cannot mount /dev 1\n");
745 
746 	RUNLOCK_VFSSW();
747 
748 	/*
749 	 * Set appropriate members and add to vfs list for mnttab display
750 	 */
751 	vfs_setresource(&dev, "/dev", 0);
752 	vfs_setmntpoint(&dev, "/dev", 0);
753 
754 	/*
755 	 * Hold the root of /dev so it won't go away
756 	 */
757 	if (VFS_ROOT(&dev, &devdir))
758 		cmn_err(CE_PANIC, "vfs_mountdev1: not dev root");
759 
760 	if (vfs_lock(&dev) != 0) {
761 		VN_RELE(devdir);
762 		cmn_err(CE_NOTE, "Cannot acquire vfs_lock of /dev");
763 		return;
764 	}
765 
766 	if (vn_vfswlock(mvp) != 0) {
767 		vfs_unlock(&dev);
768 		VN_RELE(devdir);
769 		cmn_err(CE_NOTE, "Cannot acquire vfswlock of /dev");
770 		return;
771 	}
772 
773 	vfs_add(mvp, &dev, 0);
774 	vn_vfsunlock(mvp);
775 	vfs_unlock(&dev);
776 	VN_RELE(devdir);
777 }
778 
779 /*
780  * Mount required filesystem. This is done right after root is mounted.
781  */
782 static void
783 vfs_mountfs(char *module, char *spec, char *path)
784 {
785 	struct vnode *mvp;
786 	struct mounta mounta;
787 	vfs_t *vfsp;
788 
789 	mounta.flags = MS_SYSSPACE | MS_DATA;
790 	mounta.fstype = module;
791 	mounta.spec = spec;
792 	mounta.dir = path;
793 	if (lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &mvp)) {
794 		cmn_err(CE_WARN, "Cannot find %s", path);
795 		return;
796 	}
797 	if (domount(NULL, &mounta, mvp, CRED(), &vfsp))
798 		cmn_err(CE_WARN, "Cannot mount %s", path);
799 	else
800 		VFS_RELE(vfsp);
801 	VN_RELE(mvp);
802 }
803 
804 /*
805  * vfs_mountroot is called by main() to mount the root filesystem.
806  */
807 void
808 vfs_mountroot(void)
809 {
810 	struct vnode	*rvp = NULL;
811 	char		*path;
812 	size_t		plen;
813 	struct vfssw	*vswp;
814 	proc_t		*p;
815 
816 	rw_init(&vfssw_lock, NULL, RW_DEFAULT, NULL);
817 	rw_init(&vfslist, NULL, RW_DEFAULT, NULL);
818 
819 	/*
820 	 * Alloc the vfs hash bucket array and locks
821 	 */
822 	rvfs_list = kmem_zalloc(vfshsz * sizeof (rvfs_t), KM_SLEEP);
823 
824 	/*
825 	 * Call machine-dependent routine "rootconf" to choose a root
826 	 * file system type.
827 	 */
828 	if (rootconf())
829 		panic("vfs_mountroot: cannot mount root");
830 	/*
831 	 * Get vnode for '/'.  Set up rootdir, u.u_rdir and u.u_cdir
832 	 * to point to it.  These are used by lookuppn() so that it
833 	 * knows where to start from ('/' or '.').
834 	 */
835 	vfs_setmntpoint(rootvfs, "/", 0);
836 	if (VFS_ROOT(rootvfs, &rootdir))
837 		panic("vfs_mountroot: no root vnode");
838 
839 	/*
840 	 * At this point, the process tree consists of p0 and possibly some
841 	 * direct children of p0.  (i.e. there are no grandchildren)
842 	 *
843 	 * Walk through them all, setting their current directory.
844 	 */
845 	mutex_enter(&pidlock);
846 	for (p = practive; p != NULL; p = p->p_next) {
847 		ASSERT(p == &p0 || p->p_parent == &p0);
848 
849 		PTOU(p)->u_cdir = rootdir;
850 		VN_HOLD(PTOU(p)->u_cdir);
851 		PTOU(p)->u_rdir = NULL;
852 	}
853 	mutex_exit(&pidlock);
854 
855 	/*
856 	 * Setup the global zone's rootvp, now that it exists.
857 	 */
858 	global_zone->zone_rootvp = rootdir;
859 	VN_HOLD(global_zone->zone_rootvp);
860 
861 	/*
862 	 * Notify the module code that it can begin using the
863 	 * root filesystem instead of the boot program's services.
864 	 */
865 	modrootloaded = 1;
866 
867 	/*
868 	 * Special handling for a ZFS root file system.
869 	 */
870 	zfs_boot_init();
871 
872 	/*
873 	 * Set up mnttab information for root
874 	 */
875 	vfs_setresource(rootvfs, rootfs.bo_name, 0);
876 
877 	/*
878 	 * Notify cluster software that the root filesystem is available.
879 	 */
880 	clboot_mountroot();
881 
882 	/* Now that we're all done with the root FS, set up its vopstats */
883 	if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) != NULL) {
884 		/* Set flag for statistics collection */
885 		if (vswp->vsw_flag & VSW_STATS) {
886 			initialize_vopstats(&rootvfs->vfs_vopstats);
887 			rootvfs->vfs_flag |= VFS_STATS;
888 			rootvfs->vfs_fstypevsp =
889 			    get_fstype_vopstats(rootvfs, vswp);
890 			rootvfs->vfs_vskap = get_vskstat_anchor(rootvfs);
891 		}
892 		vfs_unrefvfssw(vswp);
893 	}
894 
895 	/*
896 	 * Mount /devices, /dev instance 1, /system/contract, /etc/mnttab,
897 	 * /etc/svc/volatile, /etc/dfs/sharetab, /system/object, and /proc.
898 	 */
899 	vfs_mountdevices();
900 	vfs_mountdev1();
901 
902 	vfs_mountfs("ctfs", "ctfs", CTFS_ROOT);
903 	vfs_mountfs("proc", "/proc", "/proc");
904 	vfs_mountfs("mntfs", "/etc/mnttab", "/etc/mnttab");
905 	vfs_mountfs("tmpfs", "/etc/svc/volatile", "/etc/svc/volatile");
906 	vfs_mountfs("objfs", "objfs", OBJFS_ROOT);
907 
908 	if (getzoneid() == GLOBAL_ZONEID) {
909 		vfs_mountfs("sharefs", "sharefs", "/etc/dfs/sharetab");
910 	}
911 
912 #ifdef __sparc
913 	/*
914 	 * This bit of magic can go away when we convert sparc to
915 	 * the new boot architecture based on ramdisk.
916 	 *
917 	 * Booting off a mirrored root volume:
918 	 * At this point, we have booted and mounted root on a
919 	 * single component of the mirror.  Complete the boot
920 	 * by configuring SVM and converting the root to the
921 	 * dev_t of the mirrored root device.  This dev_t conversion
922 	 * only works because the underlying device doesn't change.
923 	 */
924 	if (root_is_svm) {
925 		if (svm_rootconf()) {
926 			panic("vfs_mountroot: cannot remount root");
927 		}
928 
929 		/*
930 		 * mnttab should reflect the new root device
931 		 */
932 		vfs_lock_wait(rootvfs);
933 		vfs_setresource(rootvfs, rootfs.bo_name, 0);
934 		vfs_unlock(rootvfs);
935 	}
936 #endif /* __sparc */
937 
938 	if (strcmp(rootfs.bo_fstype, "zfs") != 0) {
939 		/*
940 		 * Look up the root device via devfs so that a dv_node is
941 		 * created for it. The vnode is never VN_RELE()ed.
942 		 * We allocate more than MAXPATHLEN so that the
943 		 * buffer passed to i_ddi_prompath_to_devfspath() is
944 		 * exactly MAXPATHLEN (the function expects a buffer
945 		 * of that length).
946 		 */
947 		plen = strlen("/devices");
948 		path = kmem_alloc(plen + MAXPATHLEN, KM_SLEEP);
949 		(void) strcpy(path, "/devices");
950 
951 		if (i_ddi_prompath_to_devfspath(rootfs.bo_name, path + plen)
952 		    != DDI_SUCCESS ||
953 		    lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, &rvp)) {
954 
955 			/* NUL terminate in case "path" has garbage */
956 			path[plen + MAXPATHLEN - 1] = '\0';
957 #ifdef	DEBUG
958 			cmn_err(CE_WARN, "!Cannot lookup root device: %s",
959 			    path);
960 #endif
961 		}
962 		kmem_free(path, plen + MAXPATHLEN);
963 	}
964 
965 	vfs_mnttabvp_setup();
966 }
967 
968 /*
969  * Check to see if our "block device" is actually a file.  If so,
970  * automatically add a lofi device, and keep track of this fact.
971  */
972 static int
973 lofi_add(const char *fsname, struct vfs *vfsp,
974     mntopts_t *mntopts, struct mounta *uap)
975 {
976 	int fromspace = (uap->flags & MS_SYSSPACE) ?
977 	    UIO_SYSSPACE : UIO_USERSPACE;
978 	struct lofi_ioctl *li = NULL;
979 	struct vnode *vp = NULL;
980 	struct pathname	pn = { NULL };
981 	ldi_ident_t ldi_id;
982 	ldi_handle_t ldi_hdl;
983 	vfssw_t *vfssw;
984 	int minor;
985 	int err = 0;
986 
987 	if ((vfssw = vfs_getvfssw(fsname)) == NULL)
988 		return (0);
989 
990 	if (!(vfssw->vsw_flag & VSW_CANLOFI)) {
991 		vfs_unrefvfssw(vfssw);
992 		return (0);
993 	}
994 
995 	vfs_unrefvfssw(vfssw);
996 	vfssw = NULL;
997 
998 	if (pn_get(uap->spec, fromspace, &pn) != 0)
999 		return (0);
1000 
1001 	if (lookupname(uap->spec, fromspace, FOLLOW, NULL, &vp) != 0)
1002 		goto out;
1003 
1004 	if (vp->v_type != VREG)
1005 		goto out;
1006 
1007 	/* OK, this is a lofi mount. */
1008 
1009 	if ((uap->flags & (MS_REMOUNT|MS_GLOBAL)) ||
1010 	    vfs_optionisset_nolock(mntopts, MNTOPT_SUID, NULL) ||
1011 	    vfs_optionisset_nolock(mntopts, MNTOPT_SETUID, NULL) ||
1012 	    vfs_optionisset_nolock(mntopts, MNTOPT_DEVICES, NULL)) {
1013 		err = EINVAL;
1014 		goto out;
1015 	}
1016 
1017 	ldi_id = ldi_ident_from_anon();
1018 	li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1019 	(void) strlcpy(li->li_filename, pn.pn_path, MAXPATHLEN);
1020 
1021 	err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1022 	    &ldi_hdl, ldi_id);
1023 
1024 	if (err)
1025 		goto out2;
1026 
1027 	err = ldi_ioctl(ldi_hdl, LOFI_MAP_FILE, (intptr_t)li,
1028 	    FREAD | FWRITE | FKIOCTL, kcred, &minor);
1029 
1030 	(void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1031 
1032 	if (!err)
1033 		vfsp->vfs_lofi_minor = minor;
1034 
1035 out2:
1036 	ldi_ident_release(ldi_id);
1037 out:
1038 	if (li != NULL)
1039 		kmem_free(li, sizeof (*li));
1040 	if (vp != NULL)
1041 		VN_RELE(vp);
1042 	pn_free(&pn);
1043 	return (err);
1044 }
1045 
1046 static void
1047 lofi_remove(struct vfs *vfsp)
1048 {
1049 	struct lofi_ioctl *li = NULL;
1050 	ldi_ident_t ldi_id;
1051 	ldi_handle_t ldi_hdl;
1052 	int err;
1053 
1054 	if (vfsp->vfs_lofi_minor == 0)
1055 		return;
1056 
1057 	ldi_id = ldi_ident_from_anon();
1058 
1059 	li = kmem_zalloc(sizeof (*li), KM_SLEEP);
1060 	li->li_minor = vfsp->vfs_lofi_minor;
1061 	li->li_cleanup = B_TRUE;
1062 
1063 	err = ldi_open_by_name("/dev/lofictl", FREAD | FWRITE, kcred,
1064 	    &ldi_hdl, ldi_id);
1065 
1066 	if (err)
1067 		goto out;
1068 
1069 	err = ldi_ioctl(ldi_hdl, LOFI_UNMAP_FILE_MINOR, (intptr_t)li,
1070 	    FREAD | FWRITE | FKIOCTL, kcred, NULL);
1071 
1072 	(void) ldi_close(ldi_hdl, FREAD | FWRITE, kcred);
1073 
1074 	if (!err)
1075 		vfsp->vfs_lofi_minor = 0;
1076 
1077 out:
1078 	ldi_ident_release(ldi_id);
1079 	if (li != NULL)
1080 		kmem_free(li, sizeof (*li));
1081 }
1082 
1083 /*
1084  * Common mount code.  Called from the system call entry point, from autofs,
1085  * nfsv4 trigger mounts, and from pxfs.
1086  *
1087  * Takes the effective file system type, mount arguments, the mount point
1088  * vnode, flags specifying whether the mount is a remount and whether it
1089  * should be entered into the vfs list, and credentials.  Fills in its vfspp
1090  * parameter with the mounted file system instance's vfs.
1091  *
1092  * Note that the effective file system type is specified as a string.  It may
1093  * be null, in which case it's determined from the mount arguments, and may
1094  * differ from the type specified in the mount arguments; this is a hook to
1095  * allow interposition when instantiating file system instances.
1096  *
1097  * The caller is responsible for releasing its own hold on the mount point
1098  * vp (this routine does its own hold when necessary).
1099  * Also note that for remounts, the mount point vp should be the vnode for
1100  * the root of the file system rather than the vnode that the file system
1101  * is mounted on top of.
1102  */
1103 int
1104 domount(char *fsname, struct mounta *uap, vnode_t *vp, struct cred *credp,
1105 	struct vfs **vfspp)
1106 {
1107 	struct vfssw	*vswp;
1108 	vfsops_t	*vfsops;
1109 	struct vfs	*vfsp;
1110 	struct vnode	*bvp;
1111 	dev_t		bdev = 0;
1112 	mntopts_t	mnt_mntopts;
1113 	int		error = 0;
1114 	int		copyout_error = 0;
1115 	int		ovflags;
1116 	char		*opts = uap->optptr;
1117 	char		*inargs = opts;
1118 	int		optlen = uap->optlen;
1119 	int		remount;
1120 	int		rdonly;
1121 	int		nbmand = 0;
1122 	int		delmip = 0;
1123 	int		addmip = 0;
1124 	int		splice = ((uap->flags & MS_NOSPLICE) == 0);
1125 	int		fromspace = (uap->flags & MS_SYSSPACE) ?
1126 	    UIO_SYSSPACE : UIO_USERSPACE;
1127 	char		*resource = NULL, *mountpt = NULL;
1128 	refstr_t	*oldresource, *oldmntpt;
1129 	struct pathname	pn, rpn;
1130 	vsk_anchor_t	*vskap;
1131 	char fstname[FSTYPSZ];
1132 
1133 	/*
1134 	 * The v_flag value for the mount point vp is permanently set
1135 	 * to VVFSLOCK so that no one bypasses the vn_vfs*locks routine
1136 	 * for mount point locking.
1137 	 */
1138 	mutex_enter(&vp->v_lock);
1139 	vp->v_flag |= VVFSLOCK;
1140 	mutex_exit(&vp->v_lock);
1141 
1142 	mnt_mntopts.mo_count = 0;
1143 	/*
1144 	 * Find the ops vector to use to invoke the file system-specific mount
1145 	 * method.  If the fsname argument is non-NULL, use it directly.
1146 	 * Otherwise, dig the file system type information out of the mount
1147 	 * arguments.
1148 	 *
1149 	 * A side effect is to hold the vfssw entry.
1150 	 *
1151 	 * Mount arguments can be specified in several ways, which are
1152 	 * distinguished by flag bit settings.  The preferred way is to set
1153 	 * MS_OPTIONSTR, indicating an 8 argument mount with the file system
1154 	 * type supplied as a character string and the last two arguments
1155 	 * being a pointer to a character buffer and the size of the buffer.
1156 	 * On entry, the buffer holds a null terminated list of options; on
1157 	 * return, the string is the list of options the file system
1158 	 * recognized. If MS_DATA is set arguments five and six point to a
1159 	 * block of binary data which the file system interprets.
1160 	 * A further wrinkle is that some callers don't set MS_FSS and MS_DATA
1161 	 * consistently with these conventions.  To handle them, we check to
1162 	 * see whether the pointer to the file system name has a numeric value
1163 	 * less than 256.  If so, we treat it as an index.
1164 	 */
1165 	if (fsname != NULL) {
1166 		if ((vswp = vfs_getvfssw(fsname)) == NULL) {
1167 			return (EINVAL);
1168 		}
1169 	} else if (uap->flags & (MS_OPTIONSTR | MS_DATA | MS_FSS)) {
1170 		size_t n;
1171 		uint_t fstype;
1172 
1173 		fsname = fstname;
1174 
1175 		if ((fstype = (uintptr_t)uap->fstype) < 256) {
1176 			RLOCK_VFSSW();
1177 			if (fstype == 0 || fstype >= nfstype ||
1178 			    !ALLOCATED_VFSSW(&vfssw[fstype])) {
1179 				RUNLOCK_VFSSW();
1180 				return (EINVAL);
1181 			}
1182 			(void) strcpy(fsname, vfssw[fstype].vsw_name);
1183 			RUNLOCK_VFSSW();
1184 			if ((vswp = vfs_getvfssw(fsname)) == NULL)
1185 				return (EINVAL);
1186 		} else {
1187 			/*
1188 			 * Handle either kernel or user address space.
1189 			 */
1190 			if (uap->flags & MS_SYSSPACE) {
1191 				error = copystr(uap->fstype, fsname,
1192 				    FSTYPSZ, &n);
1193 			} else {
1194 				error = copyinstr(uap->fstype, fsname,
1195 				    FSTYPSZ, &n);
1196 			}
1197 			if (error) {
1198 				if (error == ENAMETOOLONG)
1199 					return (EINVAL);
1200 				return (error);
1201 			}
1202 			if ((vswp = vfs_getvfssw(fsname)) == NULL)
1203 				return (EINVAL);
1204 		}
1205 	} else {
1206 		if ((vswp = vfs_getvfsswbyvfsops(vfs_getops(rootvfs))) == NULL)
1207 			return (EINVAL);
1208 		fsname = vswp->vsw_name;
1209 	}
1210 	if (!VFS_INSTALLED(vswp))
1211 		return (EINVAL);
1212 
1213 	if ((error = secpolicy_fs_allowed_mount(fsname)) != 0)  {
1214 		vfs_unrefvfssw(vswp);
1215 		return (error);
1216 	}
1217 
1218 	vfsops = &vswp->vsw_vfsops;
1219 
1220 	vfs_copyopttbl(&vswp->vsw_optproto, &mnt_mntopts);
1221 	/*
1222 	 * Fetch mount options and parse them for generic vfs options
1223 	 */
1224 	if (uap->flags & MS_OPTIONSTR) {
1225 		/*
1226 		 * Limit the buffer size
1227 		 */
1228 		if (optlen < 0 || optlen > MAX_MNTOPT_STR) {
1229 			error = EINVAL;
1230 			goto errout;
1231 		}
1232 		if ((uap->flags & MS_SYSSPACE) == 0) {
1233 			inargs = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
1234 			inargs[0] = '\0';
1235 			if (optlen) {
1236 				error = copyinstr(opts, inargs, (size_t)optlen,
1237 				    NULL);
1238 				if (error) {
1239 					goto errout;
1240 				}
1241 			}
1242 		}
1243 		vfs_parsemntopts(&mnt_mntopts, inargs, 0);
1244 	}
1245 	/*
1246 	 * Flag bits override the options string.
1247 	 */
1248 	if (uap->flags & MS_REMOUNT)
1249 		vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_REMOUNT, NULL, 0, 0);
1250 	if (uap->flags & MS_RDONLY)
1251 		vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_RO, NULL, 0, 0);
1252 	if (uap->flags & MS_NOSUID)
1253 		vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1254 
1255 	/*
1256 	 * Check if this is a remount; must be set in the option string and
1257 	 * the file system must support a remount option.
1258 	 */
1259 	if (remount = vfs_optionisset_nolock(&mnt_mntopts,
1260 	    MNTOPT_REMOUNT, NULL)) {
1261 		if (!(vswp->vsw_flag & VSW_CANREMOUNT)) {
1262 			error = ENOTSUP;
1263 			goto errout;
1264 		}
1265 		uap->flags |= MS_REMOUNT;
1266 	}
1267 
1268 	/*
1269 	 * uap->flags and vfs_optionisset() should agree.
1270 	 */
1271 	if (rdonly = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_RO, NULL)) {
1272 		uap->flags |= MS_RDONLY;
1273 	}
1274 	if (vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL)) {
1275 		uap->flags |= MS_NOSUID;
1276 	}
1277 	nbmand = vfs_optionisset_nolock(&mnt_mntopts, MNTOPT_NBMAND, NULL);
1278 	ASSERT(splice || !remount);
1279 	/*
1280 	 * If we are splicing the fs into the namespace,
1281 	 * perform mount point checks.
1282 	 *
1283 	 * We want to resolve the path for the mount point to eliminate
1284 	 * '.' and ".." and symlinks in mount points; we can't do the
1285 	 * same for the resource string, since it would turn
1286 	 * "/dev/dsk/c0t0d0s0" into "/devices/pci@...".  We need to do
1287 	 * this before grabbing vn_vfswlock(), because otherwise we
1288 	 * would deadlock with lookuppn().
1289 	 */
1290 	if (splice) {
1291 		ASSERT(vp->v_count > 0);
1292 
1293 		/*
1294 		 * Pick up mount point and device from appropriate space.
1295 		 */
1296 		if (pn_get(uap->spec, fromspace, &pn) == 0) {
1297 			resource = kmem_alloc(pn.pn_pathlen + 1,
1298 			    KM_SLEEP);
1299 			(void) strcpy(resource, pn.pn_path);
1300 			pn_free(&pn);
1301 		}
1302 		/*
1303 		 * Do a lookupname prior to taking the
1304 		 * writelock. Mark this as completed if
1305 		 * successful for later cleanup and addition to
1306 		 * the mount in progress table.
1307 		 */
1308 		if ((uap->flags & MS_GLOBAL) == 0 &&
1309 		    lookupname(uap->spec, fromspace,
1310 		    FOLLOW, NULL, &bvp) == 0) {
1311 			addmip = 1;
1312 		}
1313 
1314 		if ((error = pn_get(uap->dir, fromspace, &pn)) == 0) {
1315 			pathname_t *pnp;
1316 
1317 			if (*pn.pn_path != '/') {
1318 				error = EINVAL;
1319 				pn_free(&pn);
1320 				goto errout;
1321 			}
1322 			pn_alloc(&rpn);
1323 			/*
1324 			 * Kludge to prevent autofs from deadlocking with
1325 			 * itself when it calls domount().
1326 			 *
1327 			 * If autofs is calling, it is because it is doing
1328 			 * (autofs) mounts in the process of an NFS mount.  A
1329 			 * lookuppn() here would cause us to block waiting for
1330 			 * said NFS mount to complete, which can't since this
1331 			 * is the thread that was supposed to doing it.
1332 			 */
1333 			if (fromspace == UIO_USERSPACE) {
1334 				if ((error = lookuppn(&pn, &rpn, FOLLOW, NULL,
1335 				    NULL)) == 0) {
1336 					pnp = &rpn;
1337 				} else {
1338 					/*
1339 					 * The file disappeared or otherwise
1340 					 * became inaccessible since we opened
1341 					 * it; might as well fail the mount
1342 					 * since the mount point is no longer
1343 					 * accessible.
1344 					 */
1345 					pn_free(&rpn);
1346 					pn_free(&pn);
1347 					goto errout;
1348 				}
1349 			} else {
1350 				pnp = &pn;
1351 			}
1352 			mountpt = kmem_alloc(pnp->pn_pathlen + 1, KM_SLEEP);
1353 			(void) strcpy(mountpt, pnp->pn_path);
1354 
1355 			/*
1356 			 * If the addition of the zone's rootpath
1357 			 * would push us over a total path length
1358 			 * of MAXPATHLEN, we fail the mount with
1359 			 * ENAMETOOLONG, which is what we would have
1360 			 * gotten if we were trying to perform the same
1361 			 * mount in the global zone.
1362 			 *
1363 			 * strlen() doesn't count the trailing
1364 			 * '\0', but zone_rootpathlen counts both a
1365 			 * trailing '/' and the terminating '\0'.
1366 			 */
1367 			if ((curproc->p_zone->zone_rootpathlen - 1 +
1368 			    strlen(mountpt)) > MAXPATHLEN ||
1369 			    (resource != NULL &&
1370 			    (curproc->p_zone->zone_rootpathlen - 1 +
1371 			    strlen(resource)) > MAXPATHLEN)) {
1372 				error = ENAMETOOLONG;
1373 			}
1374 
1375 			pn_free(&rpn);
1376 			pn_free(&pn);
1377 		}
1378 
1379 		if (error)
1380 			goto errout;
1381 
1382 		/*
1383 		 * Prevent path name resolution from proceeding past
1384 		 * the mount point.
1385 		 */
1386 		if (vn_vfswlock(vp) != 0) {
1387 			error = EBUSY;
1388 			goto errout;
1389 		}
1390 
1391 		/*
1392 		 * Verify that it's legitimate to establish a mount on
1393 		 * the prospective mount point.
1394 		 */
1395 		if (vn_mountedvfs(vp) != NULL) {
1396 			/*
1397 			 * The mount point lock was obtained after some
1398 			 * other thread raced through and established a mount.
1399 			 */
1400 			vn_vfsunlock(vp);
1401 			error = EBUSY;
1402 			goto errout;
1403 		}
1404 		if (vp->v_flag & VNOMOUNT) {
1405 			vn_vfsunlock(vp);
1406 			error = EINVAL;
1407 			goto errout;
1408 		}
1409 	}
1410 	if ((uap->flags & (MS_DATA | MS_OPTIONSTR)) == 0) {
1411 		uap->dataptr = NULL;
1412 		uap->datalen = 0;
1413 	}
1414 
1415 	/*
1416 	 * If this is a remount, we don't want to create a new VFS.
1417 	 * Instead, we pass the existing one with a remount flag.
1418 	 */
1419 	if (remount) {
1420 		/*
1421 		 * Confirm that the mount point is the root vnode of the
1422 		 * file system that is being remounted.
1423 		 * This can happen if the user specifies a different
1424 		 * mount point directory pathname in the (re)mount command.
1425 		 *
1426 		 * Code below can only be reached if splice is true, so it's
1427 		 * safe to do vn_vfsunlock() here.
1428 		 */
1429 		if ((vp->v_flag & VROOT) == 0) {
1430 			vn_vfsunlock(vp);
1431 			error = ENOENT;
1432 			goto errout;
1433 		}
1434 		/*
1435 		 * Disallow making file systems read-only unless file system
1436 		 * explicitly allows it in its vfssw.  Ignore other flags.
1437 		 */
1438 		if (rdonly && vn_is_readonly(vp) == 0 &&
1439 		    (vswp->vsw_flag & VSW_CANRWRO) == 0) {
1440 			vn_vfsunlock(vp);
1441 			error = EINVAL;
1442 			goto errout;
1443 		}
1444 		/*
1445 		 * Disallow changing the NBMAND disposition of the file
1446 		 * system on remounts.
1447 		 */
1448 		if ((nbmand && ((vp->v_vfsp->vfs_flag & VFS_NBMAND) == 0)) ||
1449 		    (!nbmand && (vp->v_vfsp->vfs_flag & VFS_NBMAND))) {
1450 			vn_vfsunlock(vp);
1451 			error = EINVAL;
1452 			goto errout;
1453 		}
1454 		vfsp = vp->v_vfsp;
1455 		ovflags = vfsp->vfs_flag;
1456 		vfsp->vfs_flag |= VFS_REMOUNT;
1457 		vfsp->vfs_flag &= ~VFS_RDONLY;
1458 	} else {
1459 		vfsp = vfs_alloc(KM_SLEEP);
1460 		VFS_INIT(vfsp, vfsops, NULL);
1461 	}
1462 
1463 	VFS_HOLD(vfsp);
1464 
1465 	if ((error = lofi_add(fsname, vfsp, &mnt_mntopts, uap)) != 0) {
1466 		if (!remount) {
1467 			if (splice)
1468 				vn_vfsunlock(vp);
1469 			vfs_free(vfsp);
1470 		} else {
1471 			vn_vfsunlock(vp);
1472 			VFS_RELE(vfsp);
1473 		}
1474 		goto errout;
1475 	}
1476 
1477 	/*
1478 	 * PRIV_SYS_MOUNT doesn't mean you can become root.
1479 	 */
1480 	if (vfsp->vfs_lofi_minor != 0) {
1481 		uap->flags |= MS_NOSUID;
1482 		vfs_setmntopt_nolock(&mnt_mntopts, MNTOPT_NOSUID, NULL, 0, 0);
1483 	}
1484 
1485 	/*
1486 	 * The vfs_reflock is not used anymore the code below explicitly
1487 	 * holds it preventing others accesing it directly.
1488 	 */
1489 	if ((sema_tryp(&vfsp->vfs_reflock) == 0) &&
1490 	    !(vfsp->vfs_flag & VFS_REMOUNT))
1491 		cmn_err(CE_WARN,
1492 		    "mount type %s couldn't get vfs_reflock", vswp->vsw_name);
1493 
1494 	/*
1495 	 * Lock the vfs. If this is a remount we want to avoid spurious umount
1496 	 * failures that happen as a side-effect of fsflush() and other mount
1497 	 * and unmount operations that might be going on simultaneously and
1498 	 * may have locked the vfs currently. To not return EBUSY immediately
1499 	 * here we use vfs_lock_wait() instead vfs_lock() for the remount case.
1500 	 */
1501 	if (!remount) {
1502 		if (error = vfs_lock(vfsp)) {
1503 			vfsp->vfs_flag = ovflags;
1504 
1505 			lofi_remove(vfsp);
1506 
1507 			if (splice)
1508 				vn_vfsunlock(vp);
1509 			vfs_free(vfsp);
1510 			goto errout;
1511 		}
1512 	} else {
1513 		vfs_lock_wait(vfsp);
1514 	}
1515 
1516 	/*
1517 	 * Add device to mount in progress table, global mounts require special
1518 	 * handling. It is possible that we have already done the lookupname
1519 	 * on a spliced, non-global fs. If so, we don't want to do it again
1520 	 * since we cannot do a lookupname after taking the
1521 	 * wlock above. This case is for a non-spliced, non-global filesystem.
1522 	 */
1523 	if (!addmip) {
1524 		if ((uap->flags & MS_GLOBAL) == 0 &&
1525 		    lookupname(uap->spec, fromspace, FOLLOW, NULL, &bvp) == 0) {
1526 			addmip = 1;
1527 		}
1528 	}
1529 
1530 	if (addmip) {
1531 		vnode_t *lvp = NULL;
1532 
1533 		error = vfs_get_lofi(vfsp, &lvp);
1534 		if (error > 0) {
1535 			lofi_remove(vfsp);
1536 
1537 			if (splice)
1538 				vn_vfsunlock(vp);
1539 			vfs_unlock(vfsp);
1540 
1541 			if (remount) {
1542 				VFS_RELE(vfsp);
1543 			} else {
1544 				vfs_free(vfsp);
1545 			}
1546 
1547 			goto errout;
1548 		} else if (error == -1) {
1549 			bdev = bvp->v_rdev;
1550 			VN_RELE(bvp);
1551 		} else {
1552 			bdev = lvp->v_rdev;
1553 			VN_RELE(lvp);
1554 			VN_RELE(bvp);
1555 		}
1556 
1557 		vfs_addmip(bdev, vfsp);
1558 		addmip = 0;
1559 		delmip = 1;
1560 	}
1561 	/*
1562 	 * Invalidate cached entry for the mount point.
1563 	 */
1564 	if (splice)
1565 		dnlc_purge_vp(vp);
1566 
1567 	/*
1568 	 * If have an option string but the filesystem doesn't supply a
1569 	 * prototype options table, create a table with the global
1570 	 * options and sufficient room to accept all the options in the
1571 	 * string.  Then parse the passed in option string
1572 	 * accepting all the options in the string.  This gives us an
1573 	 * option table with all the proper cancel properties for the
1574 	 * global options.
1575 	 *
1576 	 * Filesystems that supply a prototype options table are handled
1577 	 * earlier in this function.
1578 	 */
1579 	if (uap->flags & MS_OPTIONSTR) {
1580 		if (!(vswp->vsw_flag & VSW_HASPROTO)) {
1581 			mntopts_t tmp_mntopts;
1582 
1583 			tmp_mntopts.mo_count = 0;
1584 			vfs_createopttbl_extend(&tmp_mntopts, inargs,
1585 			    &mnt_mntopts);
1586 			vfs_parsemntopts(&tmp_mntopts, inargs, 1);
1587 			vfs_swapopttbl_nolock(&mnt_mntopts, &tmp_mntopts);
1588 			vfs_freeopttbl(&tmp_mntopts);
1589 		}
1590 	}
1591 
1592 	/*
1593 	 * Serialize with zone creations.
1594 	 */
1595 	mount_in_progress();
1596 	/*
1597 	 * Instantiate (or reinstantiate) the file system.  If appropriate,
1598 	 * splice it into the file system name space.
1599 	 *
1600 	 * We want VFS_MOUNT() to be able to override the vfs_resource
1601 	 * string if necessary (ie, mntfs), and also for a remount to
1602 	 * change the same (necessary when remounting '/' during boot).
1603 	 * So we set up vfs_mntpt and vfs_resource to what we think they
1604 	 * should be, then hand off control to VFS_MOUNT() which can
1605 	 * override this.
1606 	 *
1607 	 * For safety's sake, when changing vfs_resource or vfs_mntpt of
1608 	 * a vfs which is on the vfs list (i.e. during a remount), we must
1609 	 * never set those fields to NULL. Several bits of code make
1610 	 * assumptions that the fields are always valid.
1611 	 */
1612 	vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1613 	if (remount) {
1614 		if ((oldresource = vfsp->vfs_resource) != NULL)
1615 			refstr_hold(oldresource);
1616 		if ((oldmntpt = vfsp->vfs_mntpt) != NULL)
1617 			refstr_hold(oldmntpt);
1618 	}
1619 	vfs_setresource(vfsp, resource, 0);
1620 	vfs_setmntpoint(vfsp, mountpt, 0);
1621 
1622 	/*
1623 	 * going to mount on this vnode, so notify.
1624 	 */
1625 	vnevent_mountedover(vp, NULL);
1626 	error = VFS_MOUNT(vfsp, vp, uap, credp);
1627 
1628 	if (uap->flags & MS_RDONLY)
1629 		vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1630 	if (uap->flags & MS_NOSUID)
1631 		vfs_setmntopt(vfsp, MNTOPT_NOSUID, NULL, 0);
1632 	if (uap->flags & MS_GLOBAL)
1633 		vfs_setmntopt(vfsp, MNTOPT_GLOBAL, NULL, 0);
1634 
1635 	if (error) {
1636 		lofi_remove(vfsp);
1637 
1638 		if (remount) {
1639 			/* put back pre-remount options */
1640 			vfs_swapopttbl(&mnt_mntopts, &vfsp->vfs_mntopts);
1641 			vfs_setmntpoint(vfsp, refstr_value(oldmntpt),
1642 			    VFSSP_VERBATIM);
1643 			if (oldmntpt)
1644 				refstr_rele(oldmntpt);
1645 			vfs_setresource(vfsp, refstr_value(oldresource),
1646 			    VFSSP_VERBATIM);
1647 			if (oldresource)
1648 				refstr_rele(oldresource);
1649 			vfsp->vfs_flag = ovflags;
1650 			vfs_unlock(vfsp);
1651 			VFS_RELE(vfsp);
1652 		} else {
1653 			vfs_unlock(vfsp);
1654 			vfs_freemnttab(vfsp);
1655 			vfs_free(vfsp);
1656 		}
1657 	} else {
1658 		/*
1659 		 * Set the mount time to now
1660 		 */
1661 		vfsp->vfs_mtime = ddi_get_time();
1662 		if (remount) {
1663 			vfsp->vfs_flag &= ~VFS_REMOUNT;
1664 			if (oldresource)
1665 				refstr_rele(oldresource);
1666 			if (oldmntpt)
1667 				refstr_rele(oldmntpt);
1668 		} else if (splice) {
1669 			/*
1670 			 * Link vfsp into the name space at the mount
1671 			 * point. Vfs_add() is responsible for
1672 			 * holding the mount point which will be
1673 			 * released when vfs_remove() is called.
1674 			 */
1675 			vfs_add(vp, vfsp, uap->flags);
1676 		} else {
1677 			/*
1678 			 * Hold the reference to file system which is
1679 			 * not linked into the name space.
1680 			 */
1681 			vfsp->vfs_zone = NULL;
1682 			VFS_HOLD(vfsp);
1683 			vfsp->vfs_vnodecovered = NULL;
1684 		}
1685 		/*
1686 		 * Set flags for global options encountered
1687 		 */
1688 		if (vfs_optionisset(vfsp, MNTOPT_RO, NULL))
1689 			vfsp->vfs_flag |= VFS_RDONLY;
1690 		else
1691 			vfsp->vfs_flag &= ~VFS_RDONLY;
1692 		if (vfs_optionisset(vfsp, MNTOPT_NOSUID, NULL)) {
1693 			vfsp->vfs_flag |= (VFS_NOSETUID|VFS_NODEVICES);
1694 		} else {
1695 			if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
1696 				vfsp->vfs_flag |= VFS_NODEVICES;
1697 			else
1698 				vfsp->vfs_flag &= ~VFS_NODEVICES;
1699 			if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
1700 				vfsp->vfs_flag |= VFS_NOSETUID;
1701 			else
1702 				vfsp->vfs_flag &= ~VFS_NOSETUID;
1703 		}
1704 		if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL))
1705 			vfsp->vfs_flag |= VFS_NBMAND;
1706 		else
1707 			vfsp->vfs_flag &= ~VFS_NBMAND;
1708 
1709 		if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL))
1710 			vfsp->vfs_flag |= VFS_XATTR;
1711 		else
1712 			vfsp->vfs_flag &= ~VFS_XATTR;
1713 
1714 		if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL))
1715 			vfsp->vfs_flag |= VFS_NOEXEC;
1716 		else
1717 			vfsp->vfs_flag &= ~VFS_NOEXEC;
1718 
1719 		/*
1720 		 * Now construct the output option string of options
1721 		 * we recognized.
1722 		 */
1723 		if (uap->flags & MS_OPTIONSTR) {
1724 			vfs_list_read_lock();
1725 			copyout_error = vfs_buildoptionstr(
1726 			    &vfsp->vfs_mntopts, inargs, optlen);
1727 			vfs_list_unlock();
1728 			if (copyout_error == 0 &&
1729 			    (uap->flags & MS_SYSSPACE) == 0) {
1730 				copyout_error = copyoutstr(inargs, opts,
1731 				    optlen, NULL);
1732 			}
1733 		}
1734 
1735 		/*
1736 		 * If this isn't a remount, set up the vopstats before
1737 		 * anyone can touch this. We only allow spliced file
1738 		 * systems (file systems which are in the namespace) to
1739 		 * have the VFS_STATS flag set.
1740 		 * NOTE: PxFS mounts the underlying file system with
1741 		 * MS_NOSPLICE set and copies those vfs_flags to its private
1742 		 * vfs structure. As a result, PxFS should never have
1743 		 * the VFS_STATS flag or else we might access the vfs
1744 		 * statistics-related fields prior to them being
1745 		 * properly initialized.
1746 		 */
1747 		if (!remount && (vswp->vsw_flag & VSW_STATS) && splice) {
1748 			initialize_vopstats(&vfsp->vfs_vopstats);
1749 			/*
1750 			 * We need to set vfs_vskap to NULL because there's
1751 			 * a chance it won't be set below.  This is checked
1752 			 * in teardown_vopstats() so we can't have garbage.
1753 			 */
1754 			vfsp->vfs_vskap = NULL;
1755 			vfsp->vfs_flag |= VFS_STATS;
1756 			vfsp->vfs_fstypevsp = get_fstype_vopstats(vfsp, vswp);
1757 		}
1758 
1759 		if (vswp->vsw_flag & VSW_XID)
1760 			vfsp->vfs_flag |= VFS_XID;
1761 
1762 		vfs_unlock(vfsp);
1763 	}
1764 	mount_completed();
1765 	if (splice)
1766 		vn_vfsunlock(vp);
1767 
1768 	if ((error == 0) && (copyout_error == 0)) {
1769 		if (!remount) {
1770 			/*
1771 			 * Don't call get_vskstat_anchor() while holding
1772 			 * locks since it allocates memory and calls
1773 			 * VFS_STATVFS().  For NFS, the latter can generate
1774 			 * an over-the-wire call.
1775 			 */
1776 			vskap = get_vskstat_anchor(vfsp);
1777 			/* Only take the lock if we have something to do */
1778 			if (vskap != NULL) {
1779 				vfs_lock_wait(vfsp);
1780 				if (vfsp->vfs_flag & VFS_STATS) {
1781 					vfsp->vfs_vskap = vskap;
1782 				}
1783 				vfs_unlock(vfsp);
1784 			}
1785 		}
1786 		/* Return vfsp to caller. */
1787 		*vfspp = vfsp;
1788 	}
1789 errout:
1790 	vfs_freeopttbl(&mnt_mntopts);
1791 	if (resource != NULL)
1792 		kmem_free(resource, strlen(resource) + 1);
1793 	if (mountpt != NULL)
1794 		kmem_free(mountpt, strlen(mountpt) + 1);
1795 	/*
1796 	 * It is possible we errored prior to adding to mount in progress
1797 	 * table. Must free vnode we acquired with successful lookupname.
1798 	 */
1799 	if (addmip)
1800 		VN_RELE(bvp);
1801 	if (delmip)
1802 		vfs_delmip(vfsp);
1803 	ASSERT(vswp != NULL);
1804 	vfs_unrefvfssw(vswp);
1805 	if (inargs != opts)
1806 		kmem_free(inargs, MAX_MNTOPT_STR);
1807 	if (copyout_error) {
1808 		lofi_remove(vfsp);
1809 		VFS_RELE(vfsp);
1810 		error = copyout_error;
1811 	}
1812 	return (error);
1813 }
1814 
1815 static void
1816 vfs_setpath(
1817     struct vfs *vfsp,		/* vfs being updated */
1818     refstr_t **refp,		/* Ref-count string to contain the new path */
1819     const char *newpath,	/* Path to add to refp (above) */
1820     uint32_t flag)		/* flag */
1821 {
1822 	size_t len;
1823 	refstr_t *ref;
1824 	zone_t *zone = curproc->p_zone;
1825 	char *sp;
1826 	int have_list_lock = 0;
1827 
1828 	ASSERT(!VFS_ON_LIST(vfsp) || vfs_lock_held(vfsp));
1829 
1830 	/*
1831 	 * New path must be less than MAXPATHLEN because mntfs
1832 	 * will only display up to MAXPATHLEN bytes. This is currently
1833 	 * safe, because domount() uses pn_get(), and other callers
1834 	 * similarly cap the size to fewer than MAXPATHLEN bytes.
1835 	 */
1836 
1837 	ASSERT(strlen(newpath) < MAXPATHLEN);
1838 
1839 	/* mntfs requires consistency while vfs list lock is held */
1840 
1841 	if (VFS_ON_LIST(vfsp)) {
1842 		have_list_lock = 1;
1843 		vfs_list_lock();
1844 	}
1845 
1846 	if (*refp != NULL)
1847 		refstr_rele(*refp);
1848 
1849 	/*
1850 	 * If we are in a non-global zone then we prefix the supplied path,
1851 	 * newpath, with the zone's root path, with two exceptions. The first
1852 	 * is where we have been explicitly directed to avoid doing so; this
1853 	 * will be the case following a failed remount, where the path supplied
1854 	 * will be a saved version which must now be restored. The second
1855 	 * exception is where newpath is not a pathname but a descriptive name,
1856 	 * e.g. "procfs".
1857 	 */
1858 	if (zone == global_zone || (flag & VFSSP_VERBATIM) || *newpath != '/') {
1859 		ref = refstr_alloc(newpath);
1860 		goto out;
1861 	}
1862 
1863 	/*
1864 	 * Truncate the trailing '/' in the zoneroot, and merge
1865 	 * in the zone's rootpath with the "newpath" (resource
1866 	 * or mountpoint) passed in.
1867 	 *
1868 	 * The size of the required buffer is thus the size of
1869 	 * the buffer required for the passed-in newpath
1870 	 * (strlen(newpath) + 1), plus the size of the buffer
1871 	 * required to hold zone_rootpath (zone_rootpathlen)
1872 	 * minus one for one of the now-superfluous NUL
1873 	 * terminations, minus one for the trailing '/'.
1874 	 *
1875 	 * That gives us:
1876 	 *
1877 	 * (strlen(newpath) + 1) + zone_rootpathlen - 1 - 1
1878 	 *
1879 	 * Which is what we have below.
1880 	 */
1881 
1882 	len = strlen(newpath) + zone->zone_rootpathlen - 1;
1883 	sp = kmem_alloc(len, KM_SLEEP);
1884 
1885 	/*
1886 	 * Copy everything including the trailing slash, which
1887 	 * we then overwrite with the NUL character.
1888 	 */
1889 
1890 	(void) strcpy(sp, zone->zone_rootpath);
1891 	sp[zone->zone_rootpathlen - 2] = '\0';
1892 	(void) strcat(sp, newpath);
1893 
1894 	ref = refstr_alloc(sp);
1895 	kmem_free(sp, len);
1896 out:
1897 	*refp = ref;
1898 
1899 	if (have_list_lock) {
1900 		vfs_mnttab_modtimeupd();
1901 		vfs_list_unlock();
1902 	}
1903 }
1904 
1905 /*
1906  * Record a mounted resource name in a vfs structure.
1907  * If vfsp is already mounted, caller must hold the vfs lock.
1908  */
1909 void
1910 vfs_setresource(struct vfs *vfsp, const char *resource, uint32_t flag)
1911 {
1912 	if (resource == NULL || resource[0] == '\0')
1913 		resource = VFS_NORESOURCE;
1914 	vfs_setpath(vfsp, &vfsp->vfs_resource, resource, flag);
1915 }
1916 
1917 /*
1918  * Record a mount point name in a vfs structure.
1919  * If vfsp is already mounted, caller must hold the vfs lock.
1920  */
1921 void
1922 vfs_setmntpoint(struct vfs *vfsp, const char *mntpt, uint32_t flag)
1923 {
1924 	if (mntpt == NULL || mntpt[0] == '\0')
1925 		mntpt = VFS_NOMNTPT;
1926 	vfs_setpath(vfsp, &vfsp->vfs_mntpt, mntpt, flag);
1927 }
1928 
1929 /* Returns the vfs_resource. Caller must call refstr_rele() when finished. */
1930 
1931 refstr_t *
1932 vfs_getresource(const struct vfs *vfsp)
1933 {
1934 	refstr_t *resource;
1935 
1936 	vfs_list_read_lock();
1937 	resource = vfsp->vfs_resource;
1938 	refstr_hold(resource);
1939 	vfs_list_unlock();
1940 
1941 	return (resource);
1942 }
1943 
1944 /* Returns the vfs_mntpt. Caller must call refstr_rele() when finished. */
1945 
1946 refstr_t *
1947 vfs_getmntpoint(const struct vfs *vfsp)
1948 {
1949 	refstr_t *mntpt;
1950 
1951 	vfs_list_read_lock();
1952 	mntpt = vfsp->vfs_mntpt;
1953 	refstr_hold(mntpt);
1954 	vfs_list_unlock();
1955 
1956 	return (mntpt);
1957 }
1958 
1959 /*
1960  * Create an empty options table with enough empty slots to hold all
1961  * The options in the options string passed as an argument.
1962  * Potentially prepend another options table.
1963  *
1964  * Note: caller is responsible for locking the vfs list, if needed,
1965  *       to protect mops.
1966  */
1967 static void
1968 vfs_createopttbl_extend(mntopts_t *mops, const char *opts,
1969     const mntopts_t *mtmpl)
1970 {
1971 	const char *s = opts;
1972 	uint_t count;
1973 
1974 	if (opts == NULL || *opts == '\0') {
1975 		count = 0;
1976 	} else {
1977 		count = 1;
1978 
1979 		/*
1980 		 * Count number of options in the string
1981 		 */
1982 		for (s = strchr(s, ','); s != NULL; s = strchr(s, ',')) {
1983 			count++;
1984 			s++;
1985 		}
1986 	}
1987 	vfs_copyopttbl_extend(mtmpl, mops, count);
1988 }
1989 
1990 /*
1991  * Create an empty options table with enough empty slots to hold all
1992  * The options in the options string passed as an argument.
1993  *
1994  * This function is *not* for general use by filesystems.
1995  *
1996  * Note: caller is responsible for locking the vfs list, if needed,
1997  *       to protect mops.
1998  */
1999 void
2000 vfs_createopttbl(mntopts_t *mops, const char *opts)
2001 {
2002 	vfs_createopttbl_extend(mops, opts, NULL);
2003 }
2004 
2005 
2006 /*
2007  * Swap two mount options tables
2008  */
2009 static void
2010 vfs_swapopttbl_nolock(mntopts_t *optbl1, mntopts_t *optbl2)
2011 {
2012 	uint_t tmpcnt;
2013 	mntopt_t *tmplist;
2014 
2015 	tmpcnt = optbl2->mo_count;
2016 	tmplist = optbl2->mo_list;
2017 	optbl2->mo_count = optbl1->mo_count;
2018 	optbl2->mo_list = optbl1->mo_list;
2019 	optbl1->mo_count = tmpcnt;
2020 	optbl1->mo_list = tmplist;
2021 }
2022 
2023 static void
2024 vfs_swapopttbl(mntopts_t *optbl1, mntopts_t *optbl2)
2025 {
2026 	vfs_list_lock();
2027 	vfs_swapopttbl_nolock(optbl1, optbl2);
2028 	vfs_mnttab_modtimeupd();
2029 	vfs_list_unlock();
2030 }
2031 
2032 static char **
2033 vfs_copycancelopt_extend(char **const moc, int extend)
2034 {
2035 	int i = 0;
2036 	int j;
2037 	char **result;
2038 
2039 	if (moc != NULL) {
2040 		for (; moc[i] != NULL; i++)
2041 			/* count number of options to cancel */;
2042 	}
2043 
2044 	if (i + extend == 0)
2045 		return (NULL);
2046 
2047 	result = kmem_alloc((i + extend + 1) * sizeof (char *), KM_SLEEP);
2048 
2049 	for (j = 0; j < i; j++) {
2050 		result[j] = kmem_alloc(strlen(moc[j]) + 1, KM_SLEEP);
2051 		(void) strcpy(result[j], moc[j]);
2052 	}
2053 	for (; j <= i + extend; j++)
2054 		result[j] = NULL;
2055 
2056 	return (result);
2057 }
2058 
2059 static void
2060 vfs_copyopt(const mntopt_t *s, mntopt_t *d)
2061 {
2062 	char *sp, *dp;
2063 
2064 	d->mo_flags = s->mo_flags;
2065 	d->mo_data = s->mo_data;
2066 	sp = s->mo_name;
2067 	if (sp != NULL) {
2068 		dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2069 		(void) strcpy(dp, sp);
2070 		d->mo_name = dp;
2071 	} else {
2072 		d->mo_name = NULL; /* should never happen */
2073 	}
2074 
2075 	d->mo_cancel = vfs_copycancelopt_extend(s->mo_cancel, 0);
2076 
2077 	sp = s->mo_arg;
2078 	if (sp != NULL) {
2079 		dp = kmem_alloc(strlen(sp) + 1, KM_SLEEP);
2080 		(void) strcpy(dp, sp);
2081 		d->mo_arg = dp;
2082 	} else {
2083 		d->mo_arg = NULL;
2084 	}
2085 }
2086 
2087 /*
2088  * Copy a mount options table, possibly allocating some spare
2089  * slots at the end.  It is permissible to copy_extend the NULL table.
2090  */
2091 static void
2092 vfs_copyopttbl_extend(const mntopts_t *smo, mntopts_t *dmo, int extra)
2093 {
2094 	uint_t i, count;
2095 	mntopt_t *motbl;
2096 
2097 	/*
2098 	 * Clear out any existing stuff in the options table being initialized
2099 	 */
2100 	vfs_freeopttbl(dmo);
2101 	count = (smo == NULL) ? 0 : smo->mo_count;
2102 	if ((count + extra) == 0)	/* nothing to do */
2103 		return;
2104 	dmo->mo_count = count + extra;
2105 	motbl = kmem_zalloc((count + extra) * sizeof (mntopt_t), KM_SLEEP);
2106 	dmo->mo_list = motbl;
2107 	for (i = 0; i < count; i++) {
2108 		vfs_copyopt(&smo->mo_list[i], &motbl[i]);
2109 	}
2110 	for (i = count; i < count + extra; i++) {
2111 		motbl[i].mo_flags = MO_EMPTY;
2112 	}
2113 }
2114 
2115 /*
2116  * Copy a mount options table.
2117  *
2118  * This function is *not* for general use by filesystems.
2119  *
2120  * Note: caller is responsible for locking the vfs list, if needed,
2121  *       to protect smo and dmo.
2122  */
2123 void
2124 vfs_copyopttbl(const mntopts_t *smo, mntopts_t *dmo)
2125 {
2126 	vfs_copyopttbl_extend(smo, dmo, 0);
2127 }
2128 
2129 static char **
2130 vfs_mergecancelopts(const mntopt_t *mop1, const mntopt_t *mop2)
2131 {
2132 	int c1 = 0;
2133 	int c2 = 0;
2134 	char **result;
2135 	char **sp1, **sp2, **dp;
2136 
2137 	/*
2138 	 * First we count both lists of cancel options.
2139 	 * If either is NULL or has no elements, we return a copy of
2140 	 * the other.
2141 	 */
2142 	if (mop1->mo_cancel != NULL) {
2143 		for (; mop1->mo_cancel[c1] != NULL; c1++)
2144 			/* count cancel options in mop1 */;
2145 	}
2146 
2147 	if (c1 == 0)
2148 		return (vfs_copycancelopt_extend(mop2->mo_cancel, 0));
2149 
2150 	if (mop2->mo_cancel != NULL) {
2151 		for (; mop2->mo_cancel[c2] != NULL; c2++)
2152 			/* count cancel options in mop2 */;
2153 	}
2154 
2155 	result = vfs_copycancelopt_extend(mop1->mo_cancel, c2);
2156 
2157 	if (c2 == 0)
2158 		return (result);
2159 
2160 	/*
2161 	 * When we get here, we've got two sets of cancel options;
2162 	 * we need to merge the two sets.  We know that the result
2163 	 * array has "c1+c2+1" entries and in the end we might shrink
2164 	 * it.
2165 	 * Result now has a copy of the c1 entries from mop1; we'll
2166 	 * now lookup all the entries of mop2 in mop1 and copy it if
2167 	 * it is unique.
2168 	 * This operation is O(n^2) but it's only called once per
2169 	 * filesystem per duplicate option.  This is a situation
2170 	 * which doesn't arise with the filesystems in ON and
2171 	 * n is generally 1.
2172 	 */
2173 
2174 	dp = &result[c1];
2175 	for (sp2 = mop2->mo_cancel; *sp2 != NULL; sp2++) {
2176 		for (sp1 = mop1->mo_cancel; *sp1 != NULL; sp1++) {
2177 			if (strcmp(*sp1, *sp2) == 0)
2178 				break;
2179 		}
2180 		if (*sp1 == NULL) {
2181 			/*
2182 			 * Option *sp2 not found in mop1, so copy it.
2183 			 * The calls to vfs_copycancelopt_extend()
2184 			 * guarantee that there's enough room.
2185 			 */
2186 			*dp = kmem_alloc(strlen(*sp2) + 1, KM_SLEEP);
2187 			(void) strcpy(*dp++, *sp2);
2188 		}
2189 	}
2190 	if (dp != &result[c1+c2]) {
2191 		size_t bytes = (dp - result + 1) * sizeof (char *);
2192 		char **nres = kmem_alloc(bytes, KM_SLEEP);
2193 
2194 		bcopy(result, nres, bytes);
2195 		kmem_free(result, (c1 + c2 + 1) * sizeof (char *));
2196 		result = nres;
2197 	}
2198 	return (result);
2199 }
2200 
2201 /*
2202  * Merge two mount option tables (outer and inner) into one.  This is very
2203  * similar to "merging" global variables and automatic variables in C.
2204  *
2205  * This isn't (and doesn't have to be) fast.
2206  *
2207  * This function is *not* for general use by filesystems.
2208  *
2209  * Note: caller is responsible for locking the vfs list, if needed,
2210  *       to protect omo, imo & dmo.
2211  */
2212 void
2213 vfs_mergeopttbl(const mntopts_t *omo, const mntopts_t *imo, mntopts_t *dmo)
2214 {
2215 	uint_t i, count;
2216 	mntopt_t *mop, *motbl;
2217 	uint_t freeidx;
2218 
2219 	/*
2220 	 * First determine how much space we need to allocate.
2221 	 */
2222 	count = omo->mo_count;
2223 	for (i = 0; i < imo->mo_count; i++) {
2224 		if (imo->mo_list[i].mo_flags & MO_EMPTY)
2225 			continue;
2226 		if (vfs_hasopt(omo, imo->mo_list[i].mo_name) == NULL)
2227 			count++;
2228 	}
2229 	ASSERT(count >= omo->mo_count &&
2230 	    count <= omo->mo_count + imo->mo_count);
2231 	motbl = kmem_alloc(count * sizeof (mntopt_t), KM_SLEEP);
2232 	for (i = 0; i < omo->mo_count; i++)
2233 		vfs_copyopt(&omo->mo_list[i], &motbl[i]);
2234 	freeidx = omo->mo_count;
2235 	for (i = 0; i < imo->mo_count; i++) {
2236 		if (imo->mo_list[i].mo_flags & MO_EMPTY)
2237 			continue;
2238 		if ((mop = vfs_hasopt(omo, imo->mo_list[i].mo_name)) != NULL) {
2239 			char **newcanp;
2240 			uint_t index = mop - omo->mo_list;
2241 
2242 			newcanp = vfs_mergecancelopts(mop, &motbl[index]);
2243 
2244 			vfs_freeopt(&motbl[index]);
2245 			vfs_copyopt(&imo->mo_list[i], &motbl[index]);
2246 
2247 			vfs_freecancelopt(motbl[index].mo_cancel);
2248 			motbl[index].mo_cancel = newcanp;
2249 		} else {
2250 			/*
2251 			 * If it's a new option, just copy it over to the first
2252 			 * free location.
2253 			 */
2254 			vfs_copyopt(&imo->mo_list[i], &motbl[freeidx++]);
2255 		}
2256 	}
2257 	dmo->mo_count = count;
2258 	dmo->mo_list = motbl;
2259 }
2260 
2261 /*
2262  * Functions to set and clear mount options in a mount options table.
2263  */
2264 
2265 /*
2266  * Clear a mount option, if it exists.
2267  *
2268  * The update_mnttab arg indicates whether mops is part of a vfs that is on
2269  * the vfs list.
2270  */
2271 static void
2272 vfs_clearmntopt_nolock(mntopts_t *mops, const char *opt, int update_mnttab)
2273 {
2274 	struct mntopt *mop;
2275 	uint_t i, count;
2276 
2277 	ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2278 
2279 	count = mops->mo_count;
2280 	for (i = 0; i < count; i++) {
2281 		mop = &mops->mo_list[i];
2282 
2283 		if (mop->mo_flags & MO_EMPTY)
2284 			continue;
2285 		if (strcmp(opt, mop->mo_name))
2286 			continue;
2287 		mop->mo_flags &= ~MO_SET;
2288 		if (mop->mo_arg != NULL) {
2289 			kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2290 		}
2291 		mop->mo_arg = NULL;
2292 		if (update_mnttab)
2293 			vfs_mnttab_modtimeupd();
2294 		break;
2295 	}
2296 }
2297 
2298 void
2299 vfs_clearmntopt(struct vfs *vfsp, const char *opt)
2300 {
2301 	int gotlock = 0;
2302 
2303 	if (VFS_ON_LIST(vfsp)) {
2304 		gotlock = 1;
2305 		vfs_list_lock();
2306 	}
2307 	vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, opt, gotlock);
2308 	if (gotlock)
2309 		vfs_list_unlock();
2310 }
2311 
2312 
2313 /*
2314  * Set a mount option on.  If it's not found in the table, it's silently
2315  * ignored.  If the option has MO_IGNORE set, it is still set unless the
2316  * VFS_NOFORCEOPT bit is set in the flags.  Also, VFS_DISPLAY/VFS_NODISPLAY flag
2317  * bits can be used to toggle the MO_NODISPLAY bit for the option.
2318  * If the VFS_CREATEOPT flag bit is set then the first option slot with
2319  * MO_EMPTY set is created as the option passed in.
2320  *
2321  * The update_mnttab arg indicates whether mops is part of a vfs that is on
2322  * the vfs list.
2323  */
2324 static void
2325 vfs_setmntopt_nolock(mntopts_t *mops, const char *opt,
2326     const char *arg, int flags, int update_mnttab)
2327 {
2328 	mntopt_t *mop;
2329 	uint_t i, count;
2330 	char *sp;
2331 
2332 	ASSERT(!update_mnttab || RW_WRITE_HELD(&vfslist));
2333 
2334 	if (flags & VFS_CREATEOPT) {
2335 		if (vfs_hasopt(mops, opt) != NULL) {
2336 			flags &= ~VFS_CREATEOPT;
2337 		}
2338 	}
2339 	count = mops->mo_count;
2340 	for (i = 0; i < count; i++) {
2341 		mop = &mops->mo_list[i];
2342 
2343 		if (mop->mo_flags & MO_EMPTY) {
2344 			if ((flags & VFS_CREATEOPT) == 0)
2345 				continue;
2346 			sp = kmem_alloc(strlen(opt) + 1, KM_SLEEP);
2347 			(void) strcpy(sp, opt);
2348 			mop->mo_name = sp;
2349 			if (arg != NULL)
2350 				mop->mo_flags = MO_HASVALUE;
2351 			else
2352 				mop->mo_flags = 0;
2353 		} else if (strcmp(opt, mop->mo_name)) {
2354 			continue;
2355 		}
2356 		if ((mop->mo_flags & MO_IGNORE) && (flags & VFS_NOFORCEOPT))
2357 			break;
2358 		if (arg != NULL && (mop->mo_flags & MO_HASVALUE) != 0) {
2359 			sp = kmem_alloc(strlen(arg) + 1, KM_SLEEP);
2360 			(void) strcpy(sp, arg);
2361 		} else {
2362 			sp = NULL;
2363 		}
2364 		if (mop->mo_arg != NULL)
2365 			kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2366 		mop->mo_arg = sp;
2367 		if (flags & VFS_DISPLAY)
2368 			mop->mo_flags &= ~MO_NODISPLAY;
2369 		if (flags & VFS_NODISPLAY)
2370 			mop->mo_flags |= MO_NODISPLAY;
2371 		mop->mo_flags |= MO_SET;
2372 		if (mop->mo_cancel != NULL) {
2373 			char **cp;
2374 
2375 			for (cp = mop->mo_cancel; *cp != NULL; cp++)
2376 				vfs_clearmntopt_nolock(mops, *cp, 0);
2377 		}
2378 		if (update_mnttab)
2379 			vfs_mnttab_modtimeupd();
2380 		break;
2381 	}
2382 }
2383 
2384 void
2385 vfs_setmntopt(struct vfs *vfsp, const char *opt, const char *arg, int flags)
2386 {
2387 	int gotlock = 0;
2388 
2389 	if (VFS_ON_LIST(vfsp)) {
2390 		gotlock = 1;
2391 		vfs_list_lock();
2392 	}
2393 	vfs_setmntopt_nolock(&vfsp->vfs_mntopts, opt, arg, flags, gotlock);
2394 	if (gotlock)
2395 		vfs_list_unlock();
2396 }
2397 
2398 
2399 /*
2400  * Add a "tag" option to a mounted file system's options list.
2401  *
2402  * Note: caller is responsible for locking the vfs list, if needed,
2403  *       to protect mops.
2404  */
2405 static mntopt_t *
2406 vfs_addtag(mntopts_t *mops, const char *tag)
2407 {
2408 	uint_t count;
2409 	mntopt_t *mop, *motbl;
2410 
2411 	count = mops->mo_count + 1;
2412 	motbl = kmem_zalloc(count * sizeof (mntopt_t), KM_SLEEP);
2413 	if (mops->mo_count) {
2414 		size_t len = (count - 1) * sizeof (mntopt_t);
2415 
2416 		bcopy(mops->mo_list, motbl, len);
2417 		kmem_free(mops->mo_list, len);
2418 	}
2419 	mops->mo_count = count;
2420 	mops->mo_list = motbl;
2421 	mop = &motbl[count - 1];
2422 	mop->mo_flags = MO_TAG;
2423 	mop->mo_name = kmem_alloc(strlen(tag) + 1, KM_SLEEP);
2424 	(void) strcpy(mop->mo_name, tag);
2425 	return (mop);
2426 }
2427 
2428 /*
2429  * Allow users to set arbitrary "tags" in a vfs's mount options.
2430  * Broader use within the kernel is discouraged.
2431  */
2432 int
2433 vfs_settag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2434     cred_t *cr)
2435 {
2436 	vfs_t *vfsp;
2437 	mntopts_t *mops;
2438 	mntopt_t *mop;
2439 	int found = 0;
2440 	dev_t dev = makedevice(major, minor);
2441 	int err = 0;
2442 	char *buf = kmem_alloc(MAX_MNTOPT_STR, KM_SLEEP);
2443 
2444 	/*
2445 	 * Find the desired mounted file system
2446 	 */
2447 	vfs_list_lock();
2448 	vfsp = rootvfs;
2449 	do {
2450 		if (vfsp->vfs_dev == dev &&
2451 		    strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2452 			found = 1;
2453 			break;
2454 		}
2455 		vfsp = vfsp->vfs_next;
2456 	} while (vfsp != rootvfs);
2457 
2458 	if (!found) {
2459 		err = EINVAL;
2460 		goto out;
2461 	}
2462 	err = secpolicy_fs_config(cr, vfsp);
2463 	if (err != 0)
2464 		goto out;
2465 
2466 	mops = &vfsp->vfs_mntopts;
2467 	/*
2468 	 * Add tag if it doesn't already exist
2469 	 */
2470 	if ((mop = vfs_hasopt(mops, tag)) == NULL) {
2471 		int len;
2472 
2473 		(void) vfs_buildoptionstr(mops, buf, MAX_MNTOPT_STR);
2474 		len = strlen(buf);
2475 		if (len + strlen(tag) + 2 > MAX_MNTOPT_STR) {
2476 			err = ENAMETOOLONG;
2477 			goto out;
2478 		}
2479 		mop = vfs_addtag(mops, tag);
2480 	}
2481 	if ((mop->mo_flags & MO_TAG) == 0) {
2482 		err = EINVAL;
2483 		goto out;
2484 	}
2485 	vfs_setmntopt_nolock(mops, tag, NULL, 0, 1);
2486 out:
2487 	vfs_list_unlock();
2488 	kmem_free(buf, MAX_MNTOPT_STR);
2489 	return (err);
2490 }
2491 
2492 /*
2493  * Allow users to remove arbitrary "tags" in a vfs's mount options.
2494  * Broader use within the kernel is discouraged.
2495  */
2496 int
2497 vfs_clrtag(uint_t major, uint_t minor, const char *mntpt, const char *tag,
2498     cred_t *cr)
2499 {
2500 	vfs_t *vfsp;
2501 	mntopt_t *mop;
2502 	int found = 0;
2503 	dev_t dev = makedevice(major, minor);
2504 	int err = 0;
2505 
2506 	/*
2507 	 * Find the desired mounted file system
2508 	 */
2509 	vfs_list_lock();
2510 	vfsp = rootvfs;
2511 	do {
2512 		if (vfsp->vfs_dev == dev &&
2513 		    strcmp(mntpt, refstr_value(vfsp->vfs_mntpt)) == 0) {
2514 			found = 1;
2515 			break;
2516 		}
2517 		vfsp = vfsp->vfs_next;
2518 	} while (vfsp != rootvfs);
2519 
2520 	if (!found) {
2521 		err = EINVAL;
2522 		goto out;
2523 	}
2524 	err = secpolicy_fs_config(cr, vfsp);
2525 	if (err != 0)
2526 		goto out;
2527 
2528 	if ((mop = vfs_hasopt(&vfsp->vfs_mntopts, tag)) == NULL) {
2529 		err = EINVAL;
2530 		goto out;
2531 	}
2532 	if ((mop->mo_flags & MO_TAG) == 0) {
2533 		err = EINVAL;
2534 		goto out;
2535 	}
2536 	vfs_clearmntopt_nolock(&vfsp->vfs_mntopts, tag, 1);
2537 out:
2538 	vfs_list_unlock();
2539 	return (err);
2540 }
2541 
2542 /*
2543  * Function to parse an option string and fill in a mount options table.
2544  * Unknown options are silently ignored.  The input option string is modified
2545  * by replacing separators with nulls.  If the create flag is set, options
2546  * not found in the table are just added on the fly.  The table must have
2547  * an option slot marked MO_EMPTY to add an option on the fly.
2548  *
2549  * This function is *not* for general use by filesystems.
2550  *
2551  * Note: caller is responsible for locking the vfs list, if needed,
2552  *       to protect mops..
2553  */
2554 void
2555 vfs_parsemntopts(mntopts_t *mops, char *osp, int create)
2556 {
2557 	char *s = osp, *p, *nextop, *valp, *cp, *ep;
2558 	int setflg = VFS_NOFORCEOPT;
2559 
2560 	if (osp == NULL)
2561 		return;
2562 	while (*s != '\0') {
2563 		p = strchr(s, ',');	/* find next option */
2564 		if (p == NULL) {
2565 			cp = NULL;
2566 			p = s + strlen(s);
2567 		} else {
2568 			cp = p;		/* save location of comma */
2569 			*p++ = '\0';	/* mark end and point to next option */
2570 		}
2571 		nextop = p;
2572 		p = strchr(s, '=');	/* look for value */
2573 		if (p == NULL) {
2574 			valp = NULL;	/* no value supplied */
2575 		} else {
2576 			ep = p;		/* save location of equals */
2577 			*p++ = '\0';	/* end option and point to value */
2578 			valp = p;
2579 		}
2580 		/*
2581 		 * set option into options table
2582 		 */
2583 		if (create)
2584 			setflg |= VFS_CREATEOPT;
2585 		vfs_setmntopt_nolock(mops, s, valp, setflg, 0);
2586 		if (cp != NULL)
2587 			*cp = ',';	/* restore the comma */
2588 		if (valp != NULL)
2589 			*ep = '=';	/* restore the equals */
2590 		s = nextop;
2591 	}
2592 }
2593 
2594 /*
2595  * Function to inquire if an option exists in a mount options table.
2596  * Returns a pointer to the option if it exists, else NULL.
2597  *
2598  * This function is *not* for general use by filesystems.
2599  *
2600  * Note: caller is responsible for locking the vfs list, if needed,
2601  *       to protect mops.
2602  */
2603 struct mntopt *
2604 vfs_hasopt(const mntopts_t *mops, const char *opt)
2605 {
2606 	struct mntopt *mop;
2607 	uint_t i, count;
2608 
2609 	count = mops->mo_count;
2610 	for (i = 0; i < count; i++) {
2611 		mop = &mops->mo_list[i];
2612 
2613 		if (mop->mo_flags & MO_EMPTY)
2614 			continue;
2615 		if (strcmp(opt, mop->mo_name) == 0)
2616 			return (mop);
2617 	}
2618 	return (NULL);
2619 }
2620 
2621 /*
2622  * Function to inquire if an option is set in a mount options table.
2623  * Returns non-zero if set and fills in the arg pointer with a pointer to
2624  * the argument string or NULL if there is no argument string.
2625  */
2626 static int
2627 vfs_optionisset_nolock(const mntopts_t *mops, const char *opt, char **argp)
2628 {
2629 	struct mntopt *mop;
2630 	uint_t i, count;
2631 
2632 	count = mops->mo_count;
2633 	for (i = 0; i < count; i++) {
2634 		mop = &mops->mo_list[i];
2635 
2636 		if (mop->mo_flags & MO_EMPTY)
2637 			continue;
2638 		if (strcmp(opt, mop->mo_name))
2639 			continue;
2640 		if ((mop->mo_flags & MO_SET) == 0)
2641 			return (0);
2642 		if (argp != NULL && (mop->mo_flags & MO_HASVALUE) != 0)
2643 			*argp = mop->mo_arg;
2644 		return (1);
2645 	}
2646 	return (0);
2647 }
2648 
2649 
2650 int
2651 vfs_optionisset(const struct vfs *vfsp, const char *opt, char **argp)
2652 {
2653 	int ret;
2654 
2655 	vfs_list_read_lock();
2656 	ret = vfs_optionisset_nolock(&vfsp->vfs_mntopts, opt, argp);
2657 	vfs_list_unlock();
2658 	return (ret);
2659 }
2660 
2661 
2662 /*
2663  * Construct a comma separated string of the options set in the given
2664  * mount table, return the string in the given buffer.  Return non-zero if
2665  * the buffer would overflow.
2666  *
2667  * This function is *not* for general use by filesystems.
2668  *
2669  * Note: caller is responsible for locking the vfs list, if needed,
2670  *       to protect mp.
2671  */
2672 int
2673 vfs_buildoptionstr(const mntopts_t *mp, char *buf, int len)
2674 {
2675 	char *cp;
2676 	uint_t i;
2677 
2678 	buf[0] = '\0';
2679 	cp = buf;
2680 	for (i = 0; i < mp->mo_count; i++) {
2681 		struct mntopt *mop;
2682 
2683 		mop = &mp->mo_list[i];
2684 		if (mop->mo_flags & MO_SET) {
2685 			int optlen, comma = 0;
2686 
2687 			if (buf[0] != '\0')
2688 				comma = 1;
2689 			optlen = strlen(mop->mo_name);
2690 			if (strlen(buf) + comma + optlen + 1 > len)
2691 				goto err;
2692 			if (comma)
2693 				*cp++ = ',';
2694 			(void) strcpy(cp, mop->mo_name);
2695 			cp += optlen;
2696 			/*
2697 			 * Append option value if there is one
2698 			 */
2699 			if (mop->mo_arg != NULL) {
2700 				int arglen;
2701 
2702 				arglen = strlen(mop->mo_arg);
2703 				if (strlen(buf) + arglen + 2 > len)
2704 					goto err;
2705 				*cp++ = '=';
2706 				(void) strcpy(cp, mop->mo_arg);
2707 				cp += arglen;
2708 			}
2709 		}
2710 	}
2711 	return (0);
2712 err:
2713 	return (EOVERFLOW);
2714 }
2715 
2716 static void
2717 vfs_freecancelopt(char **moc)
2718 {
2719 	if (moc != NULL) {
2720 		int ccnt = 0;
2721 		char **cp;
2722 
2723 		for (cp = moc; *cp != NULL; cp++) {
2724 			kmem_free(*cp, strlen(*cp) + 1);
2725 			ccnt++;
2726 		}
2727 		kmem_free(moc, (ccnt + 1) * sizeof (char *));
2728 	}
2729 }
2730 
2731 static void
2732 vfs_freeopt(mntopt_t *mop)
2733 {
2734 	if (mop->mo_name != NULL)
2735 		kmem_free(mop->mo_name, strlen(mop->mo_name) + 1);
2736 
2737 	vfs_freecancelopt(mop->mo_cancel);
2738 
2739 	if (mop->mo_arg != NULL)
2740 		kmem_free(mop->mo_arg, strlen(mop->mo_arg) + 1);
2741 }
2742 
2743 /*
2744  * Free a mount options table
2745  *
2746  * This function is *not* for general use by filesystems.
2747  *
2748  * Note: caller is responsible for locking the vfs list, if needed,
2749  *       to protect mp.
2750  */
2751 void
2752 vfs_freeopttbl(mntopts_t *mp)
2753 {
2754 	uint_t i, count;
2755 
2756 	count = mp->mo_count;
2757 	for (i = 0; i < count; i++) {
2758 		vfs_freeopt(&mp->mo_list[i]);
2759 	}
2760 	if (count) {
2761 		kmem_free(mp->mo_list, sizeof (mntopt_t) * count);
2762 		mp->mo_count = 0;
2763 		mp->mo_list = NULL;
2764 	}
2765 }
2766 
2767 
2768 /* ARGSUSED */
2769 static int
2770 vfs_mntdummyread(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2771 	caller_context_t *ct)
2772 {
2773 	return (0);
2774 }
2775 
2776 /* ARGSUSED */
2777 static int
2778 vfs_mntdummywrite(vnode_t *vp, uio_t *uio, int ioflag, cred_t *cred,
2779 	caller_context_t *ct)
2780 {
2781 	return (0);
2782 }
2783 
2784 /*
2785  * The dummy vnode is currently used only by file events notification
2786  * module which is just interested in the timestamps.
2787  */
2788 /* ARGSUSED */
2789 static int
2790 vfs_mntdummygetattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr,
2791     caller_context_t *ct)
2792 {
2793 	bzero(vap, sizeof (vattr_t));
2794 	vap->va_type = VREG;
2795 	vap->va_nlink = 1;
2796 	vap->va_ctime = vfs_mnttab_ctime;
2797 	/*
2798 	 * it is ok to just copy mtime as the time will be monotonically
2799 	 * increasing.
2800 	 */
2801 	vap->va_mtime = vfs_mnttab_mtime;
2802 	vap->va_atime = vap->va_mtime;
2803 	return (0);
2804 }
2805 
2806 static void
2807 vfs_mnttabvp_setup(void)
2808 {
2809 	vnode_t *tvp;
2810 	vnodeops_t *vfs_mntdummyvnops;
2811 	const fs_operation_def_t mnt_dummyvnodeops_template[] = {
2812 		VOPNAME_READ, 		{ .vop_read = vfs_mntdummyread },
2813 		VOPNAME_WRITE, 		{ .vop_write = vfs_mntdummywrite },
2814 		VOPNAME_GETATTR,	{ .vop_getattr = vfs_mntdummygetattr },
2815 		VOPNAME_VNEVENT,	{ .vop_vnevent = fs_vnevent_support },
2816 		NULL,			NULL
2817 	};
2818 
2819 	if (vn_make_ops("mnttab", mnt_dummyvnodeops_template,
2820 	    &vfs_mntdummyvnops) != 0) {
2821 		cmn_err(CE_WARN, "vfs_mnttabvp_setup: vn_make_ops failed");
2822 		/* Shouldn't happen, but not bad enough to panic */
2823 		return;
2824 	}
2825 
2826 	/*
2827 	 * A global dummy vnode is allocated to represent mntfs files.
2828 	 * The mntfs file (/etc/mnttab) can be monitored for file events
2829 	 * and receive an event when mnttab changes. Dummy VOP calls
2830 	 * will be made on this vnode. The file events notification module
2831 	 * intercepts this vnode and delivers relevant events.
2832 	 */
2833 	tvp = vn_alloc(KM_SLEEP);
2834 	tvp->v_flag = VNOMOUNT|VNOMAP|VNOSWAP|VNOCACHE;
2835 	vn_setops(tvp, vfs_mntdummyvnops);
2836 	tvp->v_type = VREG;
2837 	/*
2838 	 * The mnt dummy ops do not reference v_data.
2839 	 * No other module intercepting this vnode should either.
2840 	 * Just set it to point to itself.
2841 	 */
2842 	tvp->v_data = (caddr_t)tvp;
2843 	tvp->v_vfsp = rootvfs;
2844 	vfs_mntdummyvp = tvp;
2845 }
2846 
2847 /*
2848  * performs fake read/write ops
2849  */
2850 static void
2851 vfs_mnttab_rwop(int rw)
2852 {
2853 	struct uio	uio;
2854 	struct iovec	iov;
2855 	char	buf[1];
2856 
2857 	if (vfs_mntdummyvp == NULL)
2858 		return;
2859 
2860 	bzero(&uio, sizeof (uio));
2861 	bzero(&iov, sizeof (iov));
2862 	iov.iov_base = buf;
2863 	iov.iov_len = 0;
2864 	uio.uio_iov = &iov;
2865 	uio.uio_iovcnt = 1;
2866 	uio.uio_loffset = 0;
2867 	uio.uio_segflg = UIO_SYSSPACE;
2868 	uio.uio_resid = 0;
2869 	if (rw) {
2870 		(void) VOP_WRITE(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2871 	} else {
2872 		(void) VOP_READ(vfs_mntdummyvp, &uio, 0, kcred, NULL);
2873 	}
2874 }
2875 
2876 /*
2877  * Generate a write operation.
2878  */
2879 void
2880 vfs_mnttab_writeop(void)
2881 {
2882 	vfs_mnttab_rwop(1);
2883 }
2884 
2885 /*
2886  * Generate a read operation.
2887  */
2888 void
2889 vfs_mnttab_readop(void)
2890 {
2891 	vfs_mnttab_rwop(0);
2892 }
2893 
2894 /*
2895  * Free any mnttab information recorded in the vfs struct.
2896  * The vfs must not be on the vfs list.
2897  */
2898 static void
2899 vfs_freemnttab(struct vfs *vfsp)
2900 {
2901 	ASSERT(!VFS_ON_LIST(vfsp));
2902 
2903 	/*
2904 	 * Free device and mount point information
2905 	 */
2906 	if (vfsp->vfs_mntpt != NULL) {
2907 		refstr_rele(vfsp->vfs_mntpt);
2908 		vfsp->vfs_mntpt = NULL;
2909 	}
2910 	if (vfsp->vfs_resource != NULL) {
2911 		refstr_rele(vfsp->vfs_resource);
2912 		vfsp->vfs_resource = NULL;
2913 	}
2914 	/*
2915 	 * Now free mount options information
2916 	 */
2917 	vfs_freeopttbl(&vfsp->vfs_mntopts);
2918 }
2919 
2920 /*
2921  * Return the last mnttab modification time
2922  */
2923 void
2924 vfs_mnttab_modtime(timespec_t *ts)
2925 {
2926 	ASSERT(RW_LOCK_HELD(&vfslist));
2927 	*ts = vfs_mnttab_mtime;
2928 }
2929 
2930 /*
2931  * See if mnttab is changed
2932  */
2933 void
2934 vfs_mnttab_poll(timespec_t *old, struct pollhead **phpp)
2935 {
2936 	int changed;
2937 
2938 	*phpp = (struct pollhead *)NULL;
2939 
2940 	/*
2941 	 * Note: don't grab vfs list lock before accessing vfs_mnttab_mtime.
2942 	 * Can lead to deadlock against vfs_mnttab_modtimeupd(). It is safe
2943 	 * to not grab the vfs list lock because tv_sec is monotonically
2944 	 * increasing.
2945 	 */
2946 
2947 	changed = (old->tv_nsec != vfs_mnttab_mtime.tv_nsec) ||
2948 	    (old->tv_sec != vfs_mnttab_mtime.tv_sec);
2949 	if (!changed) {
2950 		*phpp = &vfs_pollhd;
2951 	}
2952 }
2953 
2954 /* Provide a unique and monotonically-increasing timestamp. */
2955 void
2956 vfs_mono_time(timespec_t *ts)
2957 {
2958 	static volatile hrtime_t hrt;		/* The saved time. */
2959 	hrtime_t	newhrt, oldhrt;		/* For effecting the CAS. */
2960 	timespec_t	newts;
2961 
2962 	/*
2963 	 * Try gethrestime() first, but be prepared to fabricate a sensible
2964 	 * answer at the first sign of any trouble.
2965 	 */
2966 	gethrestime(&newts);
2967 	newhrt = ts2hrt(&newts);
2968 	for (;;) {
2969 		oldhrt = hrt;
2970 		if (newhrt <= hrt)
2971 			newhrt = hrt + 1;
2972 		if (cas64((uint64_t *)&hrt, oldhrt, newhrt) == oldhrt)
2973 			break;
2974 	}
2975 	hrt2ts(newhrt, ts);
2976 }
2977 
2978 /*
2979  * Update the mnttab modification time and wake up any waiters for
2980  * mnttab changes
2981  */
2982 void
2983 vfs_mnttab_modtimeupd()
2984 {
2985 	hrtime_t oldhrt, newhrt;
2986 
2987 	ASSERT(RW_WRITE_HELD(&vfslist));
2988 	oldhrt = ts2hrt(&vfs_mnttab_mtime);
2989 	gethrestime(&vfs_mnttab_mtime);
2990 	newhrt = ts2hrt(&vfs_mnttab_mtime);
2991 	if (oldhrt == (hrtime_t)0)
2992 		vfs_mnttab_ctime = vfs_mnttab_mtime;
2993 	/*
2994 	 * Attempt to provide unique mtime (like uniqtime but not).
2995 	 */
2996 	if (newhrt == oldhrt) {
2997 		newhrt++;
2998 		hrt2ts(newhrt, &vfs_mnttab_mtime);
2999 	}
3000 	pollwakeup(&vfs_pollhd, (short)POLLRDBAND);
3001 	vfs_mnttab_writeop();
3002 }
3003 
3004 int
3005 dounmount(struct vfs *vfsp, int flag, cred_t *cr)
3006 {
3007 	vnode_t *coveredvp;
3008 	int error;
3009 	extern void teardown_vopstats(vfs_t *);
3010 
3011 	/*
3012 	 * Get covered vnode. This will be NULL if the vfs is not linked
3013 	 * into the file system name space (i.e., domount() with MNT_NOSPICE).
3014 	 */
3015 	coveredvp = vfsp->vfs_vnodecovered;
3016 	ASSERT(coveredvp == NULL || vn_vfswlock_held(coveredvp));
3017 
3018 	/*
3019 	 * Purge all dnlc entries for this vfs.
3020 	 */
3021 	(void) dnlc_purge_vfsp(vfsp, 0);
3022 
3023 	/* For forcible umount, skip VFS_SYNC() since it may hang */
3024 	if ((flag & MS_FORCE) == 0)
3025 		(void) VFS_SYNC(vfsp, 0, cr);
3026 
3027 	/*
3028 	 * Lock the vfs to maintain fs status quo during unmount.  This
3029 	 * has to be done after the sync because ufs_update tries to acquire
3030 	 * the vfs_reflock.
3031 	 */
3032 	vfs_lock_wait(vfsp);
3033 
3034 	if (error = VFS_UNMOUNT(vfsp, flag, cr)) {
3035 		vfs_unlock(vfsp);
3036 		if (coveredvp != NULL)
3037 			vn_vfsunlock(coveredvp);
3038 	} else if (coveredvp != NULL) {
3039 		teardown_vopstats(vfsp);
3040 		/*
3041 		 * vfs_remove() will do a VN_RELE(vfsp->vfs_vnodecovered)
3042 		 * when it frees vfsp so we do a VN_HOLD() so we can
3043 		 * continue to use coveredvp afterwards.
3044 		 */
3045 		VN_HOLD(coveredvp);
3046 		vfs_remove(vfsp);
3047 		vn_vfsunlock(coveredvp);
3048 		VN_RELE(coveredvp);
3049 	} else {
3050 		teardown_vopstats(vfsp);
3051 		/*
3052 		 * Release the reference to vfs that is not linked
3053 		 * into the name space.
3054 		 */
3055 		vfs_unlock(vfsp);
3056 		VFS_RELE(vfsp);
3057 	}
3058 	return (error);
3059 }
3060 
3061 
3062 /*
3063  * Vfs_unmountall() is called by uadmin() to unmount all
3064  * mounted file systems (except the root file system) during shutdown.
3065  * It follows the existing locking protocol when traversing the vfs list
3066  * to sync and unmount vfses. Even though there should be no
3067  * other thread running while the system is shutting down, it is prudent
3068  * to still follow the locking protocol.
3069  */
3070 void
3071 vfs_unmountall(void)
3072 {
3073 	struct vfs *vfsp;
3074 	struct vfs *prev_vfsp = NULL;
3075 	int error;
3076 
3077 	/*
3078 	 * Toss all dnlc entries now so that the per-vfs sync
3079 	 * and unmount operations don't have to slog through
3080 	 * a bunch of uninteresting vnodes over and over again.
3081 	 */
3082 	dnlc_purge();
3083 
3084 	vfs_list_lock();
3085 	for (vfsp = rootvfs->vfs_prev; vfsp != rootvfs; vfsp = prev_vfsp) {
3086 		prev_vfsp = vfsp->vfs_prev;
3087 
3088 		if (vfs_lock(vfsp) != 0)
3089 			continue;
3090 		error = vn_vfswlock(vfsp->vfs_vnodecovered);
3091 		vfs_unlock(vfsp);
3092 		if (error)
3093 			continue;
3094 
3095 		vfs_list_unlock();
3096 
3097 		(void) VFS_SYNC(vfsp, SYNC_CLOSE, CRED());
3098 		(void) dounmount(vfsp, 0, CRED());
3099 
3100 		/*
3101 		 * Since we dropped the vfslist lock above we must
3102 		 * verify that next_vfsp still exists, else start over.
3103 		 */
3104 		vfs_list_lock();
3105 		for (vfsp = rootvfs->vfs_prev;
3106 		    vfsp != rootvfs; vfsp = vfsp->vfs_prev)
3107 			if (vfsp == prev_vfsp)
3108 				break;
3109 		if (vfsp == rootvfs && prev_vfsp != rootvfs)
3110 			prev_vfsp = rootvfs->vfs_prev;
3111 	}
3112 	vfs_list_unlock();
3113 }
3114 
3115 /*
3116  * Called to add an entry to the end of the vfs mount in progress list
3117  */
3118 void
3119 vfs_addmip(dev_t dev, struct vfs *vfsp)
3120 {
3121 	struct ipmnt *mipp;
3122 
3123 	mipp = (struct ipmnt *)kmem_alloc(sizeof (struct ipmnt), KM_SLEEP);
3124 	mipp->mip_next = NULL;
3125 	mipp->mip_dev = dev;
3126 	mipp->mip_vfsp = vfsp;
3127 	mutex_enter(&vfs_miplist_mutex);
3128 	if (vfs_miplist_end != NULL)
3129 		vfs_miplist_end->mip_next = mipp;
3130 	else
3131 		vfs_miplist = mipp;
3132 	vfs_miplist_end = mipp;
3133 	mutex_exit(&vfs_miplist_mutex);
3134 }
3135 
3136 /*
3137  * Called to remove an entry from the mount in progress list
3138  * Either because the mount completed or it failed.
3139  */
3140 void
3141 vfs_delmip(struct vfs *vfsp)
3142 {
3143 	struct ipmnt *mipp, *mipprev;
3144 
3145 	mutex_enter(&vfs_miplist_mutex);
3146 	mipprev = NULL;
3147 	for (mipp = vfs_miplist;
3148 	    mipp && mipp->mip_vfsp != vfsp; mipp = mipp->mip_next) {
3149 		mipprev = mipp;
3150 	}
3151 	if (mipp == NULL)
3152 		return; /* shouldn't happen */
3153 	if (mipp == vfs_miplist_end)
3154 		vfs_miplist_end = mipprev;
3155 	if (mipprev == NULL)
3156 		vfs_miplist = mipp->mip_next;
3157 	else
3158 		mipprev->mip_next = mipp->mip_next;
3159 	mutex_exit(&vfs_miplist_mutex);
3160 	kmem_free(mipp, sizeof (struct ipmnt));
3161 }
3162 
3163 /*
3164  * vfs_add is called by a specific filesystem's mount routine to add
3165  * the new vfs into the vfs list/hash and to cover the mounted-on vnode.
3166  * The vfs should already have been locked by the caller.
3167  *
3168  * coveredvp is NULL if this is the root.
3169  */
3170 void
3171 vfs_add(vnode_t *coveredvp, struct vfs *vfsp, int mflag)
3172 {
3173 	int newflag;
3174 
3175 	ASSERT(vfs_lock_held(vfsp));
3176 	VFS_HOLD(vfsp);
3177 	newflag = vfsp->vfs_flag;
3178 	if (mflag & MS_RDONLY)
3179 		newflag |= VFS_RDONLY;
3180 	else
3181 		newflag &= ~VFS_RDONLY;
3182 	if (mflag & MS_NOSUID)
3183 		newflag |= (VFS_NOSETUID|VFS_NODEVICES);
3184 	else
3185 		newflag &= ~(VFS_NOSETUID|VFS_NODEVICES);
3186 	if (mflag & MS_NOMNTTAB)
3187 		newflag |= VFS_NOMNTTAB;
3188 	else
3189 		newflag &= ~VFS_NOMNTTAB;
3190 
3191 	if (coveredvp != NULL) {
3192 		ASSERT(vn_vfswlock_held(coveredvp));
3193 		coveredvp->v_vfsmountedhere = vfsp;
3194 		VN_HOLD(coveredvp);
3195 	}
3196 	vfsp->vfs_vnodecovered = coveredvp;
3197 	vfsp->vfs_flag = newflag;
3198 
3199 	vfs_list_add(vfsp);
3200 }
3201 
3202 /*
3203  * Remove a vfs from the vfs list, null out the pointer from the
3204  * covered vnode to the vfs (v_vfsmountedhere), and null out the pointer
3205  * from the vfs to the covered vnode (vfs_vnodecovered). Release the
3206  * reference to the vfs and to the covered vnode.
3207  *
3208  * Called from dounmount after it's confirmed with the file system
3209  * that the unmount is legal.
3210  */
3211 void
3212 vfs_remove(struct vfs *vfsp)
3213 {
3214 	vnode_t *vp;
3215 
3216 	ASSERT(vfs_lock_held(vfsp));
3217 
3218 	/*
3219 	 * Can't unmount root.  Should never happen because fs will
3220 	 * be busy.
3221 	 */
3222 	if (vfsp == rootvfs)
3223 		panic("vfs_remove: unmounting root");
3224 
3225 	vfs_list_remove(vfsp);
3226 
3227 	/*
3228 	 * Unhook from the file system name space.
3229 	 */
3230 	vp = vfsp->vfs_vnodecovered;
3231 	ASSERT(vn_vfswlock_held(vp));
3232 	vp->v_vfsmountedhere = NULL;
3233 	vfsp->vfs_vnodecovered = NULL;
3234 	VN_RELE(vp);
3235 
3236 	/*
3237 	 * Release lock and wakeup anybody waiting.
3238 	 */
3239 	vfs_unlock(vfsp);
3240 	VFS_RELE(vfsp);
3241 }
3242 
3243 /*
3244  * Lock a filesystem to prevent access to it while mounting,
3245  * unmounting and syncing.  Return EBUSY immediately if lock
3246  * can't be acquired.
3247  */
3248 int
3249 vfs_lock(vfs_t *vfsp)
3250 {
3251 	vn_vfslocks_entry_t *vpvfsentry;
3252 
3253 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3254 	if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER))
3255 		return (0);
3256 
3257 	vn_vfslocks_rele(vpvfsentry);
3258 	return (EBUSY);
3259 }
3260 
3261 int
3262 vfs_rlock(vfs_t *vfsp)
3263 {
3264 	vn_vfslocks_entry_t *vpvfsentry;
3265 
3266 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3267 
3268 	if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER))
3269 		return (0);
3270 
3271 	vn_vfslocks_rele(vpvfsentry);
3272 	return (EBUSY);
3273 }
3274 
3275 void
3276 vfs_lock_wait(vfs_t *vfsp)
3277 {
3278 	vn_vfslocks_entry_t *vpvfsentry;
3279 
3280 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3281 	rwst_enter(&vpvfsentry->ve_lock, RW_WRITER);
3282 }
3283 
3284 void
3285 vfs_rlock_wait(vfs_t *vfsp)
3286 {
3287 	vn_vfslocks_entry_t *vpvfsentry;
3288 
3289 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3290 	rwst_enter(&vpvfsentry->ve_lock, RW_READER);
3291 }
3292 
3293 /*
3294  * Unlock a locked filesystem.
3295  */
3296 void
3297 vfs_unlock(vfs_t *vfsp)
3298 {
3299 	vn_vfslocks_entry_t *vpvfsentry;
3300 
3301 	/*
3302 	 * vfs_unlock will mimic sema_v behaviour to fix 4748018.
3303 	 * And these changes should remain for the patch changes as it is.
3304 	 */
3305 	if (panicstr)
3306 		return;
3307 
3308 	/*
3309 	 * ve_refcount needs to be dropped twice here.
3310 	 * 1. To release refernce after a call to vfs_locks_getlock()
3311 	 * 2. To release the reference from the locking routines like
3312 	 *    vfs_rlock_wait/vfs_wlock_wait/vfs_wlock etc,.
3313 	 */
3314 
3315 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3316 	vn_vfslocks_rele(vpvfsentry);
3317 
3318 	rwst_exit(&vpvfsentry->ve_lock);
3319 	vn_vfslocks_rele(vpvfsentry);
3320 }
3321 
3322 /*
3323  * Utility routine that allows a filesystem to construct its
3324  * fsid in "the usual way" - by munging some underlying dev_t and
3325  * the filesystem type number into the 64-bit fsid.  Note that
3326  * this implicitly relies on dev_t persistence to make filesystem
3327  * id's persistent.
3328  *
3329  * There's nothing to prevent an individual fs from constructing its
3330  * fsid in a different way, and indeed they should.
3331  *
3332  * Since we want fsids to be 32-bit quantities (so that they can be
3333  * exported identically by either 32-bit or 64-bit APIs, as well as
3334  * the fact that fsid's are "known" to NFS), we compress the device
3335  * number given down to 32-bits, and panic if that isn't possible.
3336  */
3337 void
3338 vfs_make_fsid(fsid_t *fsi, dev_t dev, int val)
3339 {
3340 	if (!cmpldev((dev32_t *)&fsi->val[0], dev))
3341 		panic("device number too big for fsid!");
3342 	fsi->val[1] = val;
3343 }
3344 
3345 int
3346 vfs_lock_held(vfs_t *vfsp)
3347 {
3348 	int held;
3349 	vn_vfslocks_entry_t *vpvfsentry;
3350 
3351 	/*
3352 	 * vfs_lock_held will mimic sema_held behaviour
3353 	 * if panicstr is set. And these changes should remain
3354 	 * for the patch changes as it is.
3355 	 */
3356 	if (panicstr)
3357 		return (1);
3358 
3359 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3360 	held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER);
3361 
3362 	vn_vfslocks_rele(vpvfsentry);
3363 	return (held);
3364 }
3365 
3366 struct _kthread *
3367 vfs_lock_owner(vfs_t *vfsp)
3368 {
3369 	struct _kthread *owner;
3370 	vn_vfslocks_entry_t *vpvfsentry;
3371 
3372 	/*
3373 	 * vfs_wlock_held will mimic sema_held behaviour
3374 	 * if panicstr is set. And these changes should remain
3375 	 * for the patch changes as it is.
3376 	 */
3377 	if (panicstr)
3378 		return (NULL);
3379 
3380 	vpvfsentry = vn_vfslocks_getlock(vfsp);
3381 	owner = rwst_owner(&vpvfsentry->ve_lock);
3382 
3383 	vn_vfslocks_rele(vpvfsentry);
3384 	return (owner);
3385 }
3386 
3387 /*
3388  * vfs list locking.
3389  *
3390  * Rather than manipulate the vfslist lock directly, we abstract into lock
3391  * and unlock routines to allow the locking implementation to be changed for
3392  * clustering.
3393  *
3394  * Whenever the vfs list is modified through its hash links, the overall list
3395  * lock must be obtained before locking the relevant hash bucket.  But to see
3396  * whether a given vfs is on the list, it suffices to obtain the lock for the
3397  * hash bucket without getting the overall list lock.  (See getvfs() below.)
3398  */
3399 
3400 void
3401 vfs_list_lock()
3402 {
3403 	rw_enter(&vfslist, RW_WRITER);
3404 }
3405 
3406 void
3407 vfs_list_read_lock()
3408 {
3409 	rw_enter(&vfslist, RW_READER);
3410 }
3411 
3412 void
3413 vfs_list_unlock()
3414 {
3415 	rw_exit(&vfslist);
3416 }
3417 
3418 /*
3419  * Low level worker routines for adding entries to and removing entries from
3420  * the vfs list.
3421  */
3422 
3423 static void
3424 vfs_hash_add(struct vfs *vfsp, int insert_at_head)
3425 {
3426 	int vhno;
3427 	struct vfs **hp;
3428 	dev_t dev;
3429 
3430 	ASSERT(RW_WRITE_HELD(&vfslist));
3431 
3432 	dev = expldev(vfsp->vfs_fsid.val[0]);
3433 	vhno = VFSHASH(getmajor(dev), getminor(dev));
3434 
3435 	mutex_enter(&rvfs_list[vhno].rvfs_lock);
3436 
3437 	/*
3438 	 * Link into the hash table, inserting it at the end, so that LOFS
3439 	 * with the same fsid as UFS (or other) file systems will not hide the
3440 	 * UFS.
3441 	 */
3442 	if (insert_at_head) {
3443 		vfsp->vfs_hash = rvfs_list[vhno].rvfs_head;
3444 		rvfs_list[vhno].rvfs_head = vfsp;
3445 	} else {
3446 		for (hp = &rvfs_list[vhno].rvfs_head; *hp != NULL;
3447 		    hp = &(*hp)->vfs_hash)
3448 			continue;
3449 		/*
3450 		 * hp now contains the address of the pointer to update
3451 		 * to effect the insertion.
3452 		 */
3453 		vfsp->vfs_hash = NULL;
3454 		*hp = vfsp;
3455 	}
3456 
3457 	rvfs_list[vhno].rvfs_len++;
3458 	mutex_exit(&rvfs_list[vhno].rvfs_lock);
3459 }
3460 
3461 
3462 static void
3463 vfs_hash_remove(struct vfs *vfsp)
3464 {
3465 	int vhno;
3466 	struct vfs *tvfsp;
3467 	dev_t dev;
3468 
3469 	ASSERT(RW_WRITE_HELD(&vfslist));
3470 
3471 	dev = expldev(vfsp->vfs_fsid.val[0]);
3472 	vhno = VFSHASH(getmajor(dev), getminor(dev));
3473 
3474 	mutex_enter(&rvfs_list[vhno].rvfs_lock);
3475 
3476 	/*
3477 	 * Remove from hash.
3478 	 */
3479 	if (rvfs_list[vhno].rvfs_head == vfsp) {
3480 		rvfs_list[vhno].rvfs_head = vfsp->vfs_hash;
3481 		rvfs_list[vhno].rvfs_len--;
3482 		goto foundit;
3483 	}
3484 	for (tvfsp = rvfs_list[vhno].rvfs_head; tvfsp != NULL;
3485 	    tvfsp = tvfsp->vfs_hash) {
3486 		if (tvfsp->vfs_hash == vfsp) {
3487 			tvfsp->vfs_hash = vfsp->vfs_hash;
3488 			rvfs_list[vhno].rvfs_len--;
3489 			goto foundit;
3490 		}
3491 	}
3492 	cmn_err(CE_WARN, "vfs_list_remove: vfs not found in hash");
3493 
3494 foundit:
3495 
3496 	mutex_exit(&rvfs_list[vhno].rvfs_lock);
3497 }
3498 
3499 
3500 void
3501 vfs_list_add(struct vfs *vfsp)
3502 {
3503 	zone_t *zone;
3504 
3505 	/*
3506 	 * Typically, the vfs_t will have been created on behalf of the file
3507 	 * system in vfs_init, where it will have been provided with a
3508 	 * vfs_impl_t. This, however, might be lacking if the vfs_t was created
3509 	 * by an unbundled file system. We therefore check for such an example
3510 	 * before stamping the vfs_t with its creation time for the benefit of
3511 	 * mntfs.
3512 	 */
3513 	if (vfsp->vfs_implp == NULL)
3514 		vfsimpl_setup(vfsp);
3515 	vfs_mono_time(&vfsp->vfs_hrctime);
3516 
3517 	/*
3518 	 * The zone that owns the mount is the one that performed the mount.
3519 	 * Note that this isn't necessarily the same as the zone mounted into.
3520 	 * The corresponding zone_rele_ref() will be done when the vfs_t
3521 	 * is being free'd.
3522 	 */
3523 	vfsp->vfs_zone = curproc->p_zone;
3524 	zone_init_ref(&vfsp->vfs_implp->vi_zone_ref);
3525 	zone_hold_ref(vfsp->vfs_zone, &vfsp->vfs_implp->vi_zone_ref,
3526 	    ZONE_REF_VFS);
3527 
3528 	/*
3529 	 * Find the zone mounted into, and put this mount on its vfs list.
3530 	 */
3531 	zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3532 	ASSERT(zone != NULL);
3533 	/*
3534 	 * Special casing for the root vfs.  This structure is allocated
3535 	 * statically and hooked onto rootvfs at link time.  During the
3536 	 * vfs_mountroot call at system startup time, the root file system's
3537 	 * VFS_MOUNTROOT routine will call vfs_add with this root vfs struct
3538 	 * as argument.  The code below must detect and handle this special
3539 	 * case.  The only apparent justification for this special casing is
3540 	 * to ensure that the root file system appears at the head of the
3541 	 * list.
3542 	 *
3543 	 * XXX:	I'm assuming that it's ok to do normal list locking when
3544 	 *	adding the entry for the root file system (this used to be
3545 	 *	done with no locks held).
3546 	 */
3547 	vfs_list_lock();
3548 	/*
3549 	 * Link into the vfs list proper.
3550 	 */
3551 	if (vfsp == &root) {
3552 		/*
3553 		 * Assert: This vfs is already on the list as its first entry.
3554 		 * Thus, there's nothing to do.
3555 		 */
3556 		ASSERT(rootvfs == vfsp);
3557 		/*
3558 		 * Add it to the head of the global zone's vfslist.
3559 		 */
3560 		ASSERT(zone == global_zone);
3561 		ASSERT(zone->zone_vfslist == NULL);
3562 		zone->zone_vfslist = vfsp;
3563 	} else {
3564 		/*
3565 		 * Link to end of list using vfs_prev (as rootvfs is now a
3566 		 * doubly linked circular list) so list is in mount order for
3567 		 * mnttab use.
3568 		 */
3569 		rootvfs->vfs_prev->vfs_next = vfsp;
3570 		vfsp->vfs_prev = rootvfs->vfs_prev;
3571 		rootvfs->vfs_prev = vfsp;
3572 		vfsp->vfs_next = rootvfs;
3573 
3574 		/*
3575 		 * Do it again for the zone-private list (which may be NULL).
3576 		 */
3577 		if (zone->zone_vfslist == NULL) {
3578 			ASSERT(zone != global_zone);
3579 			zone->zone_vfslist = vfsp;
3580 		} else {
3581 			zone->zone_vfslist->vfs_zone_prev->vfs_zone_next = vfsp;
3582 			vfsp->vfs_zone_prev = zone->zone_vfslist->vfs_zone_prev;
3583 			zone->zone_vfslist->vfs_zone_prev = vfsp;
3584 			vfsp->vfs_zone_next = zone->zone_vfslist;
3585 		}
3586 	}
3587 
3588 	/*
3589 	 * Link into the hash table, inserting it at the end, so that LOFS
3590 	 * with the same fsid as UFS (or other) file systems will not hide
3591 	 * the UFS.
3592 	 */
3593 	vfs_hash_add(vfsp, 0);
3594 
3595 	/*
3596 	 * update the mnttab modification time
3597 	 */
3598 	vfs_mnttab_modtimeupd();
3599 	vfs_list_unlock();
3600 	zone_rele(zone);
3601 }
3602 
3603 void
3604 vfs_list_remove(struct vfs *vfsp)
3605 {
3606 	zone_t *zone;
3607 
3608 	zone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
3609 	ASSERT(zone != NULL);
3610 	/*
3611 	 * Callers are responsible for preventing attempts to unmount the
3612 	 * root.
3613 	 */
3614 	ASSERT(vfsp != rootvfs);
3615 
3616 	vfs_list_lock();
3617 
3618 	/*
3619 	 * Remove from hash.
3620 	 */
3621 	vfs_hash_remove(vfsp);
3622 
3623 	/*
3624 	 * Remove from vfs list.
3625 	 */
3626 	vfsp->vfs_prev->vfs_next = vfsp->vfs_next;
3627 	vfsp->vfs_next->vfs_prev = vfsp->vfs_prev;
3628 	vfsp->vfs_next = vfsp->vfs_prev = NULL;
3629 
3630 	/*
3631 	 * Remove from zone-specific vfs list.
3632 	 */
3633 	if (zone->zone_vfslist == vfsp)
3634 		zone->zone_vfslist = vfsp->vfs_zone_next;
3635 
3636 	if (vfsp->vfs_zone_next == vfsp) {
3637 		ASSERT(vfsp->vfs_zone_prev == vfsp);
3638 		ASSERT(zone->zone_vfslist == vfsp);
3639 		zone->zone_vfslist = NULL;
3640 	}
3641 
3642 	vfsp->vfs_zone_prev->vfs_zone_next = vfsp->vfs_zone_next;
3643 	vfsp->vfs_zone_next->vfs_zone_prev = vfsp->vfs_zone_prev;
3644 	vfsp->vfs_zone_next = vfsp->vfs_zone_prev = NULL;
3645 
3646 	/*
3647 	 * update the mnttab modification time
3648 	 */
3649 	vfs_mnttab_modtimeupd();
3650 	vfs_list_unlock();
3651 	zone_rele(zone);
3652 }
3653 
3654 struct vfs *
3655 getvfs(fsid_t *fsid)
3656 {
3657 	struct vfs *vfsp;
3658 	int val0 = fsid->val[0];
3659 	int val1 = fsid->val[1];
3660 	dev_t dev = expldev(val0);
3661 	int vhno = VFSHASH(getmajor(dev), getminor(dev));
3662 	kmutex_t *hmp = &rvfs_list[vhno].rvfs_lock;
3663 
3664 	mutex_enter(hmp);
3665 	for (vfsp = rvfs_list[vhno].rvfs_head; vfsp; vfsp = vfsp->vfs_hash) {
3666 		if (vfsp->vfs_fsid.val[0] == val0 &&
3667 		    vfsp->vfs_fsid.val[1] == val1) {
3668 			VFS_HOLD(vfsp);
3669 			mutex_exit(hmp);
3670 			return (vfsp);
3671 		}
3672 	}
3673 	mutex_exit(hmp);
3674 	return (NULL);
3675 }
3676 
3677 /*
3678  * Search the vfs mount in progress list for a specified device/vfs entry.
3679  * Returns 0 if the first entry in the list that the device matches has the
3680  * given vfs pointer as well.  If the device matches but a different vfs
3681  * pointer is encountered in the list before the given vfs pointer then
3682  * a 1 is returned.
3683  */
3684 
3685 int
3686 vfs_devmounting(dev_t dev, struct vfs *vfsp)
3687 {
3688 	int retval = 0;
3689 	struct ipmnt *mipp;
3690 
3691 	mutex_enter(&vfs_miplist_mutex);
3692 	for (mipp = vfs_miplist; mipp != NULL; mipp = mipp->mip_next) {
3693 		if (mipp->mip_dev == dev) {
3694 			if (mipp->mip_vfsp != vfsp)
3695 				retval = 1;
3696 			break;
3697 		}
3698 	}
3699 	mutex_exit(&vfs_miplist_mutex);
3700 	return (retval);
3701 }
3702 
3703 /*
3704  * Search the vfs list for a specified device.  Returns 1, if entry is found
3705  * or 0 if no suitable entry is found.
3706  */
3707 
3708 int
3709 vfs_devismounted(dev_t dev)
3710 {
3711 	struct vfs *vfsp;
3712 	int found;
3713 
3714 	vfs_list_read_lock();
3715 	vfsp = rootvfs;
3716 	found = 0;
3717 	do {
3718 		if (vfsp->vfs_dev == dev) {
3719 			found = 1;
3720 			break;
3721 		}
3722 		vfsp = vfsp->vfs_next;
3723 	} while (vfsp != rootvfs);
3724 
3725 	vfs_list_unlock();
3726 	return (found);
3727 }
3728 
3729 /*
3730  * Search the vfs list for a specified device.  Returns a pointer to it
3731  * or NULL if no suitable entry is found. The caller of this routine
3732  * is responsible for releasing the returned vfs pointer.
3733  */
3734 struct vfs *
3735 vfs_dev2vfsp(dev_t dev)
3736 {
3737 	struct vfs *vfsp;
3738 	int found;
3739 
3740 	vfs_list_read_lock();
3741 	vfsp = rootvfs;
3742 	found = 0;
3743 	do {
3744 		/*
3745 		 * The following could be made more efficient by making
3746 		 * the entire loop use vfs_zone_next if the call is from
3747 		 * a zone.  The only callers, however, ustat(2) and
3748 		 * umount2(2), don't seem to justify the added
3749 		 * complexity at present.
3750 		 */
3751 		if (vfsp->vfs_dev == dev &&
3752 		    ZONE_PATH_VISIBLE(refstr_value(vfsp->vfs_mntpt),
3753 		    curproc->p_zone)) {
3754 			VFS_HOLD(vfsp);
3755 			found = 1;
3756 			break;
3757 		}
3758 		vfsp = vfsp->vfs_next;
3759 	} while (vfsp != rootvfs);
3760 	vfs_list_unlock();
3761 	return (found ? vfsp: NULL);
3762 }
3763 
3764 /*
3765  * Search the vfs list for a specified mntpoint.  Returns a pointer to it
3766  * or NULL if no suitable entry is found. The caller of this routine
3767  * is responsible for releasing the returned vfs pointer.
3768  *
3769  * Note that if multiple mntpoints match, the last one matching is
3770  * returned in an attempt to return the "top" mount when overlay
3771  * mounts are covering the same mount point.  This is accomplished by starting
3772  * at the end of the list and working our way backwards, stopping at the first
3773  * matching mount.
3774  */
3775 struct vfs *
3776 vfs_mntpoint2vfsp(const char *mp)
3777 {
3778 	struct vfs *vfsp;
3779 	struct vfs *retvfsp = NULL;
3780 	zone_t *zone = curproc->p_zone;
3781 	struct vfs *list;
3782 
3783 	vfs_list_read_lock();
3784 	if (getzoneid() == GLOBAL_ZONEID) {
3785 		/*
3786 		 * The global zone may see filesystems in any zone.
3787 		 */
3788 		vfsp = rootvfs->vfs_prev;
3789 		do {
3790 			if (strcmp(refstr_value(vfsp->vfs_mntpt), mp) == 0) {
3791 				retvfsp = vfsp;
3792 				break;
3793 			}
3794 			vfsp = vfsp->vfs_prev;
3795 		} while (vfsp != rootvfs->vfs_prev);
3796 	} else if ((list = zone->zone_vfslist) != NULL) {
3797 		const char *mntpt;
3798 
3799 		vfsp = list->vfs_zone_prev;
3800 		do {
3801 			mntpt = refstr_value(vfsp->vfs_mntpt);
3802 			mntpt = ZONE_PATH_TRANSLATE(mntpt, zone);
3803 			if (strcmp(mntpt, mp) == 0) {
3804 				retvfsp = vfsp;
3805 				break;
3806 			}
3807 			vfsp = vfsp->vfs_zone_prev;
3808 		} while (vfsp != list->vfs_zone_prev);
3809 	}
3810 	if (retvfsp)
3811 		VFS_HOLD(retvfsp);
3812 	vfs_list_unlock();
3813 	return (retvfsp);
3814 }
3815 
3816 /*
3817  * Search the vfs list for a specified vfsops.
3818  * if vfs entry is found then return 1, else 0.
3819  */
3820 int
3821 vfs_opsinuse(vfsops_t *ops)
3822 {
3823 	struct vfs *vfsp;
3824 	int found;
3825 
3826 	vfs_list_read_lock();
3827 	vfsp = rootvfs;
3828 	found = 0;
3829 	do {
3830 		if (vfs_getops(vfsp) == ops) {
3831 			found = 1;
3832 			break;
3833 		}
3834 		vfsp = vfsp->vfs_next;
3835 	} while (vfsp != rootvfs);
3836 	vfs_list_unlock();
3837 	return (found);
3838 }
3839 
3840 /*
3841  * Allocate an entry in vfssw for a file system type
3842  */
3843 struct vfssw *
3844 allocate_vfssw(const char *type)
3845 {
3846 	struct vfssw *vswp;
3847 
3848 	if (type[0] == '\0' || strlen(type) + 1 > _ST_FSTYPSZ) {
3849 		/*
3850 		 * The vfssw table uses the empty string to identify an
3851 		 * available entry; we cannot add any type which has
3852 		 * a leading NUL. The string length is limited to
3853 		 * the size of the st_fstype array in struct stat.
3854 		 */
3855 		return (NULL);
3856 	}
3857 
3858 	ASSERT(VFSSW_WRITE_LOCKED());
3859 	for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++)
3860 		if (!ALLOCATED_VFSSW(vswp)) {
3861 			vswp->vsw_name = kmem_alloc(strlen(type) + 1, KM_SLEEP);
3862 			(void) strcpy(vswp->vsw_name, type);
3863 			ASSERT(vswp->vsw_count == 0);
3864 			vswp->vsw_count = 1;
3865 			mutex_init(&vswp->vsw_lock, NULL, MUTEX_DEFAULT, NULL);
3866 			return (vswp);
3867 		}
3868 	return (NULL);
3869 }
3870 
3871 /*
3872  * Impose additional layer of translation between vfstype names
3873  * and module names in the filesystem.
3874  */
3875 static const char *
3876 vfs_to_modname(const char *vfstype)
3877 {
3878 	if (strcmp(vfstype, "proc") == 0) {
3879 		vfstype = "procfs";
3880 	} else if (strcmp(vfstype, "fd") == 0) {
3881 		vfstype = "fdfs";
3882 	} else if (strncmp(vfstype, "nfs", 3) == 0) {
3883 		vfstype = "nfs";
3884 	}
3885 
3886 	return (vfstype);
3887 }
3888 
3889 /*
3890  * Find a vfssw entry given a file system type name.
3891  * Try to autoload the filesystem if it's not found.
3892  * If it's installed, return the vfssw locked to prevent unloading.
3893  */
3894 struct vfssw *
3895 vfs_getvfssw(const char *type)
3896 {
3897 	struct vfssw *vswp;
3898 	const char *modname;
3899 
3900 	RLOCK_VFSSW();
3901 	vswp = vfs_getvfsswbyname(type);
3902 	modname = vfs_to_modname(type);
3903 
3904 	if (rootdir == NULL) {
3905 		/*
3906 		 * If we haven't yet loaded the root file system, then our
3907 		 * _init won't be called until later. Allocate vfssw entry,
3908 		 * because mod_installfs won't be called.
3909 		 */
3910 		if (vswp == NULL) {
3911 			RUNLOCK_VFSSW();
3912 			WLOCK_VFSSW();
3913 			if ((vswp = vfs_getvfsswbyname(type)) == NULL) {
3914 				if ((vswp = allocate_vfssw(type)) == NULL) {
3915 					WUNLOCK_VFSSW();
3916 					return (NULL);
3917 				}
3918 			}
3919 			WUNLOCK_VFSSW();
3920 			RLOCK_VFSSW();
3921 		}
3922 		if (!VFS_INSTALLED(vswp)) {
3923 			RUNLOCK_VFSSW();
3924 			(void) modloadonly("fs", modname);
3925 		} else
3926 			RUNLOCK_VFSSW();
3927 		return (vswp);
3928 	}
3929 
3930 	/*
3931 	 * Try to load the filesystem.  Before calling modload(), we drop
3932 	 * our lock on the VFS switch table, and pick it up after the
3933 	 * module is loaded.  However, there is a potential race:  the
3934 	 * module could be unloaded after the call to modload() completes
3935 	 * but before we pick up the lock and drive on.  Therefore,
3936 	 * we keep reloading the module until we've loaded the module
3937 	 * _and_ we have the lock on the VFS switch table.
3938 	 */
3939 	while (vswp == NULL || !VFS_INSTALLED(vswp)) {
3940 		RUNLOCK_VFSSW();
3941 		if (modload("fs", modname) == -1)
3942 			return (NULL);
3943 		RLOCK_VFSSW();
3944 		if (vswp == NULL)
3945 			if ((vswp = vfs_getvfsswbyname(type)) == NULL)
3946 				break;
3947 	}
3948 	RUNLOCK_VFSSW();
3949 
3950 	return (vswp);
3951 }
3952 
3953 /*
3954  * Find a vfssw entry given a file system type name.
3955  */
3956 struct vfssw *
3957 vfs_getvfsswbyname(const char *type)
3958 {
3959 	struct vfssw *vswp;
3960 
3961 	ASSERT(VFSSW_LOCKED());
3962 	if (type == NULL || *type == '\0')
3963 		return (NULL);
3964 
3965 	for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3966 		if (strcmp(type, vswp->vsw_name) == 0) {
3967 			vfs_refvfssw(vswp);
3968 			return (vswp);
3969 		}
3970 	}
3971 
3972 	return (NULL);
3973 }
3974 
3975 /*
3976  * Find a vfssw entry given a set of vfsops.
3977  */
3978 struct vfssw *
3979 vfs_getvfsswbyvfsops(vfsops_t *vfsops)
3980 {
3981 	struct vfssw *vswp;
3982 
3983 	RLOCK_VFSSW();
3984 	for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
3985 		if (ALLOCATED_VFSSW(vswp) && &vswp->vsw_vfsops == vfsops) {
3986 			vfs_refvfssw(vswp);
3987 			RUNLOCK_VFSSW();
3988 			return (vswp);
3989 		}
3990 	}
3991 	RUNLOCK_VFSSW();
3992 
3993 	return (NULL);
3994 }
3995 
3996 /*
3997  * Reference a vfssw entry.
3998  */
3999 void
4000 vfs_refvfssw(struct vfssw *vswp)
4001 {
4002 
4003 	mutex_enter(&vswp->vsw_lock);
4004 	vswp->vsw_count++;
4005 	mutex_exit(&vswp->vsw_lock);
4006 }
4007 
4008 /*
4009  * Unreference a vfssw entry.
4010  */
4011 void
4012 vfs_unrefvfssw(struct vfssw *vswp)
4013 {
4014 
4015 	mutex_enter(&vswp->vsw_lock);
4016 	vswp->vsw_count--;
4017 	mutex_exit(&vswp->vsw_lock);
4018 }
4019 
4020 int sync_timeout = 30;		/* timeout for syncing a page during panic */
4021 int sync_timeleft;		/* portion of sync_timeout remaining */
4022 
4023 static int sync_retries = 20;	/* number of retries when not making progress */
4024 static int sync_triesleft;	/* portion of sync_retries remaining */
4025 
4026 static pgcnt_t old_pgcnt, new_pgcnt;
4027 static int new_bufcnt, old_bufcnt;
4028 
4029 /*
4030  * Sync all of the mounted filesystems, and then wait for the actual i/o to
4031  * complete.  We wait by counting the number of dirty pages and buffers,
4032  * pushing them out using bio_busy() and page_busy(), and then counting again.
4033  * This routine is used during both the uadmin A_SHUTDOWN code as well as
4034  * the SYNC phase of the panic code (see comments in panic.c).  It should only
4035  * be used after some higher-level mechanism has quiesced the system so that
4036  * new writes are not being initiated while we are waiting for completion.
4037  *
4038  * To ensure finite running time, our algorithm uses two timeout mechanisms:
4039  * sync_timeleft (a timer implemented by the omnipresent deadman() cyclic), and
4040  * sync_triesleft (a progress counter used by the vfs_syncall() loop below).
4041  * Together these ensure that syncing completes if our i/o paths are stuck.
4042  * The counters are declared above so they can be found easily in the debugger.
4043  *
4044  * The sync_timeleft counter is reset by bio_busy() and page_busy() using the
4045  * vfs_syncprogress() subroutine whenever we make progress through the lists of
4046  * pages and buffers.  It is decremented and expired by the deadman() cyclic.
4047  * When vfs_syncall() decides it is done, we disable the deadman() counter by
4048  * setting sync_timeleft to zero.  This timer guards against vfs_syncall()
4049  * deadlocking or hanging inside of a broken filesystem or driver routine.
4050  *
4051  * The sync_triesleft counter is updated by vfs_syncall() itself.  If we make
4052  * sync_retries consecutive calls to bio_busy() and page_busy() without
4053  * decreasing either the number of dirty buffers or dirty pages below the
4054  * lowest count we have seen so far, we give up and return from vfs_syncall().
4055  *
4056  * Each loop iteration ends with a call to delay() one second to allow time for
4057  * i/o completion and to permit the user time to read our progress messages.
4058  */
4059 void
4060 vfs_syncall(void)
4061 {
4062 	if (rootdir == NULL && !modrootloaded)
4063 		return; /* panic during boot - no filesystems yet */
4064 
4065 	printf("syncing file systems...");
4066 	vfs_syncprogress();
4067 	sync();
4068 
4069 	vfs_syncprogress();
4070 	sync_triesleft = sync_retries;
4071 
4072 	old_bufcnt = new_bufcnt = INT_MAX;
4073 	old_pgcnt = new_pgcnt = ULONG_MAX;
4074 
4075 	while (sync_triesleft > 0) {
4076 		old_bufcnt = MIN(old_bufcnt, new_bufcnt);
4077 		old_pgcnt = MIN(old_pgcnt, new_pgcnt);
4078 
4079 		new_bufcnt = bio_busy(B_TRUE);
4080 		new_pgcnt = page_busy(B_TRUE);
4081 		vfs_syncprogress();
4082 
4083 		if (new_bufcnt == 0 && new_pgcnt == 0)
4084 			break;
4085 
4086 		if (new_bufcnt < old_bufcnt || new_pgcnt < old_pgcnt)
4087 			sync_triesleft = sync_retries;
4088 		else
4089 			sync_triesleft--;
4090 
4091 		if (new_bufcnt)
4092 			printf(" [%d]", new_bufcnt);
4093 		if (new_pgcnt)
4094 			printf(" %lu", new_pgcnt);
4095 
4096 		delay(hz);
4097 	}
4098 
4099 	if (new_bufcnt != 0 || new_pgcnt != 0)
4100 		printf(" done (not all i/o completed)\n");
4101 	else
4102 		printf(" done\n");
4103 
4104 	sync_timeleft = 0;
4105 	delay(hz);
4106 }
4107 
4108 /*
4109  * If we are in the middle of the sync phase of panic, reset sync_timeleft to
4110  * sync_timeout to indicate that we are making progress and the deadman()
4111  * omnipresent cyclic should not yet time us out.  Note that it is safe to
4112  * store to sync_timeleft here since the deadman() is firing at high-level
4113  * on top of us.  If we are racing with the deadman(), either the deadman()
4114  * will decrement the old value and then we will reset it, or we will
4115  * reset it and then the deadman() will immediately decrement it.  In either
4116  * case, correct behavior results.
4117  */
4118 void
4119 vfs_syncprogress(void)
4120 {
4121 	if (panicstr)
4122 		sync_timeleft = sync_timeout;
4123 }
4124 
4125 /*
4126  * Map VFS flags to statvfs flags.  These shouldn't really be separate
4127  * flags at all.
4128  */
4129 uint_t
4130 vf_to_stf(uint_t vf)
4131 {
4132 	uint_t stf = 0;
4133 
4134 	if (vf & VFS_RDONLY)
4135 		stf |= ST_RDONLY;
4136 	if (vf & VFS_NOSETUID)
4137 		stf |= ST_NOSUID;
4138 	if (vf & VFS_NOTRUNC)
4139 		stf |= ST_NOTRUNC;
4140 
4141 	return (stf);
4142 }
4143 
4144 /*
4145  * Entries for (illegal) fstype 0.
4146  */
4147 /* ARGSUSED */
4148 int
4149 vfsstray_sync(struct vfs *vfsp, short arg, struct cred *cr)
4150 {
4151 	cmn_err(CE_PANIC, "stray vfs operation");
4152 	return (0);
4153 }
4154 
4155 /*
4156  * Entries for (illegal) fstype 0.
4157  */
4158 int
4159 vfsstray(void)
4160 {
4161 	cmn_err(CE_PANIC, "stray vfs operation");
4162 	return (0);
4163 }
4164 
4165 /*
4166  * Support for dealing with forced UFS unmount and its interaction with
4167  * LOFS. Could be used by any filesystem.
4168  * See bug 1203132.
4169  */
4170 int
4171 vfs_EIO(void)
4172 {
4173 	return (EIO);
4174 }
4175 
4176 /*
4177  * We've gotta define the op for sync separately, since the compiler gets
4178  * confused if we mix and match ANSI and normal style prototypes when
4179  * a "short" argument is present and spits out a warning.
4180  */
4181 /*ARGSUSED*/
4182 int
4183 vfs_EIO_sync(struct vfs *vfsp, short arg, struct cred *cr)
4184 {
4185 	return (EIO);
4186 }
4187 
4188 vfs_t EIO_vfs;
4189 vfsops_t *EIO_vfsops;
4190 
4191 /*
4192  * Called from startup() to initialize all loaded vfs's
4193  */
4194 void
4195 vfsinit(void)
4196 {
4197 	struct vfssw *vswp;
4198 	int error;
4199 	extern int vopstats_enabled;
4200 	extern void vopstats_startup();
4201 
4202 	static const fs_operation_def_t EIO_vfsops_template[] = {
4203 		VFSNAME_MOUNT,		{ .error = vfs_EIO },
4204 		VFSNAME_UNMOUNT,	{ .error = vfs_EIO },
4205 		VFSNAME_ROOT,		{ .error = vfs_EIO },
4206 		VFSNAME_STATVFS,	{ .error = vfs_EIO },
4207 		VFSNAME_SYNC, 		{ .vfs_sync = vfs_EIO_sync },
4208 		VFSNAME_VGET,		{ .error = vfs_EIO },
4209 		VFSNAME_MOUNTROOT,	{ .error = vfs_EIO },
4210 		VFSNAME_FREEVFS,	{ .error = vfs_EIO },
4211 		VFSNAME_VNSTATE,	{ .error = vfs_EIO },
4212 		NULL, NULL
4213 	};
4214 
4215 	static const fs_operation_def_t stray_vfsops_template[] = {
4216 		VFSNAME_MOUNT,		{ .error = vfsstray },
4217 		VFSNAME_UNMOUNT,	{ .error = vfsstray },
4218 		VFSNAME_ROOT,		{ .error = vfsstray },
4219 		VFSNAME_STATVFS,	{ .error = vfsstray },
4220 		VFSNAME_SYNC, 		{ .vfs_sync = vfsstray_sync },
4221 		VFSNAME_VGET,		{ .error = vfsstray },
4222 		VFSNAME_MOUNTROOT,	{ .error = vfsstray },
4223 		VFSNAME_FREEVFS,	{ .error = vfsstray },
4224 		VFSNAME_VNSTATE,	{ .error = vfsstray },
4225 		NULL, NULL
4226 	};
4227 
4228 	/* Create vfs cache */
4229 	vfs_cache = kmem_cache_create("vfs_cache", sizeof (struct vfs),
4230 	    sizeof (uintptr_t), NULL, NULL, NULL, NULL, NULL, 0);
4231 
4232 	/* Initialize the vnode cache (file systems may use it during init). */
4233 	vn_create_cache();
4234 
4235 	/* Setup event monitor framework */
4236 	fem_init();
4237 
4238 	/* Initialize the dummy stray file system type. */
4239 	error = vfs_setfsops(0, stray_vfsops_template, NULL);
4240 
4241 	/* Initialize the dummy EIO file system. */
4242 	error = vfs_makefsops(EIO_vfsops_template, &EIO_vfsops);
4243 	if (error != 0) {
4244 		cmn_err(CE_WARN, "vfsinit: bad EIO vfs ops template");
4245 		/* Shouldn't happen, but not bad enough to panic */
4246 	}
4247 
4248 	VFS_INIT(&EIO_vfs, EIO_vfsops, (caddr_t)NULL);
4249 
4250 	/*
4251 	 * Default EIO_vfs.vfs_flag to VFS_UNMOUNTED so a lookup
4252 	 * on this vfs can immediately notice it's invalid.
4253 	 */
4254 	EIO_vfs.vfs_flag |= VFS_UNMOUNTED;
4255 
4256 	/*
4257 	 * Call the init routines of non-loadable filesystems only.
4258 	 * Filesystems which are loaded as separate modules will be
4259 	 * initialized by the module loading code instead.
4260 	 */
4261 
4262 	for (vswp = &vfssw[1]; vswp < &vfssw[nfstype]; vswp++) {
4263 		RLOCK_VFSSW();
4264 		if (vswp->vsw_init != NULL)
4265 			(*vswp->vsw_init)(vswp - vfssw, vswp->vsw_name);
4266 		RUNLOCK_VFSSW();
4267 	}
4268 
4269 	vopstats_startup();
4270 
4271 	if (vopstats_enabled) {
4272 		/* EIO_vfs can collect stats, but we don't retrieve them */
4273 		initialize_vopstats(&EIO_vfs.vfs_vopstats);
4274 		EIO_vfs.vfs_fstypevsp = NULL;
4275 		EIO_vfs.vfs_vskap = NULL;
4276 		EIO_vfs.vfs_flag |= VFS_STATS;
4277 	}
4278 
4279 	xattr_init();
4280 
4281 	reparse_point_init();
4282 }
4283 
4284 vfs_t *
4285 vfs_alloc(int kmflag)
4286 {
4287 	vfs_t *vfsp;
4288 
4289 	vfsp = kmem_cache_alloc(vfs_cache, kmflag);
4290 
4291 	/*
4292 	 * Do the simplest initialization here.
4293 	 * Everything else gets done in vfs_init()
4294 	 */
4295 	bzero(vfsp, sizeof (vfs_t));
4296 	return (vfsp);
4297 }
4298 
4299 void
4300 vfs_free(vfs_t *vfsp)
4301 {
4302 	/*
4303 	 * One would be tempted to assert that "vfsp->vfs_count == 0".
4304 	 * The problem is that this gets called out of domount() with
4305 	 * a partially initialized vfs and a vfs_count of 1.  This is
4306 	 * also called from vfs_rele() with a vfs_count of 0.  We can't
4307 	 * call VFS_RELE() from domount() if VFS_MOUNT() hasn't successfully
4308 	 * returned.  This is because VFS_MOUNT() fully initializes the
4309 	 * vfs structure and its associated data.  VFS_RELE() will call
4310 	 * VFS_FREEVFS() which may panic the system if the data structures
4311 	 * aren't fully initialized from a successful VFS_MOUNT()).
4312 	 */
4313 
4314 	/* If FEM was in use, make sure everything gets cleaned up */
4315 	if (vfsp->vfs_femhead) {
4316 		ASSERT(vfsp->vfs_femhead->femh_list == NULL);
4317 		mutex_destroy(&vfsp->vfs_femhead->femh_lock);
4318 		kmem_free(vfsp->vfs_femhead, sizeof (*(vfsp->vfs_femhead)));
4319 		vfsp->vfs_femhead = NULL;
4320 	}
4321 
4322 	if (vfsp->vfs_implp)
4323 		vfsimpl_teardown(vfsp);
4324 	sema_destroy(&vfsp->vfs_reflock);
4325 	kmem_cache_free(vfs_cache, vfsp);
4326 }
4327 
4328 /*
4329  * Increments the vfs reference count by one atomically.
4330  */
4331 void
4332 vfs_hold(vfs_t *vfsp)
4333 {
4334 	atomic_add_32(&vfsp->vfs_count, 1);
4335 	ASSERT(vfsp->vfs_count != 0);
4336 }
4337 
4338 /*
4339  * Decrements the vfs reference count by one atomically. When
4340  * vfs reference count becomes zero, it calls the file system
4341  * specific vfs_freevfs() to free up the resources.
4342  */
4343 void
4344 vfs_rele(vfs_t *vfsp)
4345 {
4346 	ASSERT(vfsp->vfs_count != 0);
4347 	if (atomic_add_32_nv(&vfsp->vfs_count, -1) == 0) {
4348 		VFS_FREEVFS(vfsp);
4349 		lofi_remove(vfsp);
4350 		if (vfsp->vfs_zone)
4351 			zone_rele_ref(&vfsp->vfs_implp->vi_zone_ref,
4352 			    ZONE_REF_VFS);
4353 		vfs_freemnttab(vfsp);
4354 		vfs_free(vfsp);
4355 	}
4356 }
4357 
4358 /*
4359  * Generic operations vector support.
4360  *
4361  * This is used to build operations vectors for both the vfs and vnode.
4362  * It's normally called only when a file system is loaded.
4363  *
4364  * There are many possible algorithms for this, including the following:
4365  *
4366  *   (1) scan the list of known operations; for each, see if the file system
4367  *       includes an entry for it, and fill it in as appropriate.
4368  *
4369  *   (2) set up defaults for all known operations.  scan the list of ops
4370  *       supplied by the file system; for each which is both supplied and
4371  *       known, fill it in.
4372  *
4373  *   (3) sort the lists of known ops & supplied ops; scan the list, filling
4374  *       in entries as we go.
4375  *
4376  * we choose (1) for simplicity, and because performance isn't critical here.
4377  * note that (2) could be sped up using a precomputed hash table on known ops.
4378  * (3) could be faster than either, but only if the lists were very large or
4379  * supplied in sorted order.
4380  *
4381  */
4382 
4383 int
4384 fs_build_vector(void *vector, int *unused_ops,
4385     const fs_operation_trans_def_t *translation,
4386     const fs_operation_def_t *operations)
4387 {
4388 	int i, num_trans, num_ops, used;
4389 
4390 	/*
4391 	 * Count the number of translations and the number of supplied
4392 	 * operations.
4393 	 */
4394 
4395 	{
4396 		const fs_operation_trans_def_t *p;
4397 
4398 		for (num_trans = 0, p = translation;
4399 		    p->name != NULL;
4400 		    num_trans++, p++)
4401 			;
4402 	}
4403 
4404 	{
4405 		const fs_operation_def_t *p;
4406 
4407 		for (num_ops = 0, p = operations;
4408 		    p->name != NULL;
4409 		    num_ops++, p++)
4410 			;
4411 	}
4412 
4413 	/* Walk through each operation known to our caller.  There will be */
4414 	/* one entry in the supplied "translation table" for each. */
4415 
4416 	used = 0;
4417 
4418 	for (i = 0; i < num_trans; i++) {
4419 		int j, found;
4420 		char *curname;
4421 		fs_generic_func_p result;
4422 		fs_generic_func_p *location;
4423 
4424 		curname = translation[i].name;
4425 
4426 		/* Look for a matching operation in the list supplied by the */
4427 		/* file system. */
4428 
4429 		found = 0;
4430 
4431 		for (j = 0; j < num_ops; j++) {
4432 			if (strcmp(operations[j].name, curname) == 0) {
4433 				used++;
4434 				found = 1;
4435 				break;
4436 			}
4437 		}
4438 
4439 		/*
4440 		 * If the file system is using a "placeholder" for default
4441 		 * or error functions, grab the appropriate function out of
4442 		 * the translation table.  If the file system didn't supply
4443 		 * this operation at all, use the default function.
4444 		 */
4445 
4446 		if (found) {
4447 			result = operations[j].func.fs_generic;
4448 			if (result == fs_default) {
4449 				result = translation[i].defaultFunc;
4450 			} else if (result == fs_error) {
4451 				result = translation[i].errorFunc;
4452 			} else if (result == NULL) {
4453 				/* Null values are PROHIBITED */
4454 				return (EINVAL);
4455 			}
4456 		} else {
4457 			result = translation[i].defaultFunc;
4458 		}
4459 
4460 		/* Now store the function into the operations vector. */
4461 
4462 		location = (fs_generic_func_p *)
4463 		    (((char *)vector) + translation[i].offset);
4464 
4465 		*location = result;
4466 	}
4467 
4468 	*unused_ops = num_ops - used;
4469 
4470 	return (0);
4471 }
4472 
4473 /* Placeholder functions, should never be called. */
4474 
4475 int
4476 fs_error(void)
4477 {
4478 	cmn_err(CE_PANIC, "fs_error called");
4479 	return (0);
4480 }
4481 
4482 int
4483 fs_default(void)
4484 {
4485 	cmn_err(CE_PANIC, "fs_default called");
4486 	return (0);
4487 }
4488 
4489 #ifdef __sparc
4490 
4491 /*
4492  * Part of the implementation of booting off a mirrored root
4493  * involves a change of dev_t for the root device.  To
4494  * accomplish this, first remove the existing hash table
4495  * entry for the root device, convert to the new dev_t,
4496  * then re-insert in the hash table at the head of the list.
4497  */
4498 void
4499 vfs_root_redev(vfs_t *vfsp, dev_t ndev, int fstype)
4500 {
4501 	vfs_list_lock();
4502 
4503 	vfs_hash_remove(vfsp);
4504 
4505 	vfsp->vfs_dev = ndev;
4506 	vfs_make_fsid(&vfsp->vfs_fsid, ndev, fstype);
4507 
4508 	vfs_hash_add(vfsp, 1);
4509 
4510 	vfs_list_unlock();
4511 }
4512 
4513 #else /* x86 NEWBOOT */
4514 
4515 #if defined(__x86)
4516 extern int hvmboot_rootconf();
4517 #endif /* __x86 */
4518 
4519 extern ib_boot_prop_t *iscsiboot_prop;
4520 
4521 int
4522 rootconf()
4523 {
4524 	int error;
4525 	struct vfssw *vsw;
4526 	extern void pm_init();
4527 	char *fstyp, *fsmod;
4528 	int ret = -1;
4529 
4530 	getrootfs(&fstyp, &fsmod);
4531 
4532 #if defined(__x86)
4533 	/*
4534 	 * hvmboot_rootconf() is defined in the hvm_bootstrap misc module,
4535 	 * which lives in /platform/i86hvm, and hence is only available when
4536 	 * booted in an x86 hvm environment.  If the hvm_bootstrap misc module
4537 	 * is not available then the modstub for this function will return 0.
4538 	 * If the hvm_bootstrap misc module is available it will be loaded
4539 	 * and hvmboot_rootconf() will be invoked.
4540 	 */
4541 	if (error = hvmboot_rootconf())
4542 		return (error);
4543 #endif /* __x86 */
4544 
4545 	if (error = clboot_rootconf())
4546 		return (error);
4547 
4548 	if (modload("fs", fsmod) == -1)
4549 		panic("Cannot _init %s module", fsmod);
4550 
4551 	RLOCK_VFSSW();
4552 	vsw = vfs_getvfsswbyname(fstyp);
4553 	RUNLOCK_VFSSW();
4554 	if (vsw == NULL) {
4555 		cmn_err(CE_CONT, "Cannot find %s filesystem\n", fstyp);
4556 		return (ENXIO);
4557 	}
4558 	VFS_INIT(rootvfs, &vsw->vsw_vfsops, 0);
4559 	VFS_HOLD(rootvfs);
4560 
4561 	/* always mount readonly first */
4562 	rootvfs->vfs_flag |= VFS_RDONLY;
4563 
4564 	pm_init();
4565 
4566 	if (netboot && iscsiboot_prop) {
4567 		cmn_err(CE_WARN, "NFS boot and iSCSI boot"
4568 		    " shouldn't happen in the same time");
4569 		return (EINVAL);
4570 	}
4571 
4572 	if (netboot || iscsiboot_prop) {
4573 		ret = strplumb();
4574 		if (ret != 0) {
4575 			cmn_err(CE_WARN, "Cannot plumb network device %d", ret);
4576 			return (EFAULT);
4577 		}
4578 	}
4579 
4580 	if ((ret == 0) && iscsiboot_prop) {
4581 		ret = modload("drv", "iscsi");
4582 		/* -1 indicates fail */
4583 		if (ret == -1) {
4584 			cmn_err(CE_WARN, "Failed to load iscsi module");
4585 			iscsi_boot_prop_free();
4586 			return (EINVAL);
4587 		} else {
4588 			if (!i_ddi_attach_pseudo_node("iscsi")) {
4589 				cmn_err(CE_WARN,
4590 				    "Failed to attach iscsi driver");
4591 				iscsi_boot_prop_free();
4592 				return (ENODEV);
4593 			}
4594 		}
4595 	}
4596 
4597 	error = VFS_MOUNTROOT(rootvfs, ROOT_INIT);
4598 	vfs_unrefvfssw(vsw);
4599 	rootdev = rootvfs->vfs_dev;
4600 
4601 	if (error)
4602 		cmn_err(CE_CONT, "Cannot mount root on %s fstype %s\n",
4603 		    rootfs.bo_name, fstyp);
4604 	else
4605 		cmn_err(CE_CONT, "?root on %s fstype %s\n",
4606 		    rootfs.bo_name, fstyp);
4607 	return (error);
4608 }
4609 
4610 /*
4611  * XXX this is called by nfs only and should probably be removed
4612  * If booted with ASKNAME, prompt on the console for a filesystem
4613  * name and return it.
4614  */
4615 void
4616 getfsname(char *askfor, char *name, size_t namelen)
4617 {
4618 	if (boothowto & RB_ASKNAME) {
4619 		printf("%s name: ", askfor);
4620 		console_gets(name, namelen);
4621 	}
4622 }
4623 
4624 /*
4625  * Init the root filesystem type (rootfs.bo_fstype) from the "fstype"
4626  * property.
4627  *
4628  * Filesystem types starting with the prefix "nfs" are diskless clients;
4629  * init the root filename name (rootfs.bo_name), too.
4630  *
4631  * If we are booting via NFS we currently have these options:
4632  *	nfs -	dynamically choose NFS V2, V3, or V4 (default)
4633  *	nfs2 -	force NFS V2
4634  *	nfs3 -	force NFS V3
4635  *	nfs4 -	force NFS V4
4636  * Because we need to maintain backward compatibility with the naming
4637  * convention that the NFS V2 filesystem name is "nfs" (see vfs_conf.c)
4638  * we need to map "nfs" => "nfsdyn" and "nfs2" => "nfs".  The dynamic
4639  * nfs module will map the type back to either "nfs", "nfs3", or "nfs4".
4640  * This is only for root filesystems, all other uses such as cachefs
4641  * will expect that "nfs" == NFS V2.
4642  */
4643 static void
4644 getrootfs(char **fstypp, char **fsmodp)
4645 {
4646 	extern char *strplumb_get_netdev_path(void);
4647 	char *propstr = NULL;
4648 
4649 	/*
4650 	 * Check fstype property; for diskless it should be one of "nfs",
4651 	 * "nfs2", "nfs3" or "nfs4".
4652 	 */
4653 	if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4654 	    DDI_PROP_DONTPASS, "fstype", &propstr)
4655 	    == DDI_SUCCESS) {
4656 		(void) strncpy(rootfs.bo_fstype, propstr, BO_MAXFSNAME);
4657 		ddi_prop_free(propstr);
4658 
4659 	/*
4660 	 * if the boot property 'fstype' is not set, but 'zfs-bootfs' is set,
4661 	 * assume the type of this root filesystem is 'zfs'.
4662 	 */
4663 	} else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4664 	    DDI_PROP_DONTPASS, "zfs-bootfs", &propstr)
4665 	    == DDI_SUCCESS) {
4666 		(void) strncpy(rootfs.bo_fstype, "zfs", BO_MAXFSNAME);
4667 		ddi_prop_free(propstr);
4668 	}
4669 
4670 	if (strncmp(rootfs.bo_fstype, "nfs", 3) != 0) {
4671 		*fstypp = *fsmodp = rootfs.bo_fstype;
4672 		return;
4673 	}
4674 
4675 	++netboot;
4676 
4677 	if (strcmp(rootfs.bo_fstype, "nfs2") == 0)
4678 		(void) strcpy(rootfs.bo_fstype, "nfs");
4679 	else if (strcmp(rootfs.bo_fstype, "nfs") == 0)
4680 		(void) strcpy(rootfs.bo_fstype, "nfsdyn");
4681 
4682 	/*
4683 	 * check if path to network interface is specified in bootpath
4684 	 * or by a hypervisor domain configuration file.
4685 	 * XXPV - enable strlumb_get_netdev_path()
4686 	 */
4687 	if (ddi_prop_exists(DDI_DEV_T_ANY, ddi_root_node(), DDI_PROP_DONTPASS,
4688 	    "xpv-nfsroot")) {
4689 		(void) strcpy(rootfs.bo_name, "/xpvd/xnf@0");
4690 	} else if (ddi_prop_lookup_string(DDI_DEV_T_ANY, ddi_root_node(),
4691 	    DDI_PROP_DONTPASS, "bootpath", &propstr)
4692 	    == DDI_SUCCESS) {
4693 		(void) strncpy(rootfs.bo_name, propstr, BO_MAXOBJNAME);
4694 		ddi_prop_free(propstr);
4695 	} else {
4696 		/* attempt to determine netdev_path via boot_mac address */
4697 		netdev_path = strplumb_get_netdev_path();
4698 		if (netdev_path == NULL)
4699 			panic("cannot find boot network interface");
4700 		(void) strncpy(rootfs.bo_name, netdev_path, BO_MAXOBJNAME);
4701 	}
4702 	*fstypp = rootfs.bo_fstype;
4703 	*fsmodp = "nfs";
4704 }
4705 #endif
4706 
4707 /*
4708  * VFS feature routines
4709  */
4710 
4711 #define	VFTINDEX(feature)	(((feature) >> 32) & 0xFFFFFFFF)
4712 #define	VFTBITS(feature)	((feature) & 0xFFFFFFFFLL)
4713 
4714 /* Register a feature in the vfs */
4715 void
4716 vfs_set_feature(vfs_t *vfsp, vfs_feature_t feature)
4717 {
4718 	/* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4719 	if (vfsp->vfs_implp == NULL)
4720 		return;
4721 
4722 	vfsp->vfs_featureset[VFTINDEX(feature)] |= VFTBITS(feature);
4723 }
4724 
4725 void
4726 vfs_clear_feature(vfs_t *vfsp, vfs_feature_t feature)
4727 {
4728 	/* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4729 	if (vfsp->vfs_implp == NULL)
4730 		return;
4731 	vfsp->vfs_featureset[VFTINDEX(feature)] &= VFTBITS(~feature);
4732 }
4733 
4734 /*
4735  * Query a vfs for a feature.
4736  * Returns 1 if feature is present, 0 if not
4737  */
4738 int
4739 vfs_has_feature(vfs_t *vfsp, vfs_feature_t feature)
4740 {
4741 	int	ret = 0;
4742 
4743 	/* Note that vfs_featureset[] is found in *vfsp->vfs_implp */
4744 	if (vfsp->vfs_implp == NULL)
4745 		return (ret);
4746 
4747 	if (vfsp->vfs_featureset[VFTINDEX(feature)] & VFTBITS(feature))
4748 		ret = 1;
4749 
4750 	return (ret);
4751 }
4752 
4753 /*
4754  * Propagate feature set from one vfs to another
4755  */
4756 void
4757 vfs_propagate_features(vfs_t *from, vfs_t *to)
4758 {
4759 	int i;
4760 
4761 	if (to->vfs_implp == NULL || from->vfs_implp == NULL)
4762 		return;
4763 
4764 	for (i = 1; i <= to->vfs_featureset[0]; i++) {
4765 		to->vfs_featureset[i] = from->vfs_featureset[i];
4766 	}
4767 }
4768 
4769 #define	LOFINODE_PATH "/dev/lofi/%d"
4770 
4771 /*
4772  * Return the vnode for the lofi node if there's a lofi mount in place.
4773  * Returns -1 when there's no lofi node, 0 on success, and > 0 on
4774  * failure.
4775  */
4776 int
4777 vfs_get_lofi(vfs_t *vfsp, vnode_t **vpp)
4778 {
4779 	char *path = NULL;
4780 	int strsize;
4781 	int err;
4782 
4783 	if (vfsp->vfs_lofi_minor == 0) {
4784 		*vpp = NULL;
4785 		return (-1);
4786 	}
4787 
4788 	strsize = snprintf(NULL, 0, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4789 	path = kmem_alloc(strsize + 1, KM_SLEEP);
4790 	(void) snprintf(path, strsize + 1, LOFINODE_PATH, vfsp->vfs_lofi_minor);
4791 
4792 	/*
4793 	 * We may be inside a zone, so we need to use the /dev path, but
4794 	 * it's created asynchronously, so we wait here.
4795 	 */
4796 	for (;;) {
4797 		err = lookupname(path, UIO_SYSSPACE, FOLLOW, NULLVPP, vpp);
4798 
4799 		if (err != ENOENT)
4800 			break;
4801 
4802 		if ((err = delay_sig(hz / 8)) == EINTR)
4803 			break;
4804 	}
4805 
4806 	if (err)
4807 		*vpp = NULL;
4808 
4809 	kmem_free(path, strsize + 1);
4810 	return (err);
4811 }
4812