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