1 /* $NetBSD: vfs_mount.c,v 1.40 2016/07/07 06:55:43 msaitoh 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.40 2016/07/07 06:55:43 msaitoh Exp $");
71
72 #define _VFS_VNODE_PRIVATE
73
74 #include <sys/param.h>
75 #include <sys/kernel.h>
76
77 #include <sys/atomic.h>
78 #include <sys/buf.h>
79 #include <sys/conf.h>
80 #include <sys/fcntl.h>
81 #include <sys/filedesc.h>
82 #include <sys/device.h>
83 #include <sys/kauth.h>
84 #include <sys/kmem.h>
85 #include <sys/module.h>
86 #include <sys/mount.h>
87 #include <sys/namei.h>
88 #include <sys/extattr.h>
89 #include <sys/syscallargs.h>
90 #include <sys/sysctl.h>
91 #include <sys/systm.h>
92 #include <sys/vfs_syscalls.h>
93 #include <sys/vnode.h>
94
95 #include <miscfs/genfs/genfs.h>
96 #include <miscfs/specfs/specdev.h>
97
98 /* Root filesystem. */
99 vnode_t * rootvnode;
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
vfs_mount_sysinit(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 *
vfs_mountalloc(struct vfsops * vfsops,vnode_t * vp)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
vfs_rootmountalloc(const char * fstypename,const char * devname,struct mount ** mpp)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
vfs_getnewfsid(struct mount * mp)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 *
vfs_getvfs(fsid_t * fsid)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
vfs_destroy(struct mount * mp)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
vfs_busy(struct mount * mp,struct mount ** nextp)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
vfs_unbusy(struct mount * mp,bool keepref,struct mount ** nextp)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 struct vnode_iterator {
341 struct vnode vi_vnode;
342 };
343
344 void
vfs_vnode_iterator_init(struct mount * mp,struct vnode_iterator ** vip)345 vfs_vnode_iterator_init(struct mount *mp, struct vnode_iterator **vip)
346 {
347 struct vnode *vp;
348
349 vp = vnalloc_marker(mp);
350
351 mutex_enter(&mntvnode_lock);
352 TAILQ_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
353 vp->v_usecount = 1;
354 mutex_exit(&mntvnode_lock);
355
356 *vip = (struct vnode_iterator *)vp;
357 }
358
359 void
vfs_vnode_iterator_destroy(struct vnode_iterator * vi)360 vfs_vnode_iterator_destroy(struct vnode_iterator *vi)
361 {
362 struct vnode *mvp = &vi->vi_vnode;
363
364 mutex_enter(&mntvnode_lock);
365 KASSERT(vnis_marker(mvp));
366 if (mvp->v_usecount != 0) {
367 TAILQ_REMOVE(&mvp->v_mount->mnt_vnodelist, mvp, v_mntvnodes);
368 mvp->v_usecount = 0;
369 }
370 mutex_exit(&mntvnode_lock);
371 vnfree_marker(mvp);
372 }
373
374 struct vnode *
vfs_vnode_iterator_next(struct vnode_iterator * vi,bool (* f)(void *,struct vnode *),void * cl)375 vfs_vnode_iterator_next(struct vnode_iterator *vi,
376 bool (*f)(void *, struct vnode *), void *cl)
377 {
378 struct vnode *mvp = &vi->vi_vnode;
379 struct mount *mp = mvp->v_mount;
380 struct vnode *vp;
381 int error;
382
383 KASSERT(vnis_marker(mvp));
384
385 do {
386 mutex_enter(&mntvnode_lock);
387 vp = TAILQ_NEXT(mvp, v_mntvnodes);
388 TAILQ_REMOVE(&mp->mnt_vnodelist, mvp, v_mntvnodes);
389 mvp->v_usecount = 0;
390 again:
391 if (vp == NULL) {
392 mutex_exit(&mntvnode_lock);
393 return NULL;
394 }
395 mutex_enter(vp->v_interlock);
396 if (vnis_marker(vp) ||
397 vdead_check(vp, VDEAD_NOWAIT) ||
398 (f && !(*f)(cl, vp))) {
399 mutex_exit(vp->v_interlock);
400 vp = TAILQ_NEXT(vp, v_mntvnodes);
401 goto again;
402 }
403
404 TAILQ_INSERT_AFTER(&mp->mnt_vnodelist, vp, mvp, v_mntvnodes);
405 mvp->v_usecount = 1;
406 mutex_exit(&mntvnode_lock);
407 error = vget(vp, 0, true /* wait */);
408 KASSERT(error == 0 || error == ENOENT);
409 } while (error != 0);
410
411 return vp;
412 }
413
414 /*
415 * Move a vnode from one mount queue to another.
416 */
417 void
vfs_insmntque(vnode_t * vp,struct mount * mp)418 vfs_insmntque(vnode_t *vp, struct mount *mp)
419 {
420 struct mount *omp;
421
422 KASSERT(mp == NULL || (mp->mnt_iflag & IMNT_UNMOUNT) == 0 ||
423 vp->v_tag == VT_VFS);
424
425 mutex_enter(&mntvnode_lock);
426 /*
427 * Delete from old mount point vnode list, if on one.
428 */
429 if ((omp = vp->v_mount) != NULL)
430 TAILQ_REMOVE(&vp->v_mount->mnt_vnodelist, vp, v_mntvnodes);
431 /*
432 * Insert into list of vnodes for the new mount point, if
433 * available. The caller must take a reference on the mount
434 * structure and donate to the vnode.
435 */
436 if ((vp->v_mount = mp) != NULL)
437 TAILQ_INSERT_TAIL(&mp->mnt_vnodelist, vp, v_mntvnodes);
438 mutex_exit(&mntvnode_lock);
439
440 if (omp != NULL) {
441 /* Release reference to old mount. */
442 vfs_destroy(omp);
443 }
444 }
445
446 /*
447 * Remove any vnodes in the vnode table belonging to mount point mp.
448 *
449 * If FORCECLOSE is not specified, there should not be any active ones,
450 * return error if any are found (nb: this is a user error, not a
451 * system error). If FORCECLOSE is specified, detach any active vnodes
452 * that are found.
453 *
454 * If WRITECLOSE is set, only flush out regular file vnodes open for
455 * writing.
456 *
457 * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
458 */
459 #ifdef DEBUG
460 int busyprt = 0; /* print out busy vnodes */
461 struct ctldebug debug1 = { "busyprt", &busyprt };
462 #endif
463
464 struct vflush_ctx {
465 const struct vnode *skipvp;
466 int flags;
467 };
468
469 static bool
vflush_selector(void * cl,struct vnode * vp)470 vflush_selector(void *cl, struct vnode *vp)
471 {
472 struct vflush_ctx *c = cl;
473 /*
474 * Skip over a selected vnode.
475 */
476 if (vp == c->skipvp)
477 return false;
478 /*
479 * Skip over a vnodes marked VSYSTEM.
480 */
481 if ((c->flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM))
482 return false;
483
484 /*
485 * If WRITECLOSE is set, only flush out regular file
486 * vnodes open for writing.
487 */
488 if ((c->flags & WRITECLOSE) && vp->v_type == VREG) {
489 if (vp->v_writecount == 0)
490 return false;
491 }
492 return true;
493 }
494
495 static vnode_t *
vflushnext(struct vnode_iterator * marker,void * ctx,int * when)496 vflushnext(struct vnode_iterator *marker, void *ctx, int *when)
497 {
498 if (hardclock_ticks > *when) {
499 yield();
500 *when = hardclock_ticks + hz / 10;
501 }
502 return vfs_vnode_iterator_next(marker, vflush_selector, ctx);
503 }
504
505
506 int
vflush(struct mount * mp,vnode_t * skipvp,int flags)507 vflush(struct mount *mp, vnode_t *skipvp, int flags)
508 {
509 vnode_t *vp;
510 struct vnode_iterator *marker;
511 int error, busy = 0, when = 0;
512 struct vflush_ctx ctx;
513
514 /* First, flush out any vnode references from vrele_list. */
515 vrele_flush();
516
517 vfs_vnode_iterator_init(mp, &marker);
518
519 ctx.skipvp = skipvp;
520 ctx.flags = flags;
521 while ((vp = vflushnext(marker, &ctx, &when)) != NULL) {
522 /*
523 * First try to recycle the vnode.
524 */
525 if (vrecycle(vp))
526 continue;
527 /*
528 * If FORCECLOSE is set, forcibly close the vnode.
529 */
530 if (flags & FORCECLOSE) {
531 vgone(vp);
532 continue;
533 }
534 #ifdef DEBUG
535 if (busyprt)
536 vprint("vflush: busy vnode", vp);
537 #endif
538 vrele(vp);
539 busy++;
540 }
541 vfs_vnode_iterator_destroy(marker);
542 if (busy)
543 return (EBUSY);
544
545 /* Wait for all vnodes to be reclaimed. */
546 for (;;) {
547 mutex_enter(&mntvnode_lock);
548 TAILQ_FOREACH(vp, &mp->mnt_vnodelist, v_mntvnodes) {
549 if (vp == skipvp)
550 continue;
551 if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM))
552 continue;
553 break;
554 }
555 if (vp != NULL) {
556 mutex_enter(vp->v_interlock);
557 mutex_exit(&mntvnode_lock);
558 error = vget(vp, 0, true /* wait */);
559 if (error == ENOENT)
560 continue;
561 else if (error == 0)
562 vrele(vp);
563 return EBUSY;
564 } else {
565 mutex_exit(&mntvnode_lock);
566 return 0;
567 }
568 }
569 }
570
571 /*
572 * Mount a file system.
573 */
574
575 /*
576 * Scan all active processes to see if any of them have a current or root
577 * directory onto which the new filesystem has just been mounted. If so,
578 * replace them with the new mount point.
579 */
580 static void
mount_checkdirs(vnode_t * olddp)581 mount_checkdirs(vnode_t *olddp)
582 {
583 vnode_t *newdp, *rele1, *rele2;
584 struct cwdinfo *cwdi;
585 struct proc *p;
586 bool retry;
587
588 if (olddp->v_usecount == 1) {
589 return;
590 }
591 if (VFS_ROOT(olddp->v_mountedhere, &newdp))
592 panic("mount: lost mount");
593
594 do {
595 retry = false;
596 mutex_enter(proc_lock);
597 PROCLIST_FOREACH(p, &allproc) {
598 if ((cwdi = p->p_cwdi) == NULL)
599 continue;
600 /*
601 * Cannot change to the old directory any more,
602 * so even if we see a stale value it is not a
603 * problem.
604 */
605 if (cwdi->cwdi_cdir != olddp &&
606 cwdi->cwdi_rdir != olddp)
607 continue;
608 retry = true;
609 rele1 = NULL;
610 rele2 = NULL;
611 atomic_inc_uint(&cwdi->cwdi_refcnt);
612 mutex_exit(proc_lock);
613 rw_enter(&cwdi->cwdi_lock, RW_WRITER);
614 if (cwdi->cwdi_cdir == olddp) {
615 rele1 = cwdi->cwdi_cdir;
616 vref(newdp);
617 cwdi->cwdi_cdir = newdp;
618 }
619 if (cwdi->cwdi_rdir == olddp) {
620 rele2 = cwdi->cwdi_rdir;
621 vref(newdp);
622 cwdi->cwdi_rdir = newdp;
623 }
624 rw_exit(&cwdi->cwdi_lock);
625 cwdfree(cwdi);
626 if (rele1 != NULL)
627 vrele(rele1);
628 if (rele2 != NULL)
629 vrele(rele2);
630 mutex_enter(proc_lock);
631 break;
632 }
633 mutex_exit(proc_lock);
634 } while (retry);
635
636 if (rootvnode == olddp) {
637 vrele(rootvnode);
638 vref(newdp);
639 rootvnode = newdp;
640 }
641 vput(newdp);
642 }
643
644 /*
645 * Start extended attributes
646 */
647 static int
start_extattr(struct mount * mp)648 start_extattr(struct mount *mp)
649 {
650 int error;
651
652 error = VFS_EXTATTRCTL(mp, EXTATTR_CMD_START, NULL, 0, NULL);
653 if (error)
654 printf("%s: failed to start extattr: error = %d\n",
655 mp->mnt_stat.f_mntonname, error);
656
657 return error;
658 }
659
660 int
mount_domount(struct lwp * l,vnode_t ** vpp,struct vfsops * vfsops,const char * path,int flags,void * data,size_t * data_len)661 mount_domount(struct lwp *l, vnode_t **vpp, struct vfsops *vfsops,
662 const char *path, int flags, void *data, size_t *data_len)
663 {
664 vnode_t *vp = *vpp;
665 struct mount *mp;
666 struct pathbuf *pb;
667 struct nameidata nd;
668 int error;
669
670 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_MOUNT,
671 KAUTH_REQ_SYSTEM_MOUNT_NEW, vp, KAUTH_ARG(flags), data);
672 if (error) {
673 vfs_delref(vfsops);
674 return error;
675 }
676
677 /* Cannot make a non-dir a mount-point (from here anyway). */
678 if (vp->v_type != VDIR) {
679 vfs_delref(vfsops);
680 return ENOTDIR;
681 }
682
683 if (flags & MNT_EXPORTED) {
684 vfs_delref(vfsops);
685 return EINVAL;
686 }
687
688 if ((mp = vfs_mountalloc(vfsops, vp)) == NULL) {
689 vfs_delref(vfsops);
690 return ENOMEM;
691 }
692
693 mp->mnt_stat.f_owner = kauth_cred_geteuid(l->l_cred);
694
695 /*
696 * The underlying file system may refuse the mount for
697 * various reasons. Allow the user to force it to happen.
698 *
699 * Set the mount level flags.
700 */
701 mp->mnt_flag = flags & (MNT_BASIC_FLAGS | MNT_FORCE | MNT_IGNORE);
702
703 mutex_enter(&mp->mnt_updating);
704 error = VFS_MOUNT(mp, path, data, data_len);
705 mp->mnt_flag &= ~MNT_OP_FLAGS;
706
707 if (error != 0)
708 goto err_unmounted;
709
710 /*
711 * Validate and prepare the mount point.
712 */
713 error = pathbuf_copyin(path, &pb);
714 if (error != 0) {
715 goto err_mounted;
716 }
717 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, pb);
718 error = namei(&nd);
719 pathbuf_destroy(pb);
720 if (error != 0) {
721 goto err_mounted;
722 }
723 if (nd.ni_vp != vp) {
724 vput(nd.ni_vp);
725 error = EINVAL;
726 goto err_mounted;
727 }
728 if (vp->v_mountedhere != NULL) {
729 vput(nd.ni_vp);
730 error = EBUSY;
731 goto err_mounted;
732 }
733 error = vinvalbuf(vp, V_SAVE, l->l_cred, l, 0, 0);
734 if (error != 0) {
735 vput(nd.ni_vp);
736 goto err_mounted;
737 }
738
739 /*
740 * Put the new filesystem on the mount list after root.
741 */
742 cache_purge(vp);
743 mp->mnt_iflag &= ~IMNT_WANTRDWR;
744
745 mutex_enter(&mountlist_lock);
746 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
747 mutex_exit(&mountlist_lock);
748 if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0)
749 vfs_syncer_add_to_worklist(mp);
750 vp->v_mountedhere = mp;
751 vput(nd.ni_vp);
752
753 mount_checkdirs(vp);
754 mutex_exit(&mp->mnt_updating);
755
756 /* Hold an additional reference to the mount across VFS_START(). */
757 vfs_unbusy(mp, true, NULL);
758 (void) VFS_STATVFS(mp, &mp->mnt_stat);
759 error = VFS_START(mp, 0);
760 if (error) {
761 vrele(vp);
762 } else if (flags & MNT_EXTATTR) {
763 (void)start_extattr(mp);
764 }
765 /* Drop reference held for VFS_START(). */
766 vfs_destroy(mp);
767 *vpp = NULL;
768 return error;
769
770 err_mounted:
771 if (VFS_UNMOUNT(mp, MNT_FORCE) != 0)
772 panic("Unmounting fresh file system failed");
773
774 err_unmounted:
775 vp->v_mountedhere = NULL;
776 mutex_exit(&mp->mnt_updating);
777 vfs_unbusy(mp, false, NULL);
778 vfs_destroy(mp);
779
780 return error;
781 }
782
783 /*
784 * Do the actual file system unmount. File system is assumed to have
785 * been locked by the caller.
786 *
787 * => Caller hold reference to the mount, explicitly for dounmount().
788 */
789 int
dounmount(struct mount * mp,int flags,struct lwp * l)790 dounmount(struct mount *mp, int flags, struct lwp *l)
791 {
792 vnode_t *coveredvp;
793 int error, async, used_syncer, used_extattr;
794
795 #if NVERIEXEC > 0
796 error = veriexec_unmountchk(mp);
797 if (error)
798 return (error);
799 #endif /* NVERIEXEC > 0 */
800
801 /*
802 * XXX Freeze syncer. Must do this before locking the
803 * mount point. See dounmount() for details.
804 */
805 mutex_enter(&syncer_mutex);
806
807 /*
808 * Abort unmount attempt when the filesystem is in use
809 */
810 mutex_enter(&mp->mnt_unmounting);
811 if (mp->mnt_busynest != 0) {
812 mutex_exit(&mp->mnt_unmounting);
813 mutex_exit(&syncer_mutex);
814 return EBUSY;
815 }
816
817 /*
818 * Abort unmount attempt when the filesystem is not mounted
819 */
820 if ((mp->mnt_iflag & IMNT_GONE) != 0) {
821 mutex_exit(&mp->mnt_unmounting);
822 mutex_exit(&syncer_mutex);
823 return ENOENT;
824 }
825
826 used_syncer = (mp->mnt_iflag & IMNT_ONWORKLIST) != 0;
827 used_extattr = mp->mnt_flag & MNT_EXTATTR;
828
829 /*
830 * XXX Syncer must be frozen when we get here. This should really
831 * be done on a per-mountpoint basis, but the syncer doesn't work
832 * like that.
833 *
834 * The caller of dounmount() must acquire syncer_mutex because
835 * the syncer itself acquires locks in syncer_mutex -> vfs_busy
836 * order, and we must preserve that order to avoid deadlock.
837 *
838 * So, if the file system did not use the syncer, now is
839 * the time to release the syncer_mutex.
840 */
841 if (used_syncer == 0) {
842 mutex_exit(&syncer_mutex);
843 }
844 mp->mnt_iflag |= IMNT_UNMOUNT;
845 mutex_enter(&mp->mnt_updating);
846 async = mp->mnt_flag & MNT_ASYNC;
847 mp->mnt_flag &= ~MNT_ASYNC;
848 cache_purgevfs(mp); /* remove cache entries for this file sys */
849 if (used_syncer)
850 vfs_syncer_remove_from_worklist(mp);
851 error = 0;
852 if (((mp->mnt_flag & MNT_RDONLY) == 0) && ((flags & MNT_FORCE) == 0)) {
853 error = VFS_SYNC(mp, MNT_WAIT, l->l_cred);
854 }
855 if (error == 0 || (flags & MNT_FORCE)) {
856 error = VFS_UNMOUNT(mp, flags);
857 }
858 if (error) {
859 mp->mnt_iflag &= ~IMNT_UNMOUNT;
860 mutex_exit(&mp->mnt_unmounting);
861 if ((mp->mnt_flag & (MNT_RDONLY | MNT_ASYNC)) == 0)
862 vfs_syncer_add_to_worklist(mp);
863 mp->mnt_flag |= async;
864 mutex_exit(&mp->mnt_updating);
865 if (used_syncer)
866 mutex_exit(&syncer_mutex);
867 if (used_extattr) {
868 if (start_extattr(mp) != 0)
869 mp->mnt_flag &= ~MNT_EXTATTR;
870 else
871 mp->mnt_flag |= MNT_EXTATTR;
872 }
873 return (error);
874 }
875 mutex_exit(&mp->mnt_updating);
876
877 /*
878 * release mnt_umounting lock here, because other code calls
879 * vfs_busy() while holding the mountlist_lock.
880 *
881 * mark filesystem as gone to prevent further umounts
882 * after mnt_umounting lock is gone, this also prevents
883 * vfs_busy() from succeeding.
884 */
885 mp->mnt_iflag |= IMNT_GONE;
886 mutex_exit(&mp->mnt_unmounting);
887
888 if ((coveredvp = mp->mnt_vnodecovered) != NULLVP) {
889 vn_lock(coveredvp, LK_EXCLUSIVE | LK_RETRY);
890 coveredvp->v_mountedhere = NULL;
891 VOP_UNLOCK(coveredvp);
892 }
893 mutex_enter(&mountlist_lock);
894 TAILQ_REMOVE(&mountlist, mp, mnt_list);
895 mutex_exit(&mountlist_lock);
896 if (TAILQ_FIRST(&mp->mnt_vnodelist) != NULL)
897 panic("unmount: dangling vnode");
898 if (used_syncer)
899 mutex_exit(&syncer_mutex);
900 vfs_hooks_unmount(mp);
901
902 vfs_destroy(mp); /* reference from mount() */
903 if (coveredvp != NULLVP) {
904 vrele(coveredvp);
905 }
906 return (0);
907 }
908
909 /*
910 * Unmount all file systems.
911 * We traverse the list in reverse order under the assumption that doing so
912 * will avoid needing to worry about dependencies.
913 */
914 bool
vfs_unmountall(struct lwp * l)915 vfs_unmountall(struct lwp *l)
916 {
917
918 printf("unmounting file systems...\n");
919 return vfs_unmountall1(l, true, true);
920 }
921
922 static void
vfs_unmount_print(struct mount * mp,const char * pfx)923 vfs_unmount_print(struct mount *mp, const char *pfx)
924 {
925
926 aprint_verbose("%sunmounted %s on %s type %s\n", pfx,
927 mp->mnt_stat.f_mntfromname, mp->mnt_stat.f_mntonname,
928 mp->mnt_stat.f_fstypename);
929 }
930
931 bool
vfs_unmount_forceone(struct lwp * l)932 vfs_unmount_forceone(struct lwp *l)
933 {
934 struct mount *mp, *nmp;
935 int error;
936
937 nmp = NULL;
938
939 TAILQ_FOREACH_REVERSE(mp, &mountlist, mntlist, mnt_list) {
940 if (nmp == NULL || mp->mnt_gen > nmp->mnt_gen) {
941 nmp = mp;
942 }
943 }
944 if (nmp == NULL) {
945 return false;
946 }
947
948 #ifdef DEBUG
949 printf("forcefully unmounting %s (%s)...\n",
950 nmp->mnt_stat.f_mntonname, nmp->mnt_stat.f_mntfromname);
951 #endif
952 atomic_inc_uint(&nmp->mnt_refcnt);
953 if ((error = dounmount(nmp, MNT_FORCE, l)) == 0) {
954 vfs_unmount_print(nmp, "forcefully ");
955 return true;
956 } else {
957 vfs_destroy(nmp);
958 }
959
960 #ifdef DEBUG
961 printf("forceful unmount of %s failed with error %d\n",
962 nmp->mnt_stat.f_mntonname, error);
963 #endif
964
965 return false;
966 }
967
968 bool
vfs_unmountall1(struct lwp * l,bool force,bool verbose)969 vfs_unmountall1(struct lwp *l, bool force, bool verbose)
970 {
971 struct mount *mp, *nmp;
972 bool any_error = false, progress = false;
973 int error;
974
975 TAILQ_FOREACH_REVERSE_SAFE(mp, &mountlist, mntlist, mnt_list, nmp) {
976 #ifdef DEBUG
977 printf("unmounting %p %s (%s)...\n",
978 (void *)mp, mp->mnt_stat.f_mntonname,
979 mp->mnt_stat.f_mntfromname);
980 #endif
981 atomic_inc_uint(&mp->mnt_refcnt);
982 if ((error = dounmount(mp, force ? MNT_FORCE : 0, l)) == 0) {
983 vfs_unmount_print(mp, "");
984 progress = true;
985 } else {
986 vfs_destroy(mp);
987 if (verbose) {
988 printf("unmount of %s failed with error %d\n",
989 mp->mnt_stat.f_mntonname, error);
990 }
991 any_error = true;
992 }
993 }
994 if (verbose) {
995 printf("unmounting done\n");
996 }
997 if (any_error && verbose) {
998 printf("WARNING: some file systems would not unmount\n");
999 }
1000 return progress;
1001 }
1002
1003 void
vfs_sync_all(struct lwp * l)1004 vfs_sync_all(struct lwp *l)
1005 {
1006 printf("syncing disks... ");
1007
1008 /* remove user processes from run queue */
1009 suspendsched();
1010 (void)spl0();
1011
1012 /* avoid coming back this way again if we panic. */
1013 doing_shutdown = 1;
1014
1015 do_sys_sync(l);
1016
1017 /* Wait for sync to finish. */
1018 if (buf_syncwait() != 0) {
1019 #if defined(DDB) && defined(DEBUG_HALT_BUSY)
1020 Debugger();
1021 #endif
1022 printf("giving up\n");
1023 return;
1024 } else
1025 printf("done\n");
1026 }
1027
1028 /*
1029 * Sync and unmount file systems before shutting down.
1030 */
1031 void
vfs_shutdown(void)1032 vfs_shutdown(void)
1033 {
1034 lwp_t *l = curlwp;
1035
1036 vfs_sync_all(l);
1037
1038 /*
1039 * If we have paniced - do not make the situation potentially
1040 * worse by unmounting the file systems.
1041 */
1042 if (panicstr != NULL) {
1043 return;
1044 }
1045
1046 /* Unmount file systems. */
1047 vfs_unmountall(l);
1048 }
1049
1050 /*
1051 * Print a list of supported file system types (used by vfs_mountroot)
1052 */
1053 static void
vfs_print_fstypes(void)1054 vfs_print_fstypes(void)
1055 {
1056 struct vfsops *v;
1057 int cnt = 0;
1058
1059 mutex_enter(&vfs_list_lock);
1060 LIST_FOREACH(v, &vfs_list, vfs_list)
1061 ++cnt;
1062 mutex_exit(&vfs_list_lock);
1063
1064 if (cnt == 0) {
1065 printf("WARNING: No file system modules have been loaded.\n");
1066 return;
1067 }
1068
1069 printf("Supported file systems:");
1070 mutex_enter(&vfs_list_lock);
1071 LIST_FOREACH(v, &vfs_list, vfs_list) {
1072 printf(" %s", v->vfs_name);
1073 }
1074 mutex_exit(&vfs_list_lock);
1075 printf("\n");
1076 }
1077
1078 /*
1079 * Mount the root file system. If the operator didn't specify a
1080 * file system to use, try all possible file systems until one
1081 * succeeds.
1082 */
1083 int
vfs_mountroot(void)1084 vfs_mountroot(void)
1085 {
1086 struct vfsops *v;
1087 int error = ENODEV;
1088
1089 if (root_device == NULL)
1090 panic("vfs_mountroot: root device unknown");
1091
1092 switch (device_class(root_device)) {
1093 case DV_IFNET:
1094 if (rootdev != NODEV)
1095 panic("vfs_mountroot: rootdev set for DV_IFNET "
1096 "(0x%llx -> %llu,%llu)",
1097 (unsigned long long)rootdev,
1098 (unsigned long long)major(rootdev),
1099 (unsigned long long)minor(rootdev));
1100 break;
1101
1102 case DV_DISK:
1103 if (rootdev == NODEV)
1104 panic("vfs_mountroot: rootdev not set for DV_DISK");
1105 if (bdevvp(rootdev, &rootvp))
1106 panic("vfs_mountroot: can't get vnode for rootdev");
1107 error = VOP_OPEN(rootvp, FREAD, FSCRED);
1108 if (error) {
1109 printf("vfs_mountroot: can't open root device\n");
1110 return (error);
1111 }
1112 break;
1113
1114 case DV_VIRTUAL:
1115 break;
1116
1117 default:
1118 printf("%s: inappropriate for root file system\n",
1119 device_xname(root_device));
1120 return (ENODEV);
1121 }
1122
1123 /*
1124 * If user specified a root fs type, use it. Make sure the
1125 * specified type exists and has a mount_root()
1126 */
1127 if (strcmp(rootfstype, ROOT_FSTYPE_ANY) != 0) {
1128 v = vfs_getopsbyname(rootfstype);
1129 error = EFTYPE;
1130 if (v != NULL) {
1131 if (v->vfs_mountroot != NULL) {
1132 error = (v->vfs_mountroot)();
1133 }
1134 v->vfs_refcount--;
1135 }
1136 goto done;
1137 }
1138
1139 /*
1140 * Try each file system currently configured into the kernel.
1141 */
1142 mutex_enter(&vfs_list_lock);
1143 LIST_FOREACH(v, &vfs_list, vfs_list) {
1144 if (v->vfs_mountroot == NULL)
1145 continue;
1146 #ifdef DEBUG
1147 aprint_normal("mountroot: trying %s...\n", v->vfs_name);
1148 #endif
1149 v->vfs_refcount++;
1150 mutex_exit(&vfs_list_lock);
1151 error = (*v->vfs_mountroot)();
1152 mutex_enter(&vfs_list_lock);
1153 v->vfs_refcount--;
1154 if (!error) {
1155 aprint_normal("root file system type: %s\n",
1156 v->vfs_name);
1157 break;
1158 }
1159 }
1160 mutex_exit(&vfs_list_lock);
1161
1162 if (v == NULL) {
1163 vfs_print_fstypes();
1164 printf("no file system for %s", device_xname(root_device));
1165 if (device_class(root_device) == DV_DISK)
1166 printf(" (dev 0x%llx)", (unsigned long long)rootdev);
1167 printf("\n");
1168 error = EFTYPE;
1169 }
1170
1171 done:
1172 if (error && device_class(root_device) == DV_DISK) {
1173 VOP_CLOSE(rootvp, FREAD, FSCRED);
1174 vrele(rootvp);
1175 }
1176 if (error == 0) {
1177 struct mount *mp;
1178 extern struct cwdinfo cwdi0;
1179
1180 mp = TAILQ_FIRST(&mountlist);
1181 mp->mnt_flag |= MNT_ROOTFS;
1182 mp->mnt_op->vfs_refcount++;
1183
1184 /*
1185 * Get the vnode for '/'. Set cwdi0.cwdi_cdir to
1186 * reference it.
1187 */
1188 error = VFS_ROOT(mp, &rootvnode);
1189 if (error)
1190 panic("cannot find root vnode, error=%d", error);
1191 cwdi0.cwdi_cdir = rootvnode;
1192 vref(cwdi0.cwdi_cdir);
1193 VOP_UNLOCK(rootvnode);
1194 cwdi0.cwdi_rdir = NULL;
1195
1196 /*
1197 * Now that root is mounted, we can fixup initproc's CWD
1198 * info. All other processes are kthreads, which merely
1199 * share proc0's CWD info.
1200 */
1201 initproc->p_cwdi->cwdi_cdir = rootvnode;
1202 vref(initproc->p_cwdi->cwdi_cdir);
1203 initproc->p_cwdi->cwdi_rdir = NULL;
1204 /*
1205 * Enable loading of modules from the filesystem
1206 */
1207 module_load_vfs_init();
1208
1209 }
1210 return (error);
1211 }
1212
1213 /*
1214 * mount_specific_key_create --
1215 * Create a key for subsystem mount-specific data.
1216 */
1217 int
mount_specific_key_create(specificdata_key_t * keyp,specificdata_dtor_t dtor)1218 mount_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor)
1219 {
1220
1221 return specificdata_key_create(mount_specificdata_domain, keyp, dtor);
1222 }
1223
1224 /*
1225 * mount_specific_key_delete --
1226 * Delete a key for subsystem mount-specific data.
1227 */
1228 void
mount_specific_key_delete(specificdata_key_t key)1229 mount_specific_key_delete(specificdata_key_t key)
1230 {
1231
1232 specificdata_key_delete(mount_specificdata_domain, key);
1233 }
1234
1235 /*
1236 * mount_initspecific --
1237 * Initialize a mount's specificdata container.
1238 */
1239 void
mount_initspecific(struct mount * mp)1240 mount_initspecific(struct mount *mp)
1241 {
1242 int error __diagused;
1243
1244 error = specificdata_init(mount_specificdata_domain,
1245 &mp->mnt_specdataref);
1246 KASSERT(error == 0);
1247 }
1248
1249 /*
1250 * mount_finispecific --
1251 * Finalize a mount's specificdata container.
1252 */
1253 void
mount_finispecific(struct mount * mp)1254 mount_finispecific(struct mount *mp)
1255 {
1256
1257 specificdata_fini(mount_specificdata_domain, &mp->mnt_specdataref);
1258 }
1259
1260 /*
1261 * mount_getspecific --
1262 * Return mount-specific data corresponding to the specified key.
1263 */
1264 void *
mount_getspecific(struct mount * mp,specificdata_key_t key)1265 mount_getspecific(struct mount *mp, specificdata_key_t key)
1266 {
1267
1268 return specificdata_getspecific(mount_specificdata_domain,
1269 &mp->mnt_specdataref, key);
1270 }
1271
1272 /*
1273 * mount_setspecific --
1274 * Set mount-specific data corresponding to the specified key.
1275 */
1276 void
mount_setspecific(struct mount * mp,specificdata_key_t key,void * data)1277 mount_setspecific(struct mount *mp, specificdata_key_t key, void *data)
1278 {
1279
1280 specificdata_setspecific(mount_specificdata_domain,
1281 &mp->mnt_specdataref, key, data);
1282 }
1283
1284 /*
1285 * Check to see if a filesystem is mounted on a block device.
1286 */
1287 int
vfs_mountedon(vnode_t * vp)1288 vfs_mountedon(vnode_t *vp)
1289 {
1290 vnode_t *vq;
1291 int error = 0;
1292
1293 if (vp->v_type != VBLK)
1294 return ENOTBLK;
1295 if (spec_node_getmountedfs(vp) != NULL)
1296 return EBUSY;
1297 if (spec_node_lookup_by_dev(vp->v_type, vp->v_rdev, &vq) == 0) {
1298 if (spec_node_getmountedfs(vq) != NULL)
1299 error = EBUSY;
1300 vrele(vq);
1301 }
1302
1303 return error;
1304 }
1305
1306 /*
1307 * Check if a device pointed to by vp is mounted.
1308 *
1309 * Returns:
1310 * EINVAL if it's not a disk
1311 * EBUSY if it's a disk and mounted
1312 * 0 if it's a disk and not mounted
1313 */
1314 int
rawdev_mounted(vnode_t * vp,vnode_t ** bvpp)1315 rawdev_mounted(vnode_t *vp, vnode_t **bvpp)
1316 {
1317 vnode_t *bvp;
1318 dev_t dev;
1319 int d_type;
1320
1321 bvp = NULL;
1322 d_type = D_OTHER;
1323
1324 if (iskmemvp(vp))
1325 return EINVAL;
1326
1327 switch (vp->v_type) {
1328 case VCHR: {
1329 const struct cdevsw *cdev;
1330
1331 dev = vp->v_rdev;
1332 cdev = cdevsw_lookup(dev);
1333 if (cdev != NULL) {
1334 dev_t blkdev;
1335
1336 blkdev = devsw_chr2blk(dev);
1337 if (blkdev != NODEV) {
1338 if (vfinddev(blkdev, VBLK, &bvp) != 0) {
1339 d_type = (cdev->d_flag & D_TYPEMASK);
1340 /* XXX: what if bvp disappears? */
1341 vrele(bvp);
1342 }
1343 }
1344 }
1345
1346 break;
1347 }
1348
1349 case VBLK: {
1350 const struct bdevsw *bdev;
1351
1352 dev = vp->v_rdev;
1353 bdev = bdevsw_lookup(dev);
1354 if (bdev != NULL)
1355 d_type = (bdev->d_flag & D_TYPEMASK);
1356
1357 bvp = vp;
1358
1359 break;
1360 }
1361
1362 default:
1363 break;
1364 }
1365
1366 if (d_type != D_DISK)
1367 return EINVAL;
1368
1369 if (bvpp != NULL)
1370 *bvpp = bvp;
1371
1372 /*
1373 * XXX: This is bogus. We should be failing the request
1374 * XXX: not only if this specific slice is mounted, but
1375 * XXX: if it's on a disk with any other mounted slice.
1376 */
1377 if (vfs_mountedon(bvp))
1378 return EBUSY;
1379
1380 return 0;
1381 }
1382
1383 /*
1384 * Make a 'unique' number from a mount type name.
1385 */
1386 long
makefstype(const char * type)1387 makefstype(const char *type)
1388 {
1389 long rv;
1390
1391 for (rv = 0; *type; type++) {
1392 rv <<= 2;
1393 rv ^= *type;
1394 }
1395 return rv;
1396 }
1397
1398 void
mountlist_append(struct mount * mp)1399 mountlist_append(struct mount *mp)
1400 {
1401 mutex_enter(&mountlist_lock);
1402 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
1403 mutex_exit(&mountlist_lock);
1404 }
1405