xref: /netbsd-src/sys/kern/vfs_mount.c (revision 6a493d6bc668897c91594964a732d38505b70cbb)
1 /*	$NetBSD: vfs_mount.c,v 1.25 2013/11/27 17:25:46 christos Exp $	*/
2 
3 /*-
4  * Copyright (c) 1997-2011 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9  * NASA Ames Research Center, by Charles M. Hannum, and by Andrew Doran.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 /*
34  * Copyright (c) 1989, 1993
35  *	The Regents of the University of California.  All rights reserved.
36  * (c) UNIX System Laboratories, Inc.
37  * All or some portions of this file are derived from material licensed
38  * to the University of California by American Telephone and Telegraph
39  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
40  * the permission of UNIX System Laboratories, Inc.
41  *
42  * Redistribution and use in source and binary forms, with or without
43  * modification, are permitted provided that the following conditions
44  * are met:
45  * 1. Redistributions of source code must retain the above copyright
46  *    notice, this list of conditions and the following disclaimer.
47  * 2. Redistributions in binary form must reproduce the above copyright
48  *    notice, this list of conditions and the following disclaimer in the
49  *    documentation and/or other materials provided with the distribution.
50  * 3. Neither the name of the University nor the names of its contributors
51  *    may be used to endorse or promote products derived from this software
52  *    without specific prior written permission.
53  *
54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64  * SUCH DAMAGE.
65  *
66  *	@(#)vfs_subr.c	8.13 (Berkeley) 4/18/94
67  */
68 
69 #include <sys/cdefs.h>
70 __KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.25 2013/11/27 17:25:46 christos Exp $");
71 
72 #include <sys/param.h>
73 #include <sys/kernel.h>
74 
75 #include <sys/atomic.h>
76 #include <sys/buf.h>
77 #include <sys/conf.h>
78 #include <sys/fcntl.h>
79 #include <sys/filedesc.h>
80 #include <sys/device.h>
81 #include <sys/kauth.h>
82 #include <sys/kmem.h>
83 #include <sys/module.h>
84 #include <sys/mount.h>
85 #include <sys/namei.h>
86 #include <sys/extattr.h>
87 #include <sys/syscallargs.h>
88 #include <sys/sysctl.h>
89 #include <sys/systm.h>
90 #include <sys/vfs_syscalls.h>
91 #include <sys/vnode.h>
92 
93 #include <miscfs/genfs/genfs.h>
94 #include <miscfs/syncfs/syncfs.h>
95 #include <miscfs/specfs/specdev.h>
96 
97 /* Root filesystem and device. */
98 vnode_t *			rootvnode;
99 device_t			root_device;
100 
101 /* Mounted filesystem list. */
102 struct mntlist			mountlist;
103 kmutex_t			mountlist_lock;
104 
105 kmutex_t			mntvnode_lock;
106 kmutex_t			vfs_list_lock;
107 
108 static specificdata_domain_t	mount_specificdata_domain;
109 static kmutex_t			mntid_lock;
110 
111 static kmutex_t			mountgen_lock;
112 static uint64_t			mountgen;
113 
114 void
115 vfs_mount_sysinit(void)
116 {
117 
118 	TAILQ_INIT(&mountlist);
119 	mutex_init(&mountlist_lock, MUTEX_DEFAULT, IPL_NONE);
120 	mutex_init(&mntvnode_lock, MUTEX_DEFAULT, IPL_NONE);
121 	mutex_init(&vfs_list_lock, MUTEX_DEFAULT, IPL_NONE);
122 
123 	mount_specificdata_domain = specificdata_domain_create();
124 	mutex_init(&mntid_lock, MUTEX_DEFAULT, IPL_NONE);
125 	mutex_init(&mountgen_lock, MUTEX_DEFAULT, IPL_NONE);
126 	mountgen = 0;
127 }
128 
129 struct mount *
130 vfs_mountalloc(struct vfsops *vfsops, vnode_t *vp)
131 {
132 	struct mount *mp;
133 	int error __diagused;
134 
135 	mp = kmem_zalloc(sizeof(*mp), KM_SLEEP);
136 	if (mp == NULL)
137 		return NULL;
138 
139 	mp->mnt_op = vfsops;
140 	mp->mnt_refcnt = 1;
141 	TAILQ_INIT(&mp->mnt_vnodelist);
142 	mutex_init(&mp->mnt_unmounting, MUTEX_DEFAULT, IPL_NONE);
143 	mutex_init(&mp->mnt_renamelock, MUTEX_DEFAULT, IPL_NONE);
144 	mutex_init(&mp->mnt_updating, MUTEX_DEFAULT, IPL_NONE);
145 	error = vfs_busy(mp, NULL);
146 	KASSERT(error == 0);
147 	mp->mnt_vnodecovered = vp;
148 	mount_initspecific(mp);
149 
150 	mutex_enter(&mountgen_lock);
151 	mp->mnt_gen = mountgen++;
152 	mutex_exit(&mountgen_lock);
153 
154 	return mp;
155 }
156 
157 /*
158  * vfs_rootmountalloc: lookup a filesystem type, and if found allocate and
159  * initialize a mount structure for it.
160  *
161  * Devname is usually updated by mount(8) after booting.
162  */
163 int
164 vfs_rootmountalloc(const char *fstypename, const char *devname,
165     struct mount **mpp)
166 {
167 	struct vfsops *vfsp = NULL;
168 	struct mount *mp;
169 
170 	mutex_enter(&vfs_list_lock);
171 	LIST_FOREACH(vfsp, &vfs_list, vfs_list)
172 		if (!strncmp(vfsp->vfs_name, fstypename,
173 		    sizeof(mp->mnt_stat.f_fstypename)))
174 			break;
175 	if (vfsp == NULL) {
176 		mutex_exit(&vfs_list_lock);
177 		return (ENODEV);
178 	}
179 	vfsp->vfs_refcount++;
180 	mutex_exit(&vfs_list_lock);
181 
182 	if ((mp = vfs_mountalloc(vfsp, NULL)) == NULL)
183 		return ENOMEM;
184 	mp->mnt_flag = MNT_RDONLY;
185 	(void)strlcpy(mp->mnt_stat.f_fstypename, vfsp->vfs_name,
186 	    sizeof(mp->mnt_stat.f_fstypename));
187 	mp->mnt_stat.f_mntonname[0] = '/';
188 	mp->mnt_stat.f_mntonname[1] = '\0';
189 	mp->mnt_stat.f_mntfromname[sizeof(mp->mnt_stat.f_mntfromname) - 1] =
190 	    '\0';
191 	(void)copystr(devname, mp->mnt_stat.f_mntfromname,
192 	    sizeof(mp->mnt_stat.f_mntfromname) - 1, 0);
193 	*mpp = mp;
194 	return 0;
195 }
196 
197 /*
198  * vfs_getnewfsid: get a new unique fsid.
199  */
200 void
201 vfs_getnewfsid(struct mount *mp)
202 {
203 	static u_short xxxfs_mntid;
204 	fsid_t tfsid;
205 	int mtype;
206 
207 	mutex_enter(&mntid_lock);
208 	mtype = makefstype(mp->mnt_op->vfs_name);
209 	mp->mnt_stat.f_fsidx.__fsid_val[0] = makedev(mtype, 0);
210 	mp->mnt_stat.f_fsidx.__fsid_val[1] = mtype;
211 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
212 	if (xxxfs_mntid == 0)
213 		++xxxfs_mntid;
214 	tfsid.__fsid_val[0] = makedev(mtype & 0xff, xxxfs_mntid);
215 	tfsid.__fsid_val[1] = mtype;
216 	if (!TAILQ_EMPTY(&mountlist)) {
217 		while (vfs_getvfs(&tfsid)) {
218 			tfsid.__fsid_val[0]++;
219 			xxxfs_mntid++;
220 		}
221 	}
222 	mp->mnt_stat.f_fsidx.__fsid_val[0] = tfsid.__fsid_val[0];
223 	mp->mnt_stat.f_fsid = mp->mnt_stat.f_fsidx.__fsid_val[0];
224 	mutex_exit(&mntid_lock);
225 }
226 
227 /*
228  * Lookup a mount point by filesystem identifier.
229  *
230  * XXX Needs to add a reference to the mount point.
231  */
232 struct mount *
233 vfs_getvfs(fsid_t *fsid)
234 {
235 	struct mount *mp;
236 
237 	mutex_enter(&mountlist_lock);
238 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
239 		if (mp->mnt_stat.f_fsidx.__fsid_val[0] == fsid->__fsid_val[0] &&
240 		    mp->mnt_stat.f_fsidx.__fsid_val[1] == fsid->__fsid_val[1]) {
241 			mutex_exit(&mountlist_lock);
242 			return (mp);
243 		}
244 	}
245 	mutex_exit(&mountlist_lock);
246 	return NULL;
247 }
248 
249 /*
250  * Drop a reference to a mount structure, freeing if the last reference.
251  */
252 void
253 vfs_destroy(struct mount *mp)
254 {
255 
256 	if (__predict_true((int)atomic_dec_uint_nv(&mp->mnt_refcnt) > 0)) {
257 		return;
258 	}
259 
260 	/*
261 	 * Nothing else has visibility of the mount: we can now
262 	 * free the data structures.
263 	 */
264 	KASSERT(mp->mnt_refcnt == 0);
265 	specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref);
266 	mutex_destroy(&mp->mnt_unmounting);
267 	mutex_destroy(&mp->mnt_updating);
268 	mutex_destroy(&mp->mnt_renamelock);
269 	if (mp->mnt_op != NULL) {
270 		vfs_delref(mp->mnt_op);
271 	}
272 	kmem_free(mp, sizeof(*mp));
273 }
274 
275 /*
276  * Mark a mount point as busy, and gain a new reference to it.  Used to
277  * prevent the file system from being unmounted during critical sections.
278  *
279  * vfs_busy can be called multiple times and by multiple threads
280  * and must be accompanied by the same number of vfs_unbusy calls.
281  *
282  * => The caller must hold a pre-existing reference to the mount.
283  * => Will fail if the file system is being unmounted, or is unmounted.
284  */
285 int
286 vfs_busy(struct mount *mp, struct mount **nextp)
287 {
288 
289 	KASSERT(mp->mnt_refcnt > 0);
290 
291 	mutex_enter(&mp->mnt_unmounting);
292 	if (__predict_false((mp->mnt_iflag & IMNT_GONE) != 0)) {
293 		mutex_exit(&mp->mnt_unmounting);
294 		if (nextp != NULL) {
295 			KASSERT(mutex_owned(&mountlist_lock));
296 			*nextp = TAILQ_NEXT(mp, mnt_list);
297 		}
298 		return ENOENT;
299 	}
300 	++mp->mnt_busynest;
301 	KASSERT(mp->mnt_busynest != 0);
302 	mutex_exit(&mp->mnt_unmounting);
303 	if (nextp != NULL) {
304 		mutex_exit(&mountlist_lock);
305 	}
306 	atomic_inc_uint(&mp->mnt_refcnt);
307 	return 0;
308 }
309 
310 /*
311  * Unbusy a busy filesystem.
312  *
313  * Every successful vfs_busy() call must be undone by a vfs_unbusy() call.
314  *
315  * => If keepref is true, preserve reference added by vfs_busy().
316  * => If nextp != NULL, acquire mountlist_lock.
317  */
318 void
319 vfs_unbusy(struct mount *mp, bool keepref, struct mount **nextp)
320 {
321 
322 	KASSERT(mp->mnt_refcnt > 0);
323 
324 	if (nextp != NULL) {
325 		mutex_enter(&mountlist_lock);
326 	}
327 	mutex_enter(&mp->mnt_unmounting);
328 	KASSERT(mp->mnt_busynest != 0);
329 	mp->mnt_busynest--;
330 	mutex_exit(&mp->mnt_unmounting);
331 	if (!keepref) {
332 		vfs_destroy(mp);
333 	}
334 	if (nextp != NULL) {
335 		KASSERT(mutex_owned(&mountlist_lock));
336 		*nextp = TAILQ_NEXT(mp, mnt_list);
337 	}
338 }
339 
340 /*
341  * Insert a marker vnode into a mount's vnode list, after the
342  * specified vnode.  mntvnode_lock must be held.
343  */
344 void
345 vmark(vnode_t *mvp, vnode_t *vp)
346 {
347 	struct mount *mp = mvp->v_mount;
348 
349 	KASSERT(mutex_owned(&mntvnode_lock));
350 	KASSERT((mvp->v_iflag & VI_MARKER) != 0);
351 	KASSERT(vp->v_mount == mp);
352 
353 	TAILQ_INSERT_AFTER(&mp->mnt_vnodelist, vp, mvp, v_mntvnodes);
354 }
355 
356 /*
357  * Remove a marker vnode from a mount's vnode list, and return
358  * a pointer to the next vnode in the list.  mntvnode_lock must
359  * be held.
360  */
361 vnode_t *
362 vunmark(vnode_t *mvp)
363 {
364 	struct mount *mp = mvp->v_mount;
365 	vnode_t *vp;
366 
367 	KASSERT(mutex_owned(&mntvnode_lock));
368 	KASSERT((mvp->v_iflag & VI_MARKER) != 0);
369 
370 	vp = TAILQ_NEXT(mvp, v_mntvnodes);
371 	TAILQ_REMOVE(&mp->mnt_vnodelist, mvp, v_mntvnodes);
372 
373 	KASSERT(vp == NULL || vp->v_mount == mp);
374 
375 	return vp;
376 }
377 
378 /*
379  * Move a vnode from one mount queue to another.
380  */
381 void
382 vfs_insmntque(vnode_t *vp, struct mount *mp)
383 {
384 	struct mount *omp;
385 
386 	KASSERT(mp == NULL || (mp->mnt_iflag & IMNT_UNMOUNT) == 0 ||
387 	    vp->v_tag == VT_VFS);
388 
389 	mutex_enter(&mntvnode_lock);
390 	/*
391 	 * Delete from old mount point vnode list, if on one.
392 	 */
393 	if ((omp = vp->v_mount) != NULL)
394 		TAILQ_REMOVE(&vp->v_mount->mnt_vnodelist, vp, v_mntvnodes);
395 	/*
396 	 * Insert into list of vnodes for the new mount point, if
397 	 * available.  The caller must take a reference on the mount
398 	 * structure and donate to the vnode.
399 	 */
400 	if ((vp->v_mount = mp) != NULL)
401 		TAILQ_INSERT_TAIL(&mp->mnt_vnodelist, vp, v_mntvnodes);
402 	mutex_exit(&mntvnode_lock);
403 
404 	if (omp != NULL) {
405 		/* Release reference to old mount. */
406 		vfs_destroy(omp);
407 	}
408 }
409 
410 /*
411  * Remove any vnodes in the vnode table belonging to mount point mp.
412  *
413  * If FORCECLOSE is not specified, there should not be any active ones,
414  * return error if any are found (nb: this is a user error, not a
415  * system error). If FORCECLOSE is specified, detach any active vnodes
416  * that are found.
417  *
418  * If WRITECLOSE is set, only flush out regular file vnodes open for
419  * writing.
420  *
421  * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
422  */
423 #ifdef DEBUG
424 int busyprt = 0;	/* print out busy vnodes */
425 struct ctldebug debug1 = { "busyprt", &busyprt };
426 #endif
427 
428 static vnode_t *
429 vflushnext(vnode_t *mvp, int *when)
430 {
431 
432 	if (hardclock_ticks > *when) {
433 		mutex_exit(&mntvnode_lock);
434 		yield();
435 		mutex_enter(&mntvnode_lock);
436 		*when = hardclock_ticks + hz / 10;
437 	}
438 	return vunmark(mvp);
439 }
440 
441 int
442 vflush(struct mount *mp, vnode_t *skipvp, int flags)
443 {
444 	vnode_t *vp, *mvp;
445 	int busy = 0, when = 0;
446 
447 	/* First, flush out any vnode references from vrele_list. */
448 	vrele_flush();
449 
450 	/* Allocate a marker vnode. */
451 	mvp = vnalloc(mp);
452 
453 	/*
454 	 * NOTE: not using the TAILQ_FOREACH here since in this loop vgone()
455 	 * and vclean() are called.
456 	 */
457 	mutex_enter(&mntvnode_lock);
458 	for (vp = TAILQ_FIRST(&mp->mnt_vnodelist);
459 	    vp != NULL;
460 	    vp = vflushnext(mvp, &when)) {
461 		vmark(mvp, vp);
462 		if (vp->v_mount != mp || vismarker(vp))
463 			continue;
464 		/*
465 		 * Skip over a selected vnode.
466 		 */
467 		if (vp == skipvp)
468 			continue;
469 		/*
470 		 * First try to recycle the vnode.
471 		 */
472 		if (vrecycle(vp, &mntvnode_lock)) {
473 			mutex_enter(&mntvnode_lock);
474 			continue;
475 		}
476 		mutex_enter(vp->v_interlock);
477 		/*
478 		 * Ignore clean but still referenced vnodes.
479 		 */
480 		if ((vp->v_iflag & VI_CLEAN) != 0) {
481 			mutex_exit(vp->v_interlock);
482 			continue;
483 		}
484 		/*
485 		 * Skip over a vnodes marked VSYSTEM.
486 		 */
487 		if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) {
488 			mutex_exit(vp->v_interlock);
489 			continue;
490 		}
491 		/*
492 		 * If WRITECLOSE is set, only flush out regular file
493 		 * vnodes open for writing.
494 		 */
495 		if ((flags & WRITECLOSE) &&
496 		    (vp->v_writecount == 0 || vp->v_type != VREG)) {
497 			mutex_exit(vp->v_interlock);
498 			continue;
499 		}
500 		/*
501 		 * If FORCECLOSE is set, forcibly close the vnode.
502 		 * For block or character devices, revert to an
503 		 * anonymous device.  For all other files, just
504 		 * kill them.
505 		 */
506 		if (flags & FORCECLOSE) {
507 			mutex_exit(&mntvnode_lock);
508 			if (vget(vp, 0) == 0)
509 				vgone(vp);
510 			mutex_enter(&mntvnode_lock);
511 			continue;
512 		}
513 #ifdef DEBUG
514 		if (busyprt)
515 			vprint("vflush: busy vnode", vp);
516 #endif
517 		mutex_exit(vp->v_interlock);
518 		busy++;
519 	}
520 	mutex_exit(&mntvnode_lock);
521 	vnfree(mvp);
522 	if (busy)
523 		return (EBUSY);
524 	return (0);
525 }
526 
527 /*
528  * Remove clean vnodes from a mountpoint's vnode list.
529  */
530 void
531 vfs_scrubvnlist(struct mount *mp)
532 {
533 	vnode_t *vp, *nvp;
534 
535 retry:
536 	mutex_enter(&mntvnode_lock);
537 	TAILQ_FOREACH_SAFE(vp, &mp->mnt_vnodelist, v_mntvnodes, nvp) {
538 		mutex_enter(vp->v_interlock);
539 		if ((vp->v_iflag & VI_CLEAN) != 0) {
540 			TAILQ_REMOVE(&mp->mnt_vnodelist, vp, v_mntvnodes);
541 			vp->v_mount = NULL;
542 			mutex_exit(&mntvnode_lock);
543 			mutex_exit(vp->v_interlock);
544 			vfs_destroy(mp);
545 			goto retry;
546 		}
547 		mutex_exit(vp->v_interlock);
548 	}
549 	mutex_exit(&mntvnode_lock);
550 }
551 
552 /*
553  * Mount a file system.
554  */
555 
556 /*
557  * Scan all active processes to see if any of them have a current or root
558  * directory onto which the new filesystem has just been  mounted. If so,
559  * replace them with the new mount point.
560  */
561 static void
562 mount_checkdirs(vnode_t *olddp)
563 {
564 	vnode_t *newdp, *rele1, *rele2;
565 	struct cwdinfo *cwdi;
566 	struct proc *p;
567 	bool retry;
568 
569 	if (olddp->v_usecount == 1) {
570 		return;
571 	}
572 	if (VFS_ROOT(olddp->v_mountedhere, &newdp))
573 		panic("mount: lost mount");
574 
575 	do {
576 		retry = false;
577 		mutex_enter(proc_lock);
578 		PROCLIST_FOREACH(p, &allproc) {
579 			if ((cwdi = p->p_cwdi) == NULL)
580 				continue;
581 			/*
582 			 * Cannot change to the old directory any more,
583 			 * so even if we see a stale value it is not a
584 			 * problem.
585 			 */
586 			if (cwdi->cwdi_cdir != olddp &&
587 			    cwdi->cwdi_rdir != olddp)
588 				continue;
589 			retry = true;
590 			rele1 = NULL;
591 			rele2 = NULL;
592 			atomic_inc_uint(&cwdi->cwdi_refcnt);
593 			mutex_exit(proc_lock);
594 			rw_enter(&cwdi->cwdi_lock, RW_WRITER);
595 			if (cwdi->cwdi_cdir == olddp) {
596 				rele1 = cwdi->cwdi_cdir;
597 				vref(newdp);
598 				cwdi->cwdi_cdir = newdp;
599 			}
600 			if (cwdi->cwdi_rdir == olddp) {
601 				rele2 = cwdi->cwdi_rdir;
602 				vref(newdp);
603 				cwdi->cwdi_rdir = newdp;
604 			}
605 			rw_exit(&cwdi->cwdi_lock);
606 			cwdfree(cwdi);
607 			if (rele1 != NULL)
608 				vrele(rele1);
609 			if (rele2 != NULL)
610 				vrele(rele2);
611 			mutex_enter(proc_lock);
612 			break;
613 		}
614 		mutex_exit(proc_lock);
615 	} while (retry);
616 
617 	if (rootvnode == olddp) {
618 		vrele(rootvnode);
619 		vref(newdp);
620 		rootvnode = newdp;
621 	}
622 	vput(newdp);
623 }
624 
625 int
626 mount_domount(struct lwp *l, vnode_t **vpp, struct vfsops *vfsops,
627     const char *path, int flags, void *data, size_t *data_len)
628 {
629 	vnode_t *vp = *vpp;
630 	struct mount *mp;
631 	struct pathbuf *pb;
632 	struct nameidata nd;
633 	int error;
634 
635 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
636 	    KAUTH_REQ_SYSTEM_MOUNT_NEW, vp, KAUTH_ARG(flags), data);
637 	if (error) {
638 		vfs_delref(vfsops);
639 		return error;
640 	}
641 
642 	/* Cannot make a non-dir a mount-point (from here anyway). */
643 	if (vp->v_type != VDIR) {
644 		vfs_delref(vfsops);
645 		return ENOTDIR;
646 	}
647 
648 	if (flags & MNT_EXPORTED) {
649 		vfs_delref(vfsops);
650 		return EINVAL;
651 	}
652 
653 	if ((mp = vfs_mountalloc(vfsops, vp)) == NULL) {
654 		vfs_delref(vfsops);
655 		return ENOMEM;
656 	}
657 
658 	mp->mnt_stat.f_owner = kauth_cred_geteuid(l->l_cred);
659 
660 	/*
661 	 * The underlying file system may refuse the mount for
662 	 * various reasons.  Allow the user to force it to happen.
663 	 *
664 	 * Set the mount level flags.
665 	 */
666 	mp->mnt_flag = flags & (MNT_BASIC_FLAGS | MNT_FORCE | MNT_IGNORE);
667 
668 	mutex_enter(&mp->mnt_updating);
669 	error = VFS_MOUNT(mp, path, data, data_len);
670 	mp->mnt_flag &= ~MNT_OP_FLAGS;
671 
672 	if (error != 0)
673 		goto err_unmounted;
674 
675 	/*
676 	 * Validate and prepare the mount point.
677 	 */
678 	error = pathbuf_copyin(path, &pb);
679 	if (error != 0) {
680 		goto err_mounted;
681 	}
682 	NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, pb);
683 	error = namei(&nd);
684 	pathbuf_destroy(pb);
685 	if (error != 0) {
686 		goto err_mounted;
687 	}
688 	if (nd.ni_vp != vp) {
689 		vput(nd.ni_vp);
690 		error = EINVAL;
691 		goto err_mounted;
692 	}
693 	if (vp->v_mountedhere != NULL) {
694 		vput(nd.ni_vp);
695 		error = EBUSY;
696 		goto err_mounted;
697 	}
698 	error = vinvalbuf(vp, V_SAVE, l->l_cred, l, 0, 0);
699 	if (error != 0) {
700 		vput(nd.ni_vp);
701 		goto err_mounted;
702 	}
703 
704 	/*
705 	 * Put the new filesystem on the mount list after root.
706 	 */
707 	cache_purge(vp);
708 	mp->mnt_iflag &= ~IMNT_WANTRDWR;
709 
710 	mutex_enter(&mountlist_lock);
711 	TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
712 	mutex_exit(&mountlist_lock);
713 	if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0)
714 		error = vfs_allocate_syncvnode(mp);
715 	if (error == 0)
716 		vp->v_mountedhere = mp;
717 	vput(nd.ni_vp);
718 	if (error != 0)
719 		goto err_onmountlist;
720 
721 	mount_checkdirs(vp);
722 	mutex_exit(&mp->mnt_updating);
723 
724 	/* Hold an additional reference to the mount across VFS_START(). */
725 	vfs_unbusy(mp, true, NULL);
726 	(void) VFS_STATVFS(mp, &mp->mnt_stat);
727 	error = VFS_START(mp, 0);
728        if (error) {
729 		vrele(vp);
730        } else if (flags & MNT_EXTATTR) {
731 	       error = VFS_EXTATTRCTL(vp->v_mountedhere,
732 		   EXTATTR_CMD_START, NULL, 0, NULL);
733 	       if (error)
734 		       printf("%s: failed to start extattr: error = %d\n",
735 			   vp->v_mountedhere->mnt_stat.f_mntonname, error);
736        }
737 	/* Drop reference held for VFS_START(). */
738 	vfs_destroy(mp);
739 	*vpp = NULL;
740 	return error;
741 
742 err_onmountlist:
743 	mutex_enter(&mountlist_lock);
744 	TAILQ_REMOVE(&mountlist, mp, mnt_list);
745 	mp->mnt_iflag |= IMNT_GONE;
746 	mutex_exit(&mountlist_lock);
747 
748 err_mounted:
749 	if (VFS_UNMOUNT(mp, MNT_FORCE) != 0)
750 		panic("Unmounting fresh file system failed");
751 
752 err_unmounted:
753 	vp->v_mountedhere = NULL;
754 	mutex_exit(&mp->mnt_updating);
755 	vfs_unbusy(mp, false, NULL);
756 	vfs_destroy(mp);
757 
758 	return error;
759 }
760 
761 /*
762  * Do the actual file system unmount.  File system is assumed to have
763  * been locked by the caller.
764  *
765  * => Caller hold reference to the mount, explicitly for dounmount().
766  */
767 int
768 dounmount(struct mount *mp, int flags, struct lwp *l)
769 {
770 	vnode_t *coveredvp;
771 	int error, async, used_syncer;
772 
773 #if NVERIEXEC > 0
774 	error = veriexec_unmountchk(mp);
775 	if (error)
776 		return (error);
777 #endif /* NVERIEXEC > 0 */
778 
779 	/*
780 	 * XXX Freeze syncer.  Must do this before locking the
781 	 * mount point.  See dounmount() for details.
782 	 */
783 	mutex_enter(&syncer_mutex);
784 
785 	/*
786 	 * Abort unmount attempt when the filesystem is in use
787 	 */
788 	mutex_enter(&mp->mnt_unmounting);
789 	if (mp->mnt_busynest != 0) {
790 		mutex_exit(&mp->mnt_unmounting);
791 		mutex_exit(&syncer_mutex);
792 		return EBUSY;
793 	}
794 
795 	/*
796 	 * Abort unmount attempt when the filesystem is not mounted
797 	 */
798 	if ((mp->mnt_iflag & IMNT_GONE) != 0) {
799 		mutex_exit(&mp->mnt_unmounting);
800 		mutex_exit(&syncer_mutex);
801 		return ENOENT;
802 	}
803 
804 	used_syncer = (mp->mnt_syncer != NULL);
805 
806 	/*
807 	 * XXX Syncer must be frozen when we get here.  This should really
808 	 * be done on a per-mountpoint basis, but the syncer doesn't work
809 	 * like that.
810 	 *
811 	 * The caller of dounmount() must acquire syncer_mutex because
812 	 * the syncer itself acquires locks in syncer_mutex -> vfs_busy
813 	 * order, and we must preserve that order to avoid deadlock.
814 	 *
815 	 * So, if the file system did not use the syncer, now is
816 	 * the time to release the syncer_mutex.
817 	 */
818 	if (used_syncer == 0) {
819 		mutex_exit(&syncer_mutex);
820 	}
821 	mp->mnt_iflag |= IMNT_UNMOUNT;
822 	mutex_enter(&mp->mnt_updating);
823 	async = mp->mnt_flag & MNT_ASYNC;
824 	mp->mnt_flag &= ~MNT_ASYNC;
825 	cache_purgevfs(mp);	/* remove cache entries for this file sys */
826 	if (mp->mnt_syncer != NULL)
827 		vfs_deallocate_syncvnode(mp);
828 	error = 0;
829 	if ((mp->mnt_flag & MNT_RDONLY) == 0) {
830 		error = VFS_SYNC(mp, MNT_WAIT, l->l_cred);
831 	}
832 	vfs_scrubvnlist(mp);
833 	if (error == 0 || (flags & MNT_FORCE)) {
834 		error = VFS_UNMOUNT(mp, flags);
835 	}
836 	if (error) {
837 		mp->mnt_iflag &= ~IMNT_UNMOUNT;
838 		mutex_exit(&mp->mnt_unmounting);
839 		if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0)
840 			(void) vfs_allocate_syncvnode(mp);
841 		mp->mnt_flag |= async;
842 		mutex_exit(&mp->mnt_updating);
843 		if (used_syncer)
844 			mutex_exit(&syncer_mutex);
845 		return (error);
846 	}
847 	mutex_exit(&mp->mnt_updating);
848 	vfs_scrubvnlist(mp);
849 
850 	/*
851 	 * release mnt_umounting lock here, because other code calls
852 	 * vfs_busy() while holding the mountlist_lock.
853 	 *
854 	 * mark filesystem as gone to prevent further umounts
855 	 * after mnt_umounting lock is gone, this also prevents
856 	 * vfs_busy() from succeeding.
857 	 */
858 	mp->mnt_iflag |= IMNT_GONE;
859 	mutex_exit(&mp->mnt_unmounting);
860 
861 	if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
862 		vn_lock(coveredvp, LK_EXCLUSIVE | LK_RETRY);
863 		coveredvp->v_mountedhere = NULL;
864 		VOP_UNLOCK(coveredvp);
865 	}
866 	mutex_enter(&mountlist_lock);
867 	TAILQ_REMOVE(&mountlist, mp, mnt_list);
868 	mutex_exit(&mountlist_lock);
869 	if (TAILQ_FIRST(&mp->mnt_vnodelist) != NULL)
870 		panic("unmount: dangling vnode");
871 	if (used_syncer)
872 		mutex_exit(&syncer_mutex);
873 	vfs_hooks_unmount(mp);
874 
875 	vfs_destroy(mp);	/* reference from mount() */
876 	if (coveredvp != NULLVP) {
877 		vrele(coveredvp);
878 	}
879 	return (0);
880 }
881 
882 /*
883  * Unmount all file systems.
884  * We traverse the list in reverse order under the assumption that doing so
885  * will avoid needing to worry about dependencies.
886  */
887 bool
888 vfs_unmountall(struct lwp *l)
889 {
890 
891 	printf("unmounting file systems...\n");
892 	return vfs_unmountall1(l, true, true);
893 }
894 
895 static void
896 vfs_unmount_print(struct mount *mp, const char *pfx)
897 {
898 
899 	aprint_verbose("%sunmounted %s on %s type %s\n", pfx,
900 	    mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname,
901 	    mp->mnt_stat.f_fstypename);
902 }
903 
904 bool
905 vfs_unmount_forceone(struct lwp *l)
906 {
907 	struct mount *mp, *nmp;
908 	int error;
909 
910 	nmp = NULL;
911 
912 	TAILQ_FOREACH_REVERSE(mp, &mountlist, mntlist, mnt_list) {
913 		if (nmp == NULL || mp->mnt_gen > nmp->mnt_gen) {
914 			nmp = mp;
915 		}
916 	}
917 	if (nmp == NULL) {
918 		return false;
919 	}
920 
921 #ifdef DEBUG
922 	printf("forcefully unmounting %s (%s)...\n",
923 	    nmp->mnt_stat.f_mntonname, nmp->mnt_stat.f_mntfromname);
924 #endif
925 	atomic_inc_uint(&nmp->mnt_refcnt);
926 	if ((error = dounmount(nmp, MNT_FORCE, l)) == 0) {
927 		vfs_unmount_print(nmp, "forcefully ");
928 		return true;
929 	} else {
930 		vfs_destroy(nmp);
931 	}
932 
933 #ifdef DEBUG
934 	printf("forceful unmount of %s failed with error %d\n",
935 	    nmp->mnt_stat.f_mntonname, error);
936 #endif
937 
938 	return false;
939 }
940 
941 bool
942 vfs_unmountall1(struct lwp *l, bool force, bool verbose)
943 {
944 	struct mount *mp, *nmp;
945 	bool any_error = false, progress = false;
946 	int error;
947 
948 	TAILQ_FOREACH_REVERSE_SAFE(mp, &mountlist, mntlist, mnt_list, nmp) {
949 #ifdef DEBUG
950 		printf("unmounting %p %s (%s)...\n",
951 		    (void *)mp, mp->mnt_stat.f_mntonname,
952 		    mp->mnt_stat.f_mntfromname);
953 #endif
954 		atomic_inc_uint(&mp->mnt_refcnt);
955 		if ((error = dounmount(mp, force ? MNT_FORCE : 0, l)) == 0) {
956 			vfs_unmount_print(mp, "");
957 			progress = true;
958 		} else {
959 			vfs_destroy(mp);
960 			if (verbose) {
961 				printf("unmount of %s failed with error %d\n",
962 				    mp->mnt_stat.f_mntonname, error);
963 			}
964 			any_error = true;
965 		}
966 	}
967 	if (verbose) {
968 		printf("unmounting done\n");
969 	}
970 	if (any_error && verbose) {
971 		printf("WARNING: some file systems would not unmount\n");
972 	}
973 	return progress;
974 }
975 
976 void
977 vfs_sync_all(struct lwp *l)
978 {
979 	printf("syncing disks... ");
980 
981 	/* remove user processes from run queue */
982 	suspendsched();
983 	(void)spl0();
984 
985 	/* avoid coming back this way again if we panic. */
986 	doing_shutdown = 1;
987 
988 	do_sys_sync(l);
989 
990 	/* Wait for sync to finish. */
991 	if (buf_syncwait() != 0) {
992 #if defined(DDB) && defined(DEBUG_HALT_BUSY)
993 		Debugger();
994 #endif
995 		printf("giving up\n");
996 		return;
997 	} else
998 		printf("done\n");
999 }
1000 
1001 /*
1002  * Sync and unmount file systems before shutting down.
1003  */
1004 void
1005 vfs_shutdown(void)
1006 {
1007 	lwp_t *l = curlwp;
1008 
1009 	vfs_sync_all(l);
1010 
1011 	/*
1012 	 * If we have paniced - do not make the situation potentially
1013 	 * worse by unmounting the file systems.
1014 	 */
1015 	if (panicstr != NULL) {
1016 		return;
1017 	}
1018 
1019 	/* Unmount file systems. */
1020 	vfs_unmountall(l);
1021 }
1022 
1023 /*
1024  * Print a list of supported file system types (used by vfs_mountroot)
1025  */
1026 static void
1027 vfs_print_fstypes(void)
1028 {
1029 	struct vfsops *v;
1030 	int cnt = 0;
1031 
1032 	mutex_enter(&vfs_list_lock);
1033 	LIST_FOREACH(v, &vfs_list, vfs_list)
1034 		++cnt;
1035 	mutex_exit(&vfs_list_lock);
1036 
1037 	if (cnt == 0) {
1038 		printf("WARNING: No file system modules have been loaded.\n");
1039 		return;
1040 	}
1041 
1042 	printf("Supported file systems:");
1043 	mutex_enter(&vfs_list_lock);
1044 	LIST_FOREACH(v, &vfs_list, vfs_list) {
1045 		printf(" %s", v->vfs_name);
1046 	}
1047 	mutex_exit(&vfs_list_lock);
1048 	printf("\n");
1049 }
1050 
1051 /*
1052  * Mount the root file system.  If the operator didn't specify a
1053  * file system to use, try all possible file systems until one
1054  * succeeds.
1055  */
1056 int
1057 vfs_mountroot(void)
1058 {
1059 	struct vfsops *v;
1060 	int error = ENODEV;
1061 
1062 	if (root_device == NULL)
1063 		panic("vfs_mountroot: root device unknown");
1064 
1065 	switch (device_class(root_device)) {
1066 	case DV_IFNET:
1067 		if (rootdev != NODEV)
1068 			panic("vfs_mountroot: rootdev set for DV_IFNET "
1069 			    "(0x%llx -> %llu,%llu)",
1070 			    (unsigned long long)rootdev,
1071 			    (unsigned long long)major(rootdev),
1072 			    (unsigned long long)minor(rootdev));
1073 		break;
1074 
1075 	case DV_DISK:
1076 		if (rootdev == NODEV)
1077 			panic("vfs_mountroot: rootdev not set for DV_DISK");
1078 	        if (bdevvp(rootdev, &rootvp))
1079 	                panic("vfs_mountroot: can't get vnode for rootdev");
1080 		error = VOP_OPEN(rootvp, FREAD, FSCRED);
1081 		if (error) {
1082 			printf("vfs_mountroot: can't open root device\n");
1083 			return (error);
1084 		}
1085 		break;
1086 
1087 	case DV_VIRTUAL:
1088 		break;
1089 
1090 	default:
1091 		printf("%s: inappropriate for root file system\n",
1092 		    device_xname(root_device));
1093 		return (ENODEV);
1094 	}
1095 
1096 	/*
1097 	 * If user specified a root fs type, use it.  Make sure the
1098 	 * specified type exists and has a mount_root()
1099 	 */
1100 	if (strcmp(rootfstype, ROOT_FSTYPE_ANY) != 0) {
1101 		v = vfs_getopsbyname(rootfstype);
1102 		error = EFTYPE;
1103 		if (v != NULL) {
1104 			if (v->vfs_mountroot != NULL) {
1105 				error = (v->vfs_mountroot)();
1106 			}
1107 			v->vfs_refcount--;
1108 		}
1109 		goto done;
1110 	}
1111 
1112 	/*
1113 	 * Try each file system currently configured into the kernel.
1114 	 */
1115 	mutex_enter(&vfs_list_lock);
1116 	LIST_FOREACH(v, &vfs_list, vfs_list) {
1117 		if (v->vfs_mountroot == NULL)
1118 			continue;
1119 #ifdef DEBUG
1120 		aprint_normal("mountroot: trying %s...\n", v->vfs_name);
1121 #endif
1122 		v->vfs_refcount++;
1123 		mutex_exit(&vfs_list_lock);
1124 		error = (*v->vfs_mountroot)();
1125 		mutex_enter(&vfs_list_lock);
1126 		v->vfs_refcount--;
1127 		if (!error) {
1128 			aprint_normal("root file system type: %s\n",
1129 			    v->vfs_name);
1130 			break;
1131 		}
1132 	}
1133 	mutex_exit(&vfs_list_lock);
1134 
1135 	if (v == NULL) {
1136 		vfs_print_fstypes();
1137 		printf("no file system for %s", device_xname(root_device));
1138 		if (device_class(root_device) == DV_DISK)
1139 			printf(" (dev 0x%llx)", (unsigned long long)rootdev);
1140 		printf("\n");
1141 		error = EFTYPE;
1142 	}
1143 
1144 done:
1145 	if (error && device_class(root_device) == DV_DISK) {
1146 		VOP_CLOSE(rootvp, FREAD, FSCRED);
1147 		vrele(rootvp);
1148 	}
1149 	if (error == 0) {
1150 		struct mount *mp;
1151 		extern struct cwdinfo cwdi0;
1152 
1153 		mp = TAILQ_FIRST(&mountlist);
1154 		mp->mnt_flag |= MNT_ROOTFS;
1155 		mp->mnt_op->vfs_refcount++;
1156 
1157 		/*
1158 		 * Get the vnode for '/'.  Set cwdi0.cwdi_cdir to
1159 		 * reference it.
1160 		 */
1161 		error = VFS_ROOT(mp, &rootvnode);
1162 		if (error)
1163 			panic("cannot find root vnode, error=%d", error);
1164 		cwdi0.cwdi_cdir = rootvnode;
1165 		vref(cwdi0.cwdi_cdir);
1166 		VOP_UNLOCK(rootvnode);
1167 		cwdi0.cwdi_rdir = NULL;
1168 
1169 		/*
1170 		 * Now that root is mounted, we can fixup initproc's CWD
1171 		 * info.  All other processes are kthreads, which merely
1172 		 * share proc0's CWD info.
1173 		 */
1174 		initproc->p_cwdi->cwdi_cdir = rootvnode;
1175 		vref(initproc->p_cwdi->cwdi_cdir);
1176 		initproc->p_cwdi->cwdi_rdir = NULL;
1177 		/*
1178 		 * Enable loading of modules from the filesystem
1179 		 */
1180 		module_load_vfs_init();
1181 
1182 	}
1183 	return (error);
1184 }
1185 
1186 /*
1187  * mount_specific_key_create --
1188  *	Create a key for subsystem mount-specific data.
1189  */
1190 int
1191 mount_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor)
1192 {
1193 
1194 	return specificdata_key_create(mount_specificdata_domain, keyp, dtor);
1195 }
1196 
1197 /*
1198  * mount_specific_key_delete --
1199  *	Delete a key for subsystem mount-specific data.
1200  */
1201 void
1202 mount_specific_key_delete(specificdata_key_t key)
1203 {
1204 
1205 	specificdata_key_delete(mount_specificdata_domain, key);
1206 }
1207 
1208 /*
1209  * mount_initspecific --
1210  *	Initialize a mount's specificdata container.
1211  */
1212 void
1213 mount_initspecific(struct mount *mp)
1214 {
1215 	int error __diagused;
1216 
1217 	error = specificdata_init(mount_specificdata_domain,
1218 				  &mp->mnt_specdataref);
1219 	KASSERT(error == 0);
1220 }
1221 
1222 /*
1223  * mount_finispecific --
1224  *	Finalize a mount's specificdata container.
1225  */
1226 void
1227 mount_finispecific(struct mount *mp)
1228 {
1229 
1230 	specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref);
1231 }
1232 
1233 /*
1234  * mount_getspecific --
1235  *	Return mount-specific data corresponding to the specified key.
1236  */
1237 void *
1238 mount_getspecific(struct mount *mp, specificdata_key_t key)
1239 {
1240 
1241 	return specificdata_getspecific(mount_specificdata_domain,
1242 					 &mp->mnt_specdataref, key);
1243 }
1244 
1245 /*
1246  * mount_setspecific --
1247  *	Set mount-specific data corresponding to the specified key.
1248  */
1249 void
1250 mount_setspecific(struct mount *mp, specificdata_key_t key, void *data)
1251 {
1252 
1253 	specificdata_setspecific(mount_specificdata_domain,
1254 				 &mp->mnt_specdataref, key, data);
1255 }
1256 
1257 /*
1258  * Check to see if a filesystem is mounted on a block device.
1259  */
1260 int
1261 vfs_mountedon(vnode_t *vp)
1262 {
1263 	vnode_t *vq;
1264 	int error = 0;
1265 
1266 	if (vp->v_type != VBLK)
1267 		return ENOTBLK;
1268 	if (spec_node_getmountedfs(vp) != NULL)
1269 		return EBUSY;
1270 	if (spec_node_lookup_by_dev(vp->v_type, vp->v_rdev, &vq) == 0) {
1271 		if (spec_node_getmountedfs(vq) != NULL)
1272 			error = EBUSY;
1273 		vrele(vq);
1274 	}
1275 
1276 	return error;
1277 }
1278 
1279 /*
1280  * Check if a device pointed to by vp is mounted.
1281  *
1282  * Returns:
1283  *   EINVAL	if it's not a disk
1284  *   EBUSY	if it's a disk and mounted
1285  *   0		if it's a disk and not mounted
1286  */
1287 int
1288 rawdev_mounted(vnode_t *vp, vnode_t **bvpp)
1289 {
1290 	vnode_t *bvp;
1291 	dev_t dev;
1292 	int d_type;
1293 
1294 	bvp = NULL;
1295 	d_type = D_OTHER;
1296 
1297 	if (iskmemvp(vp))
1298 		return EINVAL;
1299 
1300 	switch (vp->v_type) {
1301 	case VCHR: {
1302 		const struct cdevsw *cdev;
1303 
1304 		dev = vp->v_rdev;
1305 		cdev = cdevsw_lookup(dev);
1306 		if (cdev != NULL) {
1307 			dev_t blkdev;
1308 
1309 			blkdev = devsw_chr2blk(dev);
1310 			if (blkdev != NODEV) {
1311 				if (vfinddev(blkdev, VBLK, &bvp) != 0) {
1312 					d_type = (cdev->d_flag & D_TYPEMASK);
1313 					/* XXX: what if bvp disappears? */
1314 					vrele(bvp);
1315 				}
1316 			}
1317 		}
1318 
1319 		break;
1320 		}
1321 
1322 	case VBLK: {
1323 		const struct bdevsw *bdev;
1324 
1325 		dev = vp->v_rdev;
1326 		bdev = bdevsw_lookup(dev);
1327 		if (bdev != NULL)
1328 			d_type = (bdev->d_flag & D_TYPEMASK);
1329 
1330 		bvp = vp;
1331 
1332 		break;
1333 		}
1334 
1335 	default:
1336 		break;
1337 	}
1338 
1339 	if (d_type != D_DISK)
1340 		return EINVAL;
1341 
1342 	if (bvpp != NULL)
1343 		*bvpp = bvp;
1344 
1345 	/*
1346 	 * XXX: This is bogus. We should be failing the request
1347 	 * XXX: not only if this specific slice is mounted, but
1348 	 * XXX: if it's on a disk with any other mounted slice.
1349 	 */
1350 	if (vfs_mountedon(bvp))
1351 		return EBUSY;
1352 
1353 	return 0;
1354 }
1355 
1356 /*
1357  * Make a 'unique' number from a mount type name.
1358  */
1359 long
1360 makefstype(const char *type)
1361 {
1362 	long rv;
1363 
1364 	for (rv = 0; *type; type++) {
1365 		rv <<= 2;
1366 		rv ^= *type;
1367 	}
1368 	return rv;
1369 }
1370 
1371 void
1372 mountlist_append(struct mount *mp)
1373 {
1374 	mutex_enter(&mountlist_lock);
1375 	TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
1376 	mutex_exit(&mountlist_lock);
1377 }
1378