2 * Copyright (c) 2004,2013 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
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.
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
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.
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
68 * External virtual filesystem routines
71 #include <sys/param.h>
72 #include <sys/systm.h>
73 #include <sys/kernel.h>
74 #include <sys/malloc.h>
75 #include <sys/mount.h>
77 #include <sys/vnode.h>
79 #include <sys/eventhandler.h>
80 #include <sys/kthread.h>
81 #include <sys/sysctl.h>
83 #include <machine/limits.h>
86 #include <sys/thread2.h>
87 #include <sys/sysref2.h>
90 #include <vm/vm_object.h>
92 struct mountscan_info
{
93 TAILQ_ENTRY(mountscan_info
) msi_entry
;
95 struct mount
*msi_node
;
98 struct vmntvnodescan_info
{
99 TAILQ_ENTRY(vmntvnodescan_info
) entry
;
107 static int vnlru_nowhere
= 0;
108 SYSCTL_INT(_debug
, OID_AUTO
, vnlru_nowhere
, CTLFLAG_RD
,
110 "Number of times the vnlru process ran without success");
113 static struct lwkt_token mntid_token
;
114 static struct mount dummymount
;
116 /* note: mountlist exported to pstat */
117 struct mntlist mountlist
= TAILQ_HEAD_INITIALIZER(mountlist
);
118 static TAILQ_HEAD(,mountscan_info
) mountscan_list
;
119 static struct lwkt_token mountlist_token
;
121 static TAILQ_HEAD(,bio_ops
) bio_ops_list
= TAILQ_HEAD_INITIALIZER(bio_ops_list
);
124 * Called from vfsinit()
129 lwkt_token_init(&mountlist_token
, "mntlist");
130 lwkt_token_init(&mntid_token
, "mntid");
131 TAILQ_INIT(&mountscan_list
);
132 mount_init(&dummymount
);
133 dummymount
.mnt_flag
|= MNT_RDONLY
;
134 dummymount
.mnt_kern_flag
|= MNTK_ALL_MPSAFE
;
138 * Support function called to remove a vnode from the mountlist and
139 * deal with side effects for scans in progress.
141 * Target mnt_token is held on call.
144 vremovevnodemnt(struct vnode
*vp
)
146 struct vmntvnodescan_info
*info
;
147 struct mount
*mp
= vp
->v_mount
;
149 TAILQ_FOREACH(info
, &mp
->mnt_vnodescan_list
, entry
) {
151 info
->vp
= TAILQ_NEXT(vp
, v_nmntvnodes
);
153 TAILQ_REMOVE(&vp
->v_mount
->mnt_nvnodelist
, vp
, v_nmntvnodes
);
157 * Allocate a new vnode and associate it with a tag, mount point, and
160 * A VX locked and refd vnode is returned. The caller should setup the
161 * remaining fields and vx_put() or, if he wishes to leave a vref,
162 * vx_unlock() the vnode.
165 getnewvnode(enum vtagtype tag
, struct mount
*mp
,
166 struct vnode
**vpp
, int lktimeout
, int lkflags
)
170 KKASSERT(mp
!= NULL
);
172 vp
= allocvnode(lktimeout
, lkflags
);
177 * By default the vnode is assigned the mount point's normal
180 vp
->v_ops
= &mp
->mnt_vn_use_ops
;
181 vp
->v_pbuf_count
= nswbuf_kva
/ NSWBUF_SPLIT
;
184 * Placing the vnode on the mount point's queue makes it visible.
185 * VNON prevents it from being messed with, however.
190 * A VX locked & refd vnode is returned.
197 * This function creates vnodes with special operations vectors. The
198 * mount point is optional.
200 * This routine is being phased out but is still used by vfs_conf to
201 * create vnodes for devices prior to the root mount (with mp == NULL).
204 getspecialvnode(enum vtagtype tag
, struct mount
*mp
,
205 struct vop_ops
**ops
,
206 struct vnode
**vpp
, int lktimeout
, int lkflags
)
210 vp
= allocvnode(lktimeout
, lkflags
);
219 * Placing the vnode on the mount point's queue makes it visible.
220 * VNON prevents it from being messed with, however.
225 * A VX locked & refd vnode is returned.
232 * Interlock against an unmount, return 0 on success, non-zero on failure.
234 * The passed flag may be 0 or LK_NOWAIT and is only used if an unmount
237 * If no unmount is in-progress LK_NOWAIT is ignored. No other flag bits
238 * are used. A shared locked will be obtained and the filesystem will not
239 * be unmountable until the lock is released.
242 vfs_busy(struct mount
*mp
, int flags
)
246 atomic_add_int(&mp
->mnt_refs
, 1);
247 lwkt_gettoken(&mp
->mnt_token
);
248 if (mp
->mnt_kern_flag
& MNTK_UNMOUNT
) {
249 if (flags
& LK_NOWAIT
) {
250 lwkt_reltoken(&mp
->mnt_token
);
251 atomic_add_int(&mp
->mnt_refs
, -1);
254 /* XXX not MP safe */
255 mp
->mnt_kern_flag
|= MNTK_MWAIT
;
257 * Since all busy locks are shared except the exclusive
258 * lock granted when unmounting, the only place that a
259 * wakeup needs to be done is at the release of the
260 * exclusive lock at the end of dounmount.
262 tsleep((caddr_t
)mp
, 0, "vfs_busy", 0);
263 lwkt_reltoken(&mp
->mnt_token
);
264 atomic_add_int(&mp
->mnt_refs
, -1);
268 if (lockmgr(&mp
->mnt_lock
, lkflags
))
269 panic("vfs_busy: unexpected lock failure");
270 lwkt_reltoken(&mp
->mnt_token
);
275 * Free a busy filesystem.
277 * Decrement refs before releasing the lock so e.g. a pending umount
278 * doesn't give us an unexpected busy error.
281 vfs_unbusy(struct mount
*mp
)
283 atomic_add_int(&mp
->mnt_refs
, -1);
284 lockmgr(&mp
->mnt_lock
, LK_RELEASE
);
288 * Lookup a filesystem type, and if found allocate and initialize
289 * a mount structure for it.
291 * Devname is usually updated by mount(8) after booting.
294 vfs_rootmountalloc(char *fstypename
, char *devname
, struct mount
**mpp
)
296 struct vfsconf
*vfsp
;
299 if (fstypename
== NULL
)
302 vfsp
= vfsconf_find_by_name(fstypename
);
305 mp
= kmalloc(sizeof(struct mount
), M_MOUNT
, M_WAITOK
| M_ZERO
);
307 lockinit(&mp
->mnt_lock
, "vfslock", VLKTIMEOUT
, 0);
311 mp
->mnt_op
= vfsp
->vfc_vfsops
;
312 mp
->mnt_pbuf_count
= nswbuf_kva
/ NSWBUF_SPLIT
;
313 vfsp
->vfc_refcount
++;
314 mp
->mnt_stat
.f_type
= vfsp
->vfc_typenum
;
315 mp
->mnt_flag
|= MNT_RDONLY
;
316 mp
->mnt_flag
|= vfsp
->vfc_flags
& MNT_VISFLAGMASK
;
317 strncpy(mp
->mnt_stat
.f_fstypename
, vfsp
->vfc_name
, MFSNAMELEN
);
318 copystr(devname
, mp
->mnt_stat
.f_mntfromname
, MNAMELEN
- 1, 0);
324 * Basic mount structure initialization
327 mount_init(struct mount
*mp
)
329 lockinit(&mp
->mnt_lock
, "vfslock", hz
*5, 0);
330 lwkt_token_init(&mp
->mnt_token
, "permnt");
332 TAILQ_INIT(&mp
->mnt_vnodescan_list
);
333 TAILQ_INIT(&mp
->mnt_nvnodelist
);
334 TAILQ_INIT(&mp
->mnt_reservedvnlist
);
335 TAILQ_INIT(&mp
->mnt_jlist
);
336 mp
->mnt_nvnodelistsize
= 0;
339 mp
->mnt_iosize_max
= MAXPHYS
;
340 vn_syncer_thr_create(mp
);
344 mount_hold(struct mount
*mp
)
346 atomic_add_int(&mp
->mnt_hold
, 1);
350 mount_drop(struct mount
*mp
)
352 if (atomic_fetchadd_int(&mp
->mnt_hold
, -1) == 1)
357 * Lookup a mount point by filesystem identifier.
360 vfs_getvfs(fsid_t
*fsid
)
364 lwkt_gettoken(&mountlist_token
);
365 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
366 if (mp
->mnt_stat
.f_fsid
.val
[0] == fsid
->val
[0] &&
367 mp
->mnt_stat
.f_fsid
.val
[1] == fsid
->val
[1]) {
371 lwkt_reltoken(&mountlist_token
);
376 * Get a new unique fsid. Try to make its val[0] unique, since this value
377 * will be used to create fake device numbers for stat(). Also try (but
378 * not so hard) make its val[0] unique mod 2^16, since some emulators only
379 * support 16-bit device numbers. We end up with unique val[0]'s for the
380 * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
382 * Keep in mind that several mounts may be running in parallel. Starting
383 * the search one past where the previous search terminated is both a
384 * micro-optimization and a defense against returning the same fsid to
388 vfs_getnewfsid(struct mount
*mp
)
390 static u_int16_t mntid_base
;
394 lwkt_gettoken(&mntid_token
);
395 mtype
= mp
->mnt_vfc
->vfc_typenum
;
396 tfsid
.val
[1] = mtype
;
397 mtype
= (mtype
& 0xFF) << 24;
399 tfsid
.val
[0] = makeudev(255,
400 mtype
| ((mntid_base
& 0xFF00) << 8) | (mntid_base
& 0xFF));
402 if (vfs_getvfs(&tfsid
) == NULL
)
405 mp
->mnt_stat
.f_fsid
.val
[0] = tfsid
.val
[0];
406 mp
->mnt_stat
.f_fsid
.val
[1] = tfsid
.val
[1];
407 lwkt_reltoken(&mntid_token
);
411 * Set the FSID for a new mount point to the template. Adjust
412 * the FSID to avoid collisions.
415 vfs_setfsid(struct mount
*mp
, fsid_t
*template)
419 bzero(&mp
->mnt_stat
.f_fsid
, sizeof(mp
->mnt_stat
.f_fsid
));
421 if (vfs_getvfs(template) == NULL
)
426 mp
->mnt_stat
.f_fsid
= *template;
431 * This routine is called when we have too many vnodes. It attempts
432 * to free <count> vnodes and will potentially free vnodes that still
433 * have VM backing store (VM backing store is typically the cause
434 * of a vnode blowout so we want to do this). Therefore, this operation
435 * is not considered cheap.
437 * A number of conditions may prevent a vnode from being reclaimed.
438 * the buffer cache may have references on the vnode, a directory
439 * vnode may still have references due to the namei cache representing
440 * underlying files, or the vnode may be in active use. It is not
441 * desireable to reuse such vnodes. These conditions may cause the
442 * number of vnodes to reach some minimum value regardless of what
443 * you set kern.maxvnodes to. Do not set kern.maxvnodes too low.
447 * Attempt to recycle vnodes in a context that is always safe to block.
448 * Calling vlrurecycle() from the bowels of file system code has some
449 * interesting deadlock problems.
451 static struct thread
*vnlruthread
;
456 struct thread
*td
= curthread
;
458 EVENTHANDLER_REGISTER(shutdown_pre_sync
, shutdown_kproc
, td
,
464 kproc_suspend_loop();
467 * Try to free some vnodes if we have too many. Trigger based
468 * on potentially freeable vnodes but calculate the count
469 * based on total vnodes.
471 * (long) -> deal with 64 bit machines, intermediate overflow
473 ncached
= countcachedvnodes(1);
474 if (numvnodes
>= maxvnodes
* 9 / 10 &&
475 ncached
+ inactivevnodes
>= maxvnodes
* 5 / 10) {
476 int count
= numvnodes
- maxvnodes
* 9 / 10;
478 if (count
> (ncached
+ inactivevnodes
) / 100)
479 count
= (ncached
+ inactivevnodes
) / 100;
482 freesomevnodes(count
);
486 * Do non-critical-path (more robust) cache cleaning,
487 * even if vnode counts are nominal, to try to avoid
488 * having to do it in the critical path.
493 * Nothing to do if most of our vnodes are already on
496 ncached
= countcachedvnodes(1);
497 if (numvnodes
<= maxvnodes
* 9 / 10 ||
498 ncached
+ inactivevnodes
<= maxvnodes
* 5 / 10) {
499 tsleep(vnlruthread
, 0, "vlruwt", hz
);
506 * MOUNTLIST FUNCTIONS
510 * mountlist_insert (MP SAFE)
512 * Add a new mount point to the mount list.
515 mountlist_insert(struct mount
*mp
, int how
)
517 lwkt_gettoken(&mountlist_token
);
518 if (how
== MNTINS_FIRST
)
519 TAILQ_INSERT_HEAD(&mountlist
, mp
, mnt_list
);
521 TAILQ_INSERT_TAIL(&mountlist
, mp
, mnt_list
);
522 lwkt_reltoken(&mountlist_token
);
526 * mountlist_interlock (MP SAFE)
528 * Execute the specified interlock function with the mountlist token
529 * held. The function will be called in a serialized fashion verses
530 * other functions called through this mechanism.
533 mountlist_interlock(int (*callback
)(struct mount
*), struct mount
*mp
)
537 lwkt_gettoken(&mountlist_token
);
538 error
= callback(mp
);
539 lwkt_reltoken(&mountlist_token
);
544 * mountlist_boot_getfirst (DURING BOOT ONLY)
546 * This function returns the first mount on the mountlist, which is
547 * expected to be the root mount. Since no interlocks are obtained
548 * this function is only safe to use during booting.
552 mountlist_boot_getfirst(void)
554 return(TAILQ_FIRST(&mountlist
));
558 * mountlist_remove (MP SAFE)
560 * Remove a node from the mountlist. If this node is the next scan node
561 * for any active mountlist scans, the active mountlist scan will be
562 * adjusted to skip the node, thus allowing removals during mountlist
566 mountlist_remove(struct mount
*mp
)
568 struct mountscan_info
*msi
;
570 lwkt_gettoken(&mountlist_token
);
571 TAILQ_FOREACH(msi
, &mountscan_list
, msi_entry
) {
572 if (msi
->msi_node
== mp
) {
573 if (msi
->msi_how
& MNTSCAN_FORWARD
)
574 msi
->msi_node
= TAILQ_NEXT(mp
, mnt_list
);
576 msi
->msi_node
= TAILQ_PREV(mp
, mntlist
, mnt_list
);
579 TAILQ_REMOVE(&mountlist
, mp
, mnt_list
);
580 lwkt_reltoken(&mountlist_token
);
584 * mountlist_exists (MP SAFE)
586 * Checks if a node exists in the mountlist.
587 * This function is mainly used by VFS quota code to check if a
588 * cached nullfs struct mount pointer is still valid at use time
590 * FIXME: there is no warranty the mp passed to that function
591 * will be the same one used by VFS_ACCOUNT() later
594 mountlist_exists(struct mount
*mp
)
599 lwkt_gettoken(&mountlist_token
);
600 TAILQ_FOREACH(lmp
, &mountlist
, mnt_list
) {
606 lwkt_reltoken(&mountlist_token
);
611 * mountlist_scan (MP SAFE)
613 * Safely scan the mount points on the mount list. Unless otherwise
614 * specified each mount point will be busied prior to the callback and
615 * unbusied afterwords. The callback may safely remove any mount point
616 * without interfering with the scan. If the current callback
617 * mount is removed the scanner will not attempt to unbusy it.
619 * If a mount node cannot be busied it is silently skipped.
621 * The callback return value is aggregated and a total is returned. A return
622 * value of < 0 is not aggregated and will terminate the scan.
624 * MNTSCAN_FORWARD - the mountlist is scanned in the forward direction
625 * MNTSCAN_REVERSE - the mountlist is scanned in reverse
626 * MNTSCAN_NOBUSY - the scanner will make the callback without busying
629 * NOTE: mount_hold()/mount_drop() sequence primarily helps us avoid
630 * confusion for the unbusy check, particularly if a kfree/kmalloc
631 * occurs quickly (lots of processes mounting and unmounting at the
635 mountlist_scan(int (*callback
)(struct mount
*, void *), void *data
, int how
)
637 struct mountscan_info info
;
642 lwkt_gettoken(&mountlist_token
);
645 info
.msi_node
= NULL
; /* paranoia */
646 TAILQ_INSERT_TAIL(&mountscan_list
, &info
, msi_entry
);
650 if (how
& MNTSCAN_FORWARD
) {
651 info
.msi_node
= TAILQ_FIRST(&mountlist
);
652 while ((mp
= info
.msi_node
) != NULL
) {
654 if (how
& MNTSCAN_NOBUSY
) {
655 count
= callback(mp
, data
);
656 } else if (vfs_busy(mp
, LK_NOWAIT
) == 0) {
657 count
= callback(mp
, data
);
658 if (mp
== info
.msi_node
)
667 if (mp
== info
.msi_node
)
668 info
.msi_node
= TAILQ_NEXT(mp
, mnt_list
);
670 } else if (how
& MNTSCAN_REVERSE
) {
671 info
.msi_node
= TAILQ_LAST(&mountlist
, mntlist
);
672 while ((mp
= info
.msi_node
) != NULL
) {
674 if (how
& MNTSCAN_NOBUSY
) {
675 count
= callback(mp
, data
);
676 } else if (vfs_busy(mp
, LK_NOWAIT
) == 0) {
677 count
= callback(mp
, data
);
678 if (mp
== info
.msi_node
)
687 if (mp
== info
.msi_node
)
688 info
.msi_node
= TAILQ_PREV(mp
, mntlist
, mnt_list
);
691 TAILQ_REMOVE(&mountscan_list
, &info
, msi_entry
);
692 lwkt_reltoken(&mountlist_token
);
697 * MOUNT RELATED VNODE FUNCTIONS
700 static struct kproc_desc vnlru_kp
= {
705 SYSINIT(vnlru
, SI_SUB_KTHREAD_UPDATE
, SI_ORDER_FIRST
, kproc_start
, &vnlru_kp
);
708 * Move a vnode from one mount queue to another.
711 insmntque(struct vnode
*vp
, struct mount
*mp
)
716 * Delete from old mount point vnode list, if on one.
718 if ((omp
= vp
->v_mount
) != NULL
) {
719 lwkt_gettoken(&omp
->mnt_token
);
720 KKASSERT(omp
== vp
->v_mount
);
721 KASSERT(omp
->mnt_nvnodelistsize
> 0,
722 ("bad mount point vnode list size"));
724 omp
->mnt_nvnodelistsize
--;
725 lwkt_reltoken(&omp
->mnt_token
);
729 * Insert into list of vnodes for the new mount point, if available.
730 * The 'end' of the LRU list is the vnode prior to mp->mnt_syncer.
736 lwkt_gettoken(&mp
->mnt_token
);
738 if (mp
->mnt_syncer
) {
739 TAILQ_INSERT_BEFORE(mp
->mnt_syncer
, vp
, v_nmntvnodes
);
741 TAILQ_INSERT_TAIL(&mp
->mnt_nvnodelist
, vp
, v_nmntvnodes
);
743 mp
->mnt_nvnodelistsize
++;
744 lwkt_reltoken(&mp
->mnt_token
);
749 * Scan the vnodes under a mount point and issue appropriate callbacks.
751 * The fastfunc() callback is called with just the mountlist token held
752 * (no vnode lock). It may not block and the vnode may be undergoing
753 * modifications while the caller is processing it. The vnode will
754 * not be entirely destroyed, however, due to the fact that the mountlist
755 * token is held. A return value < 0 skips to the next vnode without calling
756 * the slowfunc(), a return value > 0 terminates the loop.
758 * WARNING! The fastfunc() should not indirect through vp->v_object, the vp
759 * data structure is unstable when called from fastfunc().
761 * The slowfunc() callback is called after the vnode has been successfully
762 * locked based on passed flags. The vnode is skipped if it gets rearranged
763 * or destroyed while blocking on the lock. A non-zero return value from
764 * the slow function terminates the loop. The slow function is allowed to
765 * arbitrarily block. The scanning code guarentees consistency of operation
766 * even if the slow function deletes or moves the node, or blocks and some
767 * other thread deletes or moves the node.
773 int (*fastfunc
)(struct mount
*mp
, struct vnode
*vp
, void *data
),
774 int (*slowfunc
)(struct mount
*mp
, struct vnode
*vp
, void *data
),
777 struct vmntvnodescan_info info
;
780 int maxcount
= mp
->mnt_nvnodelistsize
* 2;
784 lwkt_gettoken(&mp
->mnt_token
);
787 * If asked to do one pass stop after iterating available vnodes.
788 * Under heavy loads new vnodes can be added while we are scanning,
789 * so this isn't perfect. Create a slop factor of 2x.
791 if (flags
& VMSC_ONEPASS
)
792 stopcount
= mp
->mnt_nvnodelistsize
;
794 info
.vp
= TAILQ_FIRST(&mp
->mnt_nvnodelist
);
795 TAILQ_INSERT_TAIL(&mp
->mnt_vnodescan_list
, &info
, entry
);
797 while ((vp
= info
.vp
) != NULL
) {
798 if (--maxcount
== 0) {
799 kprintf("Warning: excessive fssync iteration\n");
800 maxcount
= mp
->mnt_nvnodelistsize
* 2;
804 * Skip if visible but not ready, or special (e.g.
807 if (vp
->v_type
== VNON
)
809 KKASSERT(vp
->v_mount
== mp
);
812 * Quick test. A negative return continues the loop without
813 * calling the slow test. 0 continues onto the slow test.
814 * A positive number aborts the loop.
817 if ((r
= fastfunc(mp
, vp
, data
)) < 0) {
826 * Get a vxlock on the vnode, retry if it has moved or isn't
827 * in the mountlist where we expect it.
832 switch(flags
& (VMSC_GETVP
|VMSC_GETVX
|VMSC_NOWAIT
)) {
834 error
= vget(vp
, LK_EXCLUSIVE
);
836 case VMSC_GETVP
|VMSC_NOWAIT
:
837 error
= vget(vp
, LK_EXCLUSIVE
|LK_NOWAIT
);
850 * Do not call the slow function if the vnode is
851 * invalid or if it was ripped out from under us
852 * while we (potentially) blocked.
854 if (info
.vp
== vp
&& vp
->v_type
!= VNON
)
855 r
= slowfunc(mp
, vp
, data
);
860 switch(flags
& (VMSC_GETVP
|VMSC_GETVX
|VMSC_NOWAIT
)) {
862 case VMSC_GETVP
|VMSC_NOWAIT
:
877 * Yield after some processing. Depending on the number
878 * of vnodes, we might wind up running for a long time.
879 * Because threads are not preemptable, time critical
880 * userland processes might starve. Give them a chance
883 if (++count
== 10000) {
885 * We really want to yield a bit, so we simply
888 tsleep(mp
, 0, "vnodescn", 1);
893 * If doing one pass this decrements to zero. If it starts
894 * at zero it is effectively unlimited for the purposes of
897 if (--stopcount
== 0)
901 * Iterate. If the vnode was ripped out from under us
902 * info.vp will already point to the next vnode, otherwise
903 * we have to obtain the next valid vnode ourselves.
906 info
.vp
= TAILQ_NEXT(vp
, v_nmntvnodes
);
909 TAILQ_REMOVE(&mp
->mnt_vnodescan_list
, &info
, entry
);
910 lwkt_reltoken(&mp
->mnt_token
);
915 * Remove any vnodes in the vnode table belonging to mount point mp.
917 * If FORCECLOSE is not specified, there should not be any active ones,
918 * return error if any are found (nb: this is a user error, not a
919 * system error). If FORCECLOSE is specified, detach any active vnodes
922 * If WRITECLOSE is set, only flush out regular file vnodes open for
925 * SKIPSYSTEM causes any vnodes marked VSYSTEM to be skipped.
927 * `rootrefs' specifies the base reference count for the root vnode
928 * of this filesystem. The root vnode is considered busy if its
929 * v_refcnt exceeds this value. On a successful return, vflush()
930 * will call vrele() on the root vnode exactly rootrefs times.
931 * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
935 static int busyprt
= 0; /* print out busy vnodes */
936 SYSCTL_INT(_debug
, OID_AUTO
, busyprt
, CTLFLAG_RW
, &busyprt
, 0, "");
939 static int vflush_scan(struct mount
*mp
, struct vnode
*vp
, void *data
);
948 vflush(struct mount
*mp
, int rootrefs
, int flags
)
950 struct thread
*td
= curthread
; /* XXX */
951 struct vnode
*rootvp
= NULL
;
953 struct vflush_info vflush_info
;
956 KASSERT((flags
& (SKIPSYSTEM
| WRITECLOSE
)) == 0,
957 ("vflush: bad args"));
959 * Get the filesystem root vnode. We can vput() it
960 * immediately, since with rootrefs > 0, it won't go away.
962 if ((error
= VFS_ROOT(mp
, &rootvp
)) != 0) {
963 if ((flags
& FORCECLOSE
) == 0)
966 /* continue anyway */
972 vflush_info
.busy
= 0;
973 vflush_info
.flags
= flags
;
975 vmntvnodescan(mp
, VMSC_GETVX
, NULL
, vflush_scan
, &vflush_info
);
977 if (rootrefs
> 0 && (flags
& FORCECLOSE
) == 0) {
979 * If just the root vnode is busy, and if its refcount
980 * is equal to `rootrefs', then go ahead and kill it.
982 KASSERT(vflush_info
.busy
> 0, ("vflush: not busy"));
983 KASSERT(VREFCNT(rootvp
) >= rootrefs
, ("vflush: rootrefs"));
984 if (vflush_info
.busy
== 1 && VREFCNT(rootvp
) == rootrefs
) {
986 vgone_vxlocked(rootvp
);
988 vflush_info
.busy
= 0;
991 if (vflush_info
.busy
)
993 for (; rootrefs
> 0; rootrefs
--)
999 * The scan callback is made with an VX locked vnode.
1002 vflush_scan(struct mount
*mp
, struct vnode
*vp
, void *data
)
1004 struct vflush_info
*info
= data
;
1006 int flags
= info
->flags
;
1009 * Generally speaking try to deactivate on 0 refs (catch-all)
1011 atomic_set_int(&vp
->v_refcnt
, VREF_FINALIZE
);
1014 * Skip over a vnodes marked VSYSTEM.
1016 if ((flags
& SKIPSYSTEM
) && (vp
->v_flag
& VSYSTEM
)) {
1021 * Do not force-close VCHR or VBLK vnodes
1023 if (vp
->v_type
== VCHR
|| vp
->v_type
== VBLK
)
1024 flags
&= ~(WRITECLOSE
|FORCECLOSE
);
1027 * If WRITECLOSE is set, flush out unlinked but still open
1028 * files (even if open only for reading) and regular file
1029 * vnodes open for writing.
1031 if ((flags
& WRITECLOSE
) &&
1032 (vp
->v_type
== VNON
||
1033 (VOP_GETATTR(vp
, &vattr
) == 0 &&
1034 vattr
.va_nlink
> 0)) &&
1035 (vp
->v_writecount
== 0 || vp
->v_type
!= VREG
)) {
1040 * If we are the only holder (refcnt of 1) or the vnode is in
1041 * termination (refcnt < 0), we can vgone the vnode.
1043 if (VREFCNT(vp
) <= 1) {
1049 * If FORCECLOSE is set, forcibly destroy the vnode and then move
1050 * it to a dummymount structure so vop_*() functions don't deref
1053 if (flags
& FORCECLOSE
) {
1056 if (vp
->v_mount
== NULL
)
1057 insmntque(vp
, &dummymount
);
1061 if (vp
->v_type
== VCHR
|| vp
->v_type
== VBLK
)
1062 kprintf("vflush: Warning, cannot destroy busy device vnode\n");
1065 vprint("vflush: busy vnode", vp
);
1072 add_bio_ops(struct bio_ops
*ops
)
1074 TAILQ_INSERT_TAIL(&bio_ops_list
, ops
, entry
);
1078 rem_bio_ops(struct bio_ops
*ops
)
1080 TAILQ_REMOVE(&bio_ops_list
, ops
, entry
);
1084 * This calls the bio_ops io_sync function either for a mount point
1087 * WARNING: softdeps is weirdly coded and just isn't happy unless
1088 * io_sync is called with a NULL mount from the general syncing code.
1091 bio_ops_sync(struct mount
*mp
)
1093 struct bio_ops
*ops
;
1096 if ((ops
= mp
->mnt_bioops
) != NULL
)
1099 TAILQ_FOREACH(ops
, &bio_ops_list
, entry
) {
1106 * Lookup a mount point by nch
1109 mount_get_by_nc(struct namecache
*ncp
)
1111 struct mount
*mp
= NULL
;
1113 lwkt_gettoken(&mountlist_token
);
1114 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
1115 if (ncp
== mp
->mnt_ncmountpt
.ncp
)
1118 lwkt_reltoken(&mountlist_token
);