2 * Copyright (c) 2004 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. All advertising materials mentioning features or use of this software
51 * must display the following acknowledgement:
52 * This product includes software developed by the University of
53 * California, Berkeley and its contributors.
54 * 4. Neither the name of the University nor the names of its contributors
55 * may be used to endorse or promote products derived from this software
56 * without specific prior written permission.
58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70 * $DragonFly: src/sys/kern/vfs_mount.c,v 1.28 2007/06/14 02:55:23 dillon Exp $
74 * External virtual filesystem routines
78 #include <sys/param.h>
79 #include <sys/systm.h>
80 #include <sys/kernel.h>
81 #include <sys/malloc.h>
82 #include <sys/mount.h>
84 #include <sys/vnode.h>
86 #include <sys/eventhandler.h>
87 #include <sys/kthread.h>
88 #include <sys/sysctl.h>
90 #include <machine/limits.h>
93 #include <sys/thread2.h>
94 #include <sys/sysref2.h>
97 #include <vm/vm_object.h>
99 struct mountscan_info
{
100 TAILQ_ENTRY(mountscan_info
) msi_entry
;
102 struct mount
*msi_node
;
105 struct vmntvnodescan_info
{
106 TAILQ_ENTRY(vmntvnodescan_info
) entry
;
110 static int vnlru_nowhere
= 0;
111 SYSCTL_INT(_debug
, OID_AUTO
, vnlru_nowhere
, CTLFLAG_RD
,
113 "Number of times the vnlru process ran without success");
116 static struct lwkt_token mntid_token
;
118 /* note: mountlist exported to pstat */
119 struct mntlist mountlist
= TAILQ_HEAD_INITIALIZER(mountlist
);
120 static TAILQ_HEAD(,mountscan_info
) mountscan_list
;
121 static struct lwkt_token mountlist_token
;
122 static TAILQ_HEAD(,vmntvnodescan_info
) mntvnodescan_list
;
123 struct lwkt_token mntvnode_token
;
126 * Called from vfsinit()
131 lwkt_token_init(&mountlist_token
);
132 lwkt_token_init(&mntvnode_token
);
133 lwkt_token_init(&mntid_token
);
134 TAILQ_INIT(&mountscan_list
);
135 TAILQ_INIT(&mntvnodescan_list
);
139 * Support function called with mntvnode_token held to remove a vnode
140 * from the mountlist. We must update any list scans which are in progress.
143 vremovevnodemnt(struct vnode
*vp
)
145 struct vmntvnodescan_info
*info
;
147 TAILQ_FOREACH(info
, &mntvnodescan_list
, entry
) {
149 info
->vp
= TAILQ_NEXT(vp
, v_nmntvnodes
);
151 TAILQ_REMOVE(&vp
->v_mount
->mnt_nvnodelist
, vp
, v_nmntvnodes
);
155 * Support function called with mntvnode_token held to move a vnode to
156 * the end of the list.
159 vmovevnodetoend(struct mount
*mp
, struct vnode
*vp
)
162 TAILQ_INSERT_TAIL(&mp
->mnt_nvnodelist
, vp
, v_nmntvnodes
);
167 * Allocate a new vnode and associate it with a tag, mount point, and
170 * A VX locked and refd vnode is returned. The caller should setup the
171 * remaining fields and vx_put() or, if he wishes to leave a vref,
172 * vx_unlock() the vnode.
175 getnewvnode(enum vtagtype tag
, struct mount
*mp
,
176 struct vnode
**vpp
, int lktimeout
, int lkflags
)
180 KKASSERT(mp
!= NULL
);
182 vp
= allocvnode(lktimeout
, lkflags
);
187 * By default the vnode is assigned the mount point's normal
190 vp
->v_ops
= &mp
->mnt_vn_use_ops
;
193 * Placing the vnode on the mount point's queue makes it visible.
194 * VNON prevents it from being messed with, however.
199 * A VX locked & refd vnode is returned.
206 * This function creates vnodes with special operations vectors. The
207 * mount point is optional.
209 * This routine is being phased out.
212 getspecialvnode(enum vtagtype tag
, struct mount
*mp
,
213 struct vop_ops
**ops
,
214 struct vnode
**vpp
, int lktimeout
, int lkflags
)
218 vp
= allocvnode(lktimeout
, lkflags
);
224 * Placing the vnode on the mount point's queue makes it visible.
225 * VNON prevents it from being messed with, however.
230 * A VX locked & refd vnode is returned.
237 * Interlock against an unmount, return 0 on success, non-zero on failure.
239 * The passed flag may be 0 or LK_NOWAIT and is only used if an unmount
242 * If no unmount is in-progress LK_NOWAIT is ignored. No other flag bits
243 * are used. A shared locked will be obtained and the filesystem will not
244 * be unmountable until the lock is released.
247 vfs_busy(struct mount
*mp
, int flags
)
251 if (mp
->mnt_kern_flag
& MNTK_UNMOUNT
) {
252 if (flags
& LK_NOWAIT
)
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);
266 if (lockmgr(&mp
->mnt_lock
, lkflags
))
267 panic("vfs_busy: unexpected lock failure");
272 * Free a busy filesystem.
275 vfs_unbusy(struct mount
*mp
)
277 lockmgr(&mp
->mnt_lock
, LK_RELEASE
);
281 * Lookup a filesystem type, and if found allocate and initialize
282 * a mount structure for it.
284 * Devname is usually updated by mount(8) after booting.
287 vfs_rootmountalloc(char *fstypename
, char *devname
, struct mount
**mpp
)
289 struct vfsconf
*vfsp
;
292 if (fstypename
== NULL
)
294 for (vfsp
= vfsconf
; vfsp
; vfsp
= vfsp
->vfc_next
) {
295 if (!strcmp(vfsp
->vfc_name
, fstypename
))
300 mp
= kmalloc(sizeof(struct mount
), M_MOUNT
, M_WAITOK
);
301 bzero((char *)mp
, (u_long
)sizeof(struct mount
));
302 lockinit(&mp
->mnt_lock
, "vfslock", VLKTIMEOUT
, 0);
303 vfs_busy(mp
, LK_NOWAIT
);
304 TAILQ_INIT(&mp
->mnt_nvnodelist
);
305 TAILQ_INIT(&mp
->mnt_reservedvnlist
);
306 TAILQ_INIT(&mp
->mnt_jlist
);
307 mp
->mnt_nvnodelistsize
= 0;
309 mp
->mnt_op
= vfsp
->vfc_vfsops
;
310 mp
->mnt_flag
= MNT_RDONLY
;
311 vfsp
->vfc_refcount
++;
312 mp
->mnt_iosize_max
= DFLTPHYS
;
313 mp
->mnt_stat
.f_type
= vfsp
->vfc_typenum
;
314 mp
->mnt_flag
|= vfsp
->vfc_flags
& MNT_VISFLAGMASK
;
315 strncpy(mp
->mnt_stat
.f_fstypename
, vfsp
->vfc_name
, MFSNAMELEN
);
316 copystr(devname
, mp
->mnt_stat
.f_mntfromname
, MNAMELEN
- 1, 0);
322 * Lookup a mount point by filesystem identifier.
325 vfs_getvfs(fsid_t
*fsid
)
330 lwkt_gettoken(&ilock
, &mountlist_token
);
331 TAILQ_FOREACH(mp
, &mountlist
, mnt_list
) {
332 if (mp
->mnt_stat
.f_fsid
.val
[0] == fsid
->val
[0] &&
333 mp
->mnt_stat
.f_fsid
.val
[1] == fsid
->val
[1]) {
337 lwkt_reltoken(&ilock
);
342 * Get a new unique fsid. Try to make its val[0] unique, since this value
343 * will be used to create fake device numbers for stat(). Also try (but
344 * not so hard) make its val[0] unique mod 2^16, since some emulators only
345 * support 16-bit device numbers. We end up with unique val[0]'s for the
346 * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
348 * Keep in mind that several mounts may be running in parallel. Starting
349 * the search one past where the previous search terminated is both a
350 * micro-optimization and a defense against returning the same fsid to
354 vfs_getnewfsid(struct mount
*mp
)
356 static u_int16_t mntid_base
;
361 lwkt_gettoken(&ilock
, &mntid_token
);
362 mtype
= mp
->mnt_vfc
->vfc_typenum
;
363 tfsid
.val
[1] = mtype
;
364 mtype
= (mtype
& 0xFF) << 24;
366 tfsid
.val
[0] = makeudev(255,
367 mtype
| ((mntid_base
& 0xFF00) << 8) | (mntid_base
& 0xFF));
369 if (vfs_getvfs(&tfsid
) == NULL
)
372 mp
->mnt_stat
.f_fsid
.val
[0] = tfsid
.val
[0];
373 mp
->mnt_stat
.f_fsid
.val
[1] = tfsid
.val
[1];
374 lwkt_reltoken(&ilock
);
378 * This routine is called when we have too many vnodes. It attempts
379 * to free <count> vnodes and will potentially free vnodes that still
380 * have VM backing store (VM backing store is typically the cause
381 * of a vnode blowout so we want to do this). Therefore, this operation
382 * is not considered cheap.
384 * A number of conditions may prevent a vnode from being reclaimed.
385 * the buffer cache may have references on the vnode, a directory
386 * vnode may still have references due to the namei cache representing
387 * underlying files, or the vnode may be in active use. It is not
388 * desireable to reuse such vnodes. These conditions may cause the
389 * number of vnodes to reach some minimum value regardless of what
390 * you set kern.maxvnodes to. Do not set kern.maxvnodes too low.
394 * This is a quick non-blocking check to determine if the vnode is a good
395 * candidate for being (eventually) vgone()'d. Returns 0 if the vnode is
396 * not a good candidate, 1 if it is.
399 vmightfree(struct vnode
*vp
, int page_count
)
401 if (vp
->v_flag
& VRECLAIMED
)
404 if ((vp
->v_flag
& VFREE
) && TAILQ_EMPTY(&vp
->v_namecache
))
407 if (sysref_isactive(&vp
->v_sysref
))
409 if (vp
->v_object
&& vp
->v_object
->resident_page_count
>= page_count
)
415 * The vnode was found to be possibly vgone()able and the caller has locked it
416 * (thus the usecount should be 1 now). Determine if the vnode is actually
417 * vgone()able, doing some cleanups in the process. Returns 1 if the vnode
418 * can be vgone()'d, 0 otherwise.
420 * Note that v_auxrefs may be non-zero because (A) this vnode is not a leaf
421 * in the namecache topology and (B) this vnode has buffer cache bufs.
422 * We cannot remove vnodes with non-leaf namecache associations. We do a
423 * tentitive leaf check prior to attempting to flush out any buffers but the
424 * 'real' test when all is said in done is that v_auxrefs must become 0 for
425 * the vnode to be freeable.
427 * We could theoretically just unconditionally flush when v_auxrefs != 0,
428 * but flushing data associated with non-leaf nodes (which are always
429 * directories), just throws it away for no benefit. It is the buffer
430 * cache's responsibility to choose buffers to recycle from the cached
431 * data point of view.
434 visleaf(struct vnode
*vp
)
436 struct namecache
*ncp
;
438 TAILQ_FOREACH(ncp
, &vp
->v_namecache
, nc_vnode
) {
439 if (!TAILQ_EMPTY(&ncp
->nc_list
))
446 * Try to clean up the vnode to the point where it can be vgone()'d, returning
447 * 0 if it cannot be vgone()'d (or already has been), 1 if it can. Unlike
448 * vmightfree() this routine may flush the vnode and block. Vnodes marked
449 * VFREE are still candidates for vgone()ing because they may hold namecache
450 * resources and could be blocking the namecache directory hierarchy (and
451 * related vnodes) from being freed.
454 vtrytomakegoneable(struct vnode
*vp
, int page_count
)
456 if (vp
->v_flag
& VRECLAIMED
)
458 if (vp
->v_sysref
.refcnt
> 1)
460 if (vp
->v_object
&& vp
->v_object
->resident_page_count
>= page_count
)
462 if (vp
->v_auxrefs
&& visleaf(vp
)) {
463 vinvalbuf(vp
, V_SAVE
, 0, 0);
465 kprintf((vp
->v_auxrefs
? "vrecycle: vp %p failed: %s\n" :
466 "vrecycle: vp %p succeeded: %s\n"), vp
,
467 (TAILQ_FIRST(&vp
->v_namecache
) ?
468 TAILQ_FIRST(&vp
->v_namecache
)->nc_name
: "?"));
473 * This sequence may seem a little strange, but we need to optimize
474 * the critical path a bit. We can't recycle vnodes with other
475 * references and because we are trying to recycle an otherwise
476 * perfectly fine vnode we have to invalidate the namecache in a
477 * way that avoids possible deadlocks (since the vnode lock is being
478 * held here). Finally, we have to check for other references one
479 * last time in case something snuck in during the inval.
481 if (vp
->v_sysref
.refcnt
> 1 || vp
->v_auxrefs
!= 0)
483 if (cache_inval_vp_nonblock(vp
))
485 return (vp
->v_sysref
.refcnt
<= 1 && vp
->v_auxrefs
== 0);
489 * Reclaim up to 1/10 of the vnodes associated with a mount point. Try
490 * to avoid vnodes which have lots of resident pages (we are trying to free
491 * vnodes, not memory).
493 * This routine is a callback from the mountlist scan. The mount point
494 * in question will be busied.
497 vlrureclaim(struct mount
*mp
, void *data
)
505 int trigger_mult
= vnlru_nowhere
;
508 * Calculate the trigger point for the resident pages check. The
509 * minimum trigger value is approximately the number of pages in
510 * the system divded by the number of vnodes. However, due to
511 * various other system memory overheads unrelated to data caching
512 * it is a good idea to double the trigger (at least).
514 * trigger_mult starts at 0. If the recycler is having problems
515 * finding enough freeable vnodes it will increase trigger_mult.
516 * This should not happen in normal operation, even on machines with
517 * low amounts of memory, but extraordinary memory use by the system
518 * verses the amount of cached data can trigger it.
520 usevnodes
= desiredvnodes
;
523 trigger
= vmstats
.v_page_count
* (trigger_mult
+ 2) / usevnodes
;
526 lwkt_gettoken(&ilock
, &mntvnode_token
);
527 count
= mp
->mnt_nvnodelistsize
/ 10 + 1;
528 while (count
&& (vp
= TAILQ_FIRST(&mp
->mnt_nvnodelist
)) != NULL
) {
532 * The VP will stick around while we hold mntvnode_token,
533 * at least until we block, so we can safely do an initial
534 * check, and then must check again after we lock the vnode.
536 if (vp
->v_type
== VNON
|| /* syncer or indeterminant */
537 !vmightfree(vp
, trigger
) /* critical path opt */
539 vmovevnodetoend(mp
, vp
);
545 * VX get the candidate vnode. If the VX get fails the
546 * vnode might still be on the mountlist. Our loop depends
547 * on us at least cycling the vnode to the end of the
550 if (vx_get_nonblock(vp
) != 0) {
551 if (vp
->v_mount
== mp
)
552 vmovevnodetoend(mp
, vp
);
558 * Since we blocked locking the vp, make sure it is still
559 * a candidate for reclamation. That is, it has not already
560 * been reclaimed and only has our VX reference associated
563 if (vp
->v_type
== VNON
|| /* syncer or indeterminant */
564 (vp
->v_flag
& VRECLAIMED
) ||
566 !vtrytomakegoneable(vp
, trigger
) /* critical path opt */
568 if (vp
->v_mount
== mp
)
569 vmovevnodetoend(mp
, vp
);
576 * All right, we are good, move the vp to the end of the
577 * mountlist and clean it out. The vget will have returned
578 * an error if the vnode was destroyed (VRECLAIMED set), so we
579 * do not have to check again. The vput() will move the
580 * vnode to the free list if the vgone() was successful.
582 KKASSERT(vp
->v_mount
== mp
);
583 vmovevnodetoend(mp
, vp
);
589 lwkt_reltoken(&ilock
);
594 * Attempt to recycle vnodes in a context that is always safe to block.
595 * Calling vlrurecycle() from the bowels of file system code has some
596 * interesting deadlock problems.
598 static struct thread
*vnlruthread
;
599 static int vnlruproc_sig
;
602 vnlru_proc_wait(void)
604 if (vnlruproc_sig
== 0) {
605 vnlruproc_sig
= 1; /* avoid unnecessary wakeups */
608 tsleep(&vnlruproc_sig
, 0, "vlruwk", hz
);
614 struct thread
*td
= curthread
;
617 EVENTHANDLER_REGISTER(shutdown_pre_sync
, shutdown_kproc
, td
,
622 kproc_suspend_loop();
625 * Try to free some vnodes if we have too many
627 if (numvnodes
> desiredvnodes
&&
628 freevnodes
> desiredvnodes
* 2 / 10) {
629 int count
= numvnodes
- desiredvnodes
;
631 if (count
> freevnodes
/ 100)
632 count
= freevnodes
/ 100;
635 freesomevnodes(count
);
639 * Nothing to do if most of our vnodes are already on
642 if (numvnodes
- freevnodes
<= desiredvnodes
* 9 / 10) {
644 wakeup(&vnlruproc_sig
);
645 tsleep(td
, 0, "vlruwt", hz
);
649 done
= mountlist_scan(vlrureclaim
, NULL
, MNTSCAN_FORWARD
);
652 * The vlrureclaim() call only processes 1/10 of the vnodes
653 * on each mount. If we couldn't find any repeat the loop
654 * at least enough times to cover all available vnodes before
655 * we start sleeping. Complain if the failure extends past
656 * 30 second, every 30 seconds.
660 if (vnlru_nowhere
% 10 == 0)
661 tsleep(td
, 0, "vlrup", hz
* 3);
662 if (vnlru_nowhere
% 100 == 0)
663 kprintf("vnlru_proc: vnode recycler stopped working!\n");
664 if (vnlru_nowhere
== 1000)
674 * MOUNTLIST FUNCTIONS
678 * mountlist_insert (MP SAFE)
680 * Add a new mount point to the mount list.
683 mountlist_insert(struct mount
*mp
, int how
)
687 lwkt_gettoken(&ilock
, &mountlist_token
);
688 if (how
== MNTINS_FIRST
)
689 TAILQ_INSERT_HEAD(&mountlist
, mp
, mnt_list
);
691 TAILQ_INSERT_TAIL(&mountlist
, mp
, mnt_list
);
692 lwkt_reltoken(&ilock
);
696 * mountlist_interlock (MP SAFE)
698 * Execute the specified interlock function with the mountlist token
699 * held. The function will be called in a serialized fashion verses
700 * other functions called through this mechanism.
703 mountlist_interlock(int (*callback
)(struct mount
*), struct mount
*mp
)
708 lwkt_gettoken(&ilock
, &mountlist_token
);
709 error
= callback(mp
);
710 lwkt_reltoken(&ilock
);
715 * mountlist_boot_getfirst (DURING BOOT ONLY)
717 * This function returns the first mount on the mountlist, which is
718 * expected to be the root mount. Since no interlocks are obtained
719 * this function is only safe to use during booting.
723 mountlist_boot_getfirst(void)
725 return(TAILQ_FIRST(&mountlist
));
729 * mountlist_remove (MP SAFE)
731 * Remove a node from the mountlist. If this node is the next scan node
732 * for any active mountlist scans, the active mountlist scan will be
733 * adjusted to skip the node, thus allowing removals during mountlist
737 mountlist_remove(struct mount
*mp
)
739 struct mountscan_info
*msi
;
742 lwkt_gettoken(&ilock
, &mountlist_token
);
743 TAILQ_FOREACH(msi
, &mountscan_list
, msi_entry
) {
744 if (msi
->msi_node
== mp
) {
745 if (msi
->msi_how
& MNTSCAN_FORWARD
)
746 msi
->msi_node
= TAILQ_NEXT(mp
, mnt_list
);
748 msi
->msi_node
= TAILQ_PREV(mp
, mntlist
, mnt_list
);
751 TAILQ_REMOVE(&mountlist
, mp
, mnt_list
);
752 lwkt_reltoken(&ilock
);
756 * mountlist_scan (MP SAFE)
758 * Safely scan the mount points on the mount list. Unless otherwise
759 * specified each mount point will be busied prior to the callback and
760 * unbusied afterwords. The callback may safely remove any mount point
761 * without interfering with the scan. If the current callback
762 * mount is removed the scanner will not attempt to unbusy it.
764 * If a mount node cannot be busied it is silently skipped.
766 * The callback return value is aggregated and a total is returned. A return
767 * value of < 0 is not aggregated and will terminate the scan.
769 * MNTSCAN_FORWARD - the mountlist is scanned in the forward direction
770 * MNTSCAN_REVERSE - the mountlist is scanned in reverse
771 * MNTSCAN_NOBUSY - the scanner will make the callback without busying
775 mountlist_scan(int (*callback
)(struct mount
*, void *), void *data
, int how
)
777 struct mountscan_info info
;
784 lwkt_gettoken(&ilock
, &mountlist_token
);
787 info
.msi_node
= NULL
; /* paranoia */
788 TAILQ_INSERT_TAIL(&mountscan_list
, &info
, msi_entry
);
793 if (how
& MNTSCAN_FORWARD
) {
794 info
.msi_node
= TAILQ_FIRST(&mountlist
);
795 while ((mp
= info
.msi_node
) != NULL
) {
796 if (how
& MNTSCAN_NOBUSY
) {
797 count
= callback(mp
, data
);
798 } else if (vfs_busy(mp
, LK_NOWAIT
) == 0) {
799 count
= callback(mp
, data
);
800 if (mp
== info
.msi_node
)
808 if (mp
== info
.msi_node
)
809 info
.msi_node
= TAILQ_NEXT(mp
, mnt_list
);
811 } else if (how
& MNTSCAN_REVERSE
) {
812 info
.msi_node
= TAILQ_LAST(&mountlist
, mntlist
);
813 while ((mp
= info
.msi_node
) != NULL
) {
814 if (how
& MNTSCAN_NOBUSY
) {
815 count
= callback(mp
, data
);
816 } else if (vfs_busy(mp
, LK_NOWAIT
) == 0) {
817 count
= callback(mp
, data
);
818 if (mp
== info
.msi_node
)
826 if (mp
== info
.msi_node
)
827 info
.msi_node
= TAILQ_PREV(mp
, mntlist
, mnt_list
);
830 TAILQ_REMOVE(&mountscan_list
, &info
, msi_entry
);
831 lwkt_reltoken(&ilock
);
836 * MOUNT RELATED VNODE FUNCTIONS
839 static struct kproc_desc vnlru_kp
= {
844 SYSINIT(vnlru
, SI_SUB_KTHREAD_UPDATE
, SI_ORDER_FIRST
, kproc_start
, &vnlru_kp
)
847 * Move a vnode from one mount queue to another.
850 insmntque(struct vnode
*vp
, struct mount
*mp
)
854 lwkt_gettoken(&ilock
, &mntvnode_token
);
856 * Delete from old mount point vnode list, if on one.
858 if (vp
->v_mount
!= NULL
) {
859 KASSERT(vp
->v_mount
->mnt_nvnodelistsize
> 0,
860 ("bad mount point vnode list size"));
862 vp
->v_mount
->mnt_nvnodelistsize
--;
865 * Insert into list of vnodes for the new mount point, if available.
867 if ((vp
->v_mount
= mp
) == NULL
) {
868 lwkt_reltoken(&ilock
);
871 TAILQ_INSERT_TAIL(&mp
->mnt_nvnodelist
, vp
, v_nmntvnodes
);
872 mp
->mnt_nvnodelistsize
++;
873 lwkt_reltoken(&ilock
);
878 * Scan the vnodes under a mount point and issue appropriate callbacks.
880 * The fastfunc() callback is called with just the mountlist token held
881 * (no vnode lock). It may not block and the vnode may be undergoing
882 * modifications while the caller is processing it. The vnode will
883 * not be entirely destroyed, however, due to the fact that the mountlist
884 * token is held. A return value < 0 skips to the next vnode without calling
885 * the slowfunc(), a return value > 0 terminates the loop.
887 * The slowfunc() callback is called after the vnode has been successfully
888 * locked based on passed flags. The vnode is skipped if it gets rearranged
889 * or destroyed while blocking on the lock. A non-zero return value from
890 * the slow function terminates the loop. The slow function is allowed to
891 * arbitrarily block. The scanning code guarentees consistency of operation
892 * even if the slow function deletes or moves the node, or blocks and some
893 * other thread deletes or moves the node.
899 int (*fastfunc
)(struct mount
*mp
, struct vnode
*vp
, void *data
),
900 int (*slowfunc
)(struct mount
*mp
, struct vnode
*vp
, void *data
),
903 struct vmntvnodescan_info info
;
907 int maxcount
= 1000000;
909 lwkt_gettoken(&ilock
, &mntvnode_token
);
911 info
.vp
= TAILQ_FIRST(&mp
->mnt_nvnodelist
);
912 TAILQ_INSERT_TAIL(&mntvnodescan_list
, &info
, entry
);
913 while ((vp
= info
.vp
) != NULL
) {
915 panic("maxcount reached during vmntvnodescan");
917 if (vp
->v_type
== VNON
) /* visible but not ready */
919 KKASSERT(vp
->v_mount
== mp
);
922 * Quick test. A negative return continues the loop without
923 * calling the slow test. 0 continues onto the slow test.
924 * A positive number aborts the loop.
927 if ((r
= fastfunc(mp
, vp
, data
)) < 0)
934 * Get a vxlock on the vnode, retry if it has moved or isn't
935 * in the mountlist where we expect it.
942 error
= vget(vp
, LK_EXCLUSIVE
);
944 case VMSC_GETVP
|VMSC_NOWAIT
:
945 error
= vget(vp
, LK_EXCLUSIVE
|LK_NOWAIT
);
958 * Do not call the slow function if the vnode is
959 * invalid or if it was ripped out from under us
960 * while we (potentially) blocked.
962 if (info
.vp
== vp
&& vp
->v_type
!= VNON
)
963 r
= slowfunc(mp
, vp
, data
);
970 case VMSC_GETVP
|VMSC_NOWAIT
:
984 * Iterate. If the vnode was ripped out from under us
985 * info.vp will already point to the next vnode, otherwise
986 * we have to obtain the next valid vnode ourselves.
990 info
.vp
= TAILQ_NEXT(vp
, v_nmntvnodes
);
992 TAILQ_REMOVE(&mntvnodescan_list
, &info
, entry
);
993 lwkt_reltoken(&ilock
);
998 * Remove any vnodes in the vnode table belonging to mount point mp.
1000 * If FORCECLOSE is not specified, there should not be any active ones,
1001 * return error if any are found (nb: this is a user error, not a
1002 * system error). If FORCECLOSE is specified, detach any active vnodes
1005 * If WRITECLOSE is set, only flush out regular file vnodes open for
1008 * SKIPSYSTEM causes any vnodes marked VSYSTEM to be skipped.
1010 * `rootrefs' specifies the base reference count for the root vnode
1011 * of this filesystem. The root vnode is considered busy if its
1012 * v_sysref.refcnt exceeds this value. On a successful return, vflush()
1013 * will call vrele() on the root vnode exactly rootrefs times.
1014 * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
1018 static int busyprt
= 0; /* print out busy vnodes */
1019 SYSCTL_INT(_debug
, OID_AUTO
, busyprt
, CTLFLAG_RW
, &busyprt
, 0, "");
1022 static int vflush_scan(struct mount
*mp
, struct vnode
*vp
, void *data
);
1024 struct vflush_info
{
1031 vflush(struct mount
*mp
, int rootrefs
, int flags
)
1033 struct thread
*td
= curthread
; /* XXX */
1034 struct vnode
*rootvp
= NULL
;
1036 struct vflush_info vflush_info
;
1039 KASSERT((flags
& (SKIPSYSTEM
| WRITECLOSE
)) == 0,
1040 ("vflush: bad args"));
1042 * Get the filesystem root vnode. We can vput() it
1043 * immediately, since with rootrefs > 0, it won't go away.
1045 if ((error
= VFS_ROOT(mp
, &rootvp
)) != 0)
1050 vflush_info
.busy
= 0;
1051 vflush_info
.flags
= flags
;
1052 vflush_info
.td
= td
;
1053 vmntvnodescan(mp
, VMSC_GETVX
, NULL
, vflush_scan
, &vflush_info
);
1055 if (rootrefs
> 0 && (flags
& FORCECLOSE
) == 0) {
1057 * If just the root vnode is busy, and if its refcount
1058 * is equal to `rootrefs', then go ahead and kill it.
1060 KASSERT(vflush_info
.busy
> 0, ("vflush: not busy"));
1061 KASSERT(rootvp
->v_sysref
.refcnt
>= rootrefs
, ("vflush: rootrefs"));
1062 if (vflush_info
.busy
== 1 && rootvp
->v_sysref
.refcnt
== rootrefs
) {
1064 vgone_vxlocked(rootvp
);
1066 vflush_info
.busy
= 0;
1069 if (vflush_info
.busy
)
1071 for (; rootrefs
> 0; rootrefs
--)
1077 * The scan callback is made with an VX locked vnode.
1080 vflush_scan(struct mount
*mp
, struct vnode
*vp
, void *data
)
1082 struct vflush_info
*info
= data
;
1086 * Skip over a vnodes marked VSYSTEM.
1088 if ((info
->flags
& SKIPSYSTEM
) && (vp
->v_flag
& VSYSTEM
)) {
1093 * If WRITECLOSE is set, flush out unlinked but still open
1094 * files (even if open only for reading) and regular file
1095 * vnodes open for writing.
1097 if ((info
->flags
& WRITECLOSE
) &&
1098 (vp
->v_type
== VNON
||
1099 (VOP_GETATTR(vp
, &vattr
) == 0 &&
1100 vattr
.va_nlink
> 0)) &&
1101 (vp
->v_writecount
== 0 || vp
->v_type
!= VREG
)) {
1106 * If we are the only holder (refcnt of 1) or the vnode is in
1107 * termination (refcnt < 0), we can vgone the vnode.
1109 if (vp
->v_sysref
.refcnt
<= 1) {
1115 * If FORCECLOSE is set, forcibly close the vnode. For block
1116 * or character devices, revert to an anonymous device. For
1117 * all other files, just kill them.
1119 if (info
->flags
& FORCECLOSE
) {
1120 if (vp
->v_type
!= VBLK
&& vp
->v_type
!= VCHR
) {
1123 vclean_vxlocked(vp
, 0);
1124 vp
->v_ops
= &spec_vnode_vops_p
;
1125 insmntque(vp
, NULL
);
1131 vprint("vflush: busy vnode", vp
);