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 * $DragonFly: src/sys/kern/vfs_lock.c,v 1.30 2008/06/30 03:57:41 dillon Exp $
38 * External virtual filesystem routines
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/malloc.h>
46 #include <sys/mount.h>
48 #include <sys/vnode.h>
50 #include <sys/sysctl.h>
52 #include <machine/limits.h>
55 #include <vm/vm_object.h>
58 #include <sys/thread2.h>
59 #include <sys/sysref2.h>
60 #include <sys/mplock2.h>
62 static void vnode_terminate(struct vnode *vp);
63 static boolean_t vnode_ctor(void *obj, void *private, int ocflags);
64 static void vnode_dtor(void *obj, void *private);
66 static MALLOC_DEFINE(M_VNODE, "vnodes", "vnode structures");
67 static struct sysref_class vnode_sysref_class = {
70 .proto = SYSREF_PROTO_VNODE,
71 .offset = offsetof(struct vnode, v_sysref),
72 .objsize = sizeof(struct vnode),
74 .flags = SRC_MANAGEDINIT,
78 .terminate = (sysref_terminate_func_t)vnode_terminate,
79 .lock = (sysref_terminate_func_t)vx_lock,
80 .unlock = (sysref_terminate_func_t)vx_unlock
85 * The vnode free list hold inactive vnodes. Aged inactive vnodes
86 * are inserted prior to the mid point, and otherwise inserted
89 static TAILQ_HEAD(freelst, vnode) vnode_free_list;
90 static struct vnode vnode_free_mid1;
91 static struct vnode vnode_free_mid2;
92 static struct vnode vnode_free_rover;
93 static struct spinlock vfs_spin = SPINLOCK_INITIALIZER(vfs_spin);
94 static enum { ROVER_MID1, ROVER_MID2 } rover_state = ROVER_MID2;
97 SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD,
98 &freevnodes, 0, "Number of free nodes");
99 static int wantfreevnodes = 25;
100 SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW,
101 &wantfreevnodes, 0, "Desired number of free vnodes");
103 static ulong trackvnode;
104 SYSCTL_ULONG(_debug, OID_AUTO, trackvnode, CTLFLAG_RW,
109 * Called from vfsinit()
114 TAILQ_INIT(&vnode_free_list);
115 TAILQ_INSERT_TAIL(&vnode_free_list, &vnode_free_mid1, v_freelist);
116 TAILQ_INSERT_TAIL(&vnode_free_list, &vnode_free_mid2, v_freelist);
117 TAILQ_INSERT_TAIL(&vnode_free_list, &vnode_free_rover, v_freelist);
118 spin_init(&vfs_spin);
119 kmalloc_raise_limit(M_VNODE, 0); /* unlimited */
127 _vsetflags(struct vnode *vp, int flags)
129 atomic_set_int(&vp->v_flag, flags);
134 _vclrflags(struct vnode *vp, int flags)
136 atomic_clear_int(&vp->v_flag, flags);
140 vsetflags(struct vnode *vp, int flags)
142 _vsetflags(vp, flags);
146 vclrflags(struct vnode *vp, int flags)
148 _vclrflags(vp, flags);
152 * Inline helper functions.
154 * WARNING: vbusy() may only be called while the vnode lock or VX lock
155 * is held. The vnode spinlock need not be held.
161 __vbusy_interlocked(struct vnode *vp)
163 KKASSERT(vp->v_flag & VFREE);
164 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
166 _vclrflags(vp, VFREE);
171 __vbusy(struct vnode *vp)
174 if ((ulong)vp == trackvnode)
175 kprintf("__vbusy %p %08x\n", vp, vp->v_flag);
177 spin_lock(&vfs_spin);
178 __vbusy_interlocked(vp);
179 spin_unlock(&vfs_spin);
183 * Put a vnode on the free list. The caller has cleared VCACHED or owns the
184 * implied sysref related to having removed the vnode from the freelist
185 * (and VCACHED is already clear in that case).
191 __vfree(struct vnode *vp)
194 if ((ulong)vp == trackvnode) {
195 kprintf("__vfree %p %08x\n", vp, vp->v_flag);
199 spin_lock(&vfs_spin);
200 KKASSERT((vp->v_flag & VFREE) == 0);
203 * Distinguish between basically dead vnodes, vnodes with cached
204 * data, and vnodes without cached data. A rover will shift the
205 * vnodes around as their cache status is lost.
207 if (vp->v_flag & VRECLAIMED) {
208 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
209 } else if (vp->v_object && vp->v_object->resident_page_count) {
210 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
211 } else if (vp->v_object && vp->v_object->swblock_count) {
212 TAILQ_INSERT_BEFORE(&vnode_free_mid2, vp, v_freelist);
214 TAILQ_INSERT_BEFORE(&vnode_free_mid1, vp, v_freelist);
217 _vsetflags(vp, VFREE);
218 spin_unlock(&vfs_spin);
222 * Put a vnode on the free list. The caller has cleared VCACHED or owns the
223 * implied sysref related to having removed the vnode from the freelist
224 * (and VCACHED is already clear in that case).
230 __vfreetail(struct vnode *vp)
233 if ((ulong)vp == trackvnode)
234 kprintf("__vfreetail %p %08x\n", vp, vp->v_flag);
236 spin_lock(&vfs_spin);
237 KKASSERT((vp->v_flag & VFREE) == 0);
238 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
240 _vsetflags(vp, VFREE);
241 spin_unlock(&vfs_spin);
245 * Return a C boolean if we should put the vnode on the freelist (VFREE),
246 * or leave it / mark it as VCACHED.
248 * This routine is only valid if the vnode is already either VFREE or
249 * VCACHED, or if it can become VFREE or VCACHED via vnode_terminate().
251 * WARNING! This functions is typically called with v_spinlock held.
255 static __inline boolean_t
256 vshouldfree(struct vnode *vp)
258 return (vp->v_auxrefs == 0 &&
259 (vp->v_object == NULL || vp->v_object->resident_page_count == 0));
263 * Add a ref to an active vnode. This function should never be called
264 * with an inactive vnode (use vget() instead).
269 vref(struct vnode *vp)
271 KKASSERT(vp->v_sysref.refcnt > 0 &&
272 (vp->v_flag & (VFREE|VINACTIVE)) == 0);
273 sysref_get(&vp->v_sysref);
277 * Release a ref on an active or inactive vnode. The sysref termination
278 * function will be called when the active last active reference is released,
279 * and the vnode is returned to the objcache when the last inactive
280 * reference is released.
283 vrele(struct vnode *vp)
285 sysref_put(&vp->v_sysref);
289 * Add an auxiliary data structure reference to the vnode. Auxiliary
290 * references do not change the state of the vnode or prevent them
291 * from being deactivated, reclaimed, or placed on or removed from
294 * An auxiliary reference DOES prevent the vnode from being destroyed,
295 * allowing you to vx_lock() it, test state, etc.
297 * An auxiliary reference DOES NOT move a vnode out of the VFREE state
298 * once it has entered it.
300 * WARNING! vhold() and vhold_interlocked() must not acquire v_spinlock.
301 * The spinlock may or may not already be held by the caller.
302 * vdrop() will clean up the free list state.
307 vhold(struct vnode *vp)
309 KKASSERT(vp->v_sysref.refcnt != 0);
310 atomic_add_int(&vp->v_auxrefs, 1);
314 vhold_interlocked(struct vnode *vp)
316 atomic_add_int(&vp->v_auxrefs, 1);
320 * Remove an auxiliary reference from the vnode.
322 * vdrop needs to check for a VCACHE->VFREE transition to catch cases
323 * where a vnode is held past its reclamation. We use v_spinlock to
324 * interlock VCACHED -> !VCACHED transitions.
329 vdrop(struct vnode *vp)
331 KKASSERT(vp->v_sysref.refcnt != 0 && vp->v_auxrefs > 0);
332 spin_lock(&vp->v_spinlock);
333 atomic_subtract_int(&vp->v_auxrefs, 1);
334 if ((vp->v_flag & VCACHED) && vshouldfree(vp)) {
335 _vclrflags(vp, VCACHED);
338 spin_unlock(&vp->v_spinlock);
342 * This function is called when the last active reference on the vnode
343 * is released, typically via vrele(). SYSREF will VX lock the vnode
344 * and then give the vnode a negative ref count, indicating that it is
345 * undergoing termination or is being set aside for the cache, and one
346 * final sysref_put() is required to actually return it to the memory
349 * Additional inactive sysrefs may race us but that's ok. Reactivations
350 * cannot race us because the sysref code interlocked with the VX lock
351 * (which is held on call).
356 vnode_terminate(struct vnode *vp)
359 * We own the VX lock, it should not be possible for someone else
360 * to have reactivated the vp.
362 KKASSERT(sysref_isinactive(&vp->v_sysref));
365 * Deactivate the vnode by marking it VFREE or VCACHED.
366 * The vnode can be reactivated from either state until
367 * reclaimed. These states inherit the 'last' sysref on the
370 * NOTE: There may be additional inactive references from
371 * other entities blocking on the VX lock while we hold it,
372 * but this does not prevent us from changing the vnode's
375 * NOTE: The vnode could already be marked inactive. XXX
378 * NOTE: v_mount may be NULL due to assignment to
381 * NOTE: The vnode may be marked inactive with dirty buffers
382 * or dirty pages in its cached VM object still present.
384 * NOTE: VCACHED should not be set on entry. We lose control
385 * of the sysref the instant the vnode is placed on the
386 * free list or when VCACHED is set.
388 * The VX lock is required when transitioning to
389 * +VCACHED but is not sufficient for the vshouldfree()
390 * interlocked test or when transitioning to -VCACHED.
392 if ((vp->v_flag & VINACTIVE) == 0) {
393 _vsetflags(vp, VINACTIVE);
397 spin_lock(&vp->v_spinlock);
398 KKASSERT((vp->v_flag & (VFREE|VCACHED)) == 0);
402 _vsetflags(vp, VCACHED); /* inactive but not yet free*/
403 spin_unlock(&vp->v_spinlock);
408 * Physical vnode constructor / destructor. These are only executed on
409 * the backend of the objcache. They are NOT executed on every vnode
410 * allocation or deallocation.
415 vnode_ctor(void *obj, void *private, int ocflags)
417 struct vnode *vp = obj;
419 lwkt_token_init(&vp->v_token, "vnode");
420 lockinit(&vp->v_lock, "vnode", 0, 0);
421 ccms_dataspace_init(&vp->v_ccms);
422 TAILQ_INIT(&vp->v_namecache);
423 RB_INIT(&vp->v_rbclean_tree);
424 RB_INIT(&vp->v_rbdirty_tree);
425 RB_INIT(&vp->v_rbhash_tree);
433 vnode_dtor(void *obj, void *private)
435 struct vnode *vp = obj;
437 KKASSERT((vp->v_flag & (VCACHED|VFREE)) == 0);
438 ccms_dataspace_destroy(&vp->v_ccms);
441 /****************************************************************
442 * VX LOCKING FUNCTIONS *
443 ****************************************************************
445 * These functions lock vnodes for reclamation and deactivation related
446 * activities. The caller must already be holding some sort of reference
452 vx_lock(struct vnode *vp)
454 lockmgr(&vp->v_lock, LK_EXCLUSIVE);
458 * The non-blocking version also uses a slightly different mechanic.
459 * This function will explicitly fail not only if it cannot acquire
460 * the lock normally, but also if the caller already holds a lock.
462 * The adjusted mechanic is used to close a loophole where complex
463 * VOP_RECLAIM code can circle around recursively and allocate the
464 * same vnode it is trying to destroy from the freelist.
466 * Any filesystem (aka UFS) which puts LK_CANRECURSE in lk_flags can
467 * cause the incorrect behavior to occur. If not for that lockmgr()
468 * would do the right thing.
471 vx_lock_nonblock(struct vnode *vp)
473 if (lockcountnb(&vp->v_lock))
475 return(lockmgr(&vp->v_lock, LK_EXCLUSIVE | LK_NOWAIT | LK_NOSPINWAIT));
479 vx_unlock(struct vnode *vp)
481 lockmgr(&vp->v_lock, LK_RELEASE);
484 /****************************************************************
485 * VNODE ACQUISITION FUNCTIONS *
486 ****************************************************************
488 * These functions must be used when accessing a vnode via an auxiliary
489 * reference such as the namecache or free list, or when you wish to
490 * do a combo ref+lock sequence.
492 * These functions are MANDATORY for any code chain accessing a vnode
493 * whos activation state is not known.
495 * vget() can be called with LK_NOWAIT and will return EBUSY if the
496 * lock cannot be immediately acquired.
498 * vget()/vput() are used when reactivation is desired.
500 * vx_get() and vx_put() are used when reactivation is not desired.
503 vget(struct vnode *vp, int flags)
508 * A lock type must be passed
510 if ((flags & LK_TYPE_MASK) == 0) {
511 panic("vget() called with no lock specified!");
516 * Reference the structure and then acquire the lock. 0->1
517 * transitions and refs during termination are allowed here so
518 * call sysref directly.
520 * NOTE: The requested lock might be a shared lock and does
521 * not protect our access to the refcnt or other fields.
523 sysref_get(&vp->v_sysref);
524 if ((error = vn_lock(vp, flags)) != 0) {
526 * The lock failed, undo and return an error.
528 sysref_put(&vp->v_sysref);
529 } else if (vp->v_flag & VRECLAIMED) {
531 * The node is being reclaimed and cannot be reactivated
532 * any more, undo and return ENOENT.
539 * If the vnode is marked VFREE or VCACHED it needs to be
540 * reactivated, otherwise it had better already be active.
541 * VINACTIVE must also be cleared.
543 * In the VFREE/VCACHED case we have to throw away the
544 * sysref that was earmarking those cases and preventing
545 * the vnode from being destroyed. Our sysref is still held.
547 * We are allowed to reactivate the vnode while we hold
548 * the VX lock, assuming it can be reactivated.
550 spin_lock(&vp->v_spinlock);
551 if (vp->v_flag & VFREE) {
553 sysref_activate(&vp->v_sysref);
554 spin_unlock(&vp->v_spinlock);
555 sysref_put(&vp->v_sysref);
556 } else if (vp->v_flag & VCACHED) {
557 _vclrflags(vp, VCACHED);
558 sysref_activate(&vp->v_sysref);
559 spin_unlock(&vp->v_spinlock);
560 sysref_put(&vp->v_sysref);
562 if (sysref_isinactive(&vp->v_sysref)) {
563 sysref_activate(&vp->v_sysref);
564 kprintf("Warning vp %p reactivation race\n",
567 spin_unlock(&vp->v_spinlock);
569 _vclrflags(vp, VINACTIVE);
579 vput(struct vnode *vp)
586 * XXX The vx_*() locks should use auxrefs, not the main reference counter.
591 vx_get(struct vnode *vp)
593 sysref_get(&vp->v_sysref);
594 lockmgr(&vp->v_lock, LK_EXCLUSIVE);
601 vx_get_nonblock(struct vnode *vp)
605 sysref_get(&vp->v_sysref);
606 error = lockmgr(&vp->v_lock, LK_EXCLUSIVE | LK_NOWAIT);
608 sysref_put(&vp->v_sysref);
613 * Relase a VX lock that also held a ref on the vnode.
615 * vx_put needs to check for a VCACHED->VFREE transition to catch the
616 * case where e.g. vnlru issues a vgone*().
621 vx_put(struct vnode *vp)
623 spin_lock(&vp->v_spinlock);
624 if ((vp->v_flag & VCACHED) && vshouldfree(vp)) {
625 _vclrflags(vp, VCACHED);
628 spin_unlock(&vp->v_spinlock);
629 lockmgr(&vp->v_lock, LK_RELEASE);
630 sysref_put(&vp->v_sysref);
634 * The rover looks for vnodes past the midline with no cached data and
635 * moves them to before the midline. If we do not do this the midline
636 * can wind up in a degenerate state.
640 vnode_rover_locked(void)
645 * Get the vnode after the rover. The rover roves between mid1 and
646 * the end so the only special vnode it can encounter is mid2.
648 vp = TAILQ_NEXT(&vnode_free_rover, v_freelist);
649 if (vp == &vnode_free_mid2) {
650 vp = TAILQ_NEXT(vp, v_freelist);
651 rover_state = ROVER_MID2;
653 KKASSERT(vp != &vnode_free_mid1);
656 * Start over if we finished the scan.
658 TAILQ_REMOVE(&vnode_free_list, &vnode_free_rover, v_freelist);
660 TAILQ_INSERT_AFTER(&vnode_free_list, &vnode_free_mid1,
661 &vnode_free_rover, v_freelist);
662 rover_state = ROVER_MID1;
665 TAILQ_INSERT_AFTER(&vnode_free_list, vp, &vnode_free_rover, v_freelist);
668 * Shift vp if appropriate.
670 if (vp->v_object && vp->v_object->resident_page_count) {
672 * Promote vnode with resident pages to section 3.
673 * (This case shouldn't happen).
675 if (rover_state == ROVER_MID1) {
676 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
677 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
679 } else if (vp->v_object && vp->v_object->swblock_count) {
681 * Demote vnode with only swap pages to section 2
683 if (rover_state == ROVER_MID2) {
684 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
685 TAILQ_INSERT_BEFORE(&vnode_free_mid2, vp, v_freelist);
689 * Demote vnode with no cached data to section 1
691 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
692 TAILQ_INSERT_BEFORE(&vnode_free_mid1, vp, v_freelist);
697 * Try to reuse a vnode from the free list.
699 * NOTE: The returned vnode is not completely initialized.
701 * WARNING: The freevnodes count can race, NULL can be returned even if
713 for (count = 0; count < freevnodes; count++) {
715 * Try to lock the first vnode on the free list.
718 * We use a bad hack in vx_lock_nonblock() which avoids
719 * the lock order reversal between vfs_spin and v_spinlock.
720 * This is very fragile code and I don't want to use
723 spin_lock(&vfs_spin);
724 vnode_rover_locked();
725 vnode_rover_locked();
726 vp = TAILQ_FIRST(&vnode_free_list);
727 while (vp == &vnode_free_mid1 || vp == &vnode_free_mid2 ||
728 vp == &vnode_free_rover) {
729 vp = TAILQ_NEXT(vp, v_freelist);
733 if (vx_lock_nonblock(vp)) {
734 KKASSERT(vp->v_flag & VFREE);
735 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
736 TAILQ_INSERT_TAIL(&vnode_free_list,
738 spin_unlock(&vfs_spin);
743 * We inherit the sysref associated the vnode on the free
744 * list. Because VCACHED is clear the vnode will not
745 * be placed back on the free list. We own the sysref
746 * free and clear and thus control the disposition of
749 __vbusy_interlocked(vp);
750 spin_unlock(&vfs_spin);
752 if ((ulong)vp == trackvnode)
753 kprintf("allocfreevnode %p %08x\n", vp, vp->v_flag);
756 * Do not reclaim/reuse a vnode while auxillary refs exists.
757 * This includes namecache refs due to a related ncp being
758 * locked or having children.
760 * We will make this test several times as auxrefs can
761 * get incremented on us without any spinlocks being held
762 * until we have removed all namecache and inode references
765 * Because VCACHED is already in the correct state (cleared)
766 * we cannot race other vdrop()s occuring at the same time
767 * and can safely place vp on the free list.
769 * The free list association reinherits the sysref.
778 * We inherit the reference that was previously associated
779 * with the vnode being on the free list. VCACHED had better
780 * not be set because the reference and VX lock prevents
781 * the sysref from transitioning to an active state.
783 KKASSERT((vp->v_flag & (VINACTIVE|VCACHED)) == VINACTIVE);
784 KKASSERT(sysref_isinactive(&vp->v_sysref));
787 * Holding the VX lock on an inactive vnode prevents it
788 * from being reactivated or reused. New namecache
789 * associations can only be made using active vnodes.
791 * Another thread may be blocked on our vnode lock while
792 * holding a namecache lock. We can only reuse this vnode
793 * if we can clear all namecache associations without
796 * Because VCACHED is already in the correct state (cleared)
797 * we cannot race other vdrop()s occuring at the same time
798 * and can safely place vp on the free list.
800 if ((vp->v_flag & VRECLAIMED) == 0) {
801 if (cache_inval_vp_nonblock(vp)) {
807 /* vnode is still VX locked */
811 * We can reuse the vnode if no primary or auxiliary
812 * references remain other then ours, else put it
813 * back on the free list and keep looking.
815 * Either the free list inherits the last reference
816 * or we fall through and sysref_activate() the last
819 * Since the vnode is in a VRECLAIMED state, no new
820 * namecache associations could have been made.
822 KKASSERT(TAILQ_EMPTY(&vp->v_namecache));
824 !sysref_islastdeactivation(&vp->v_sysref)) {
831 * Return a VX locked vnode suitable for reuse. The caller
832 * inherits the sysref.
840 * Obtain a new vnode from the freelist, allocating more if necessary.
841 * The returned vnode is VX locked & refd.
843 * All new vnodes set the VAGE flags. An open() of the vnode will
844 * decrement the (2-bit) flags. Vnodes which are opened several times
845 * are thus retained in the cache over vnodes which are merely stat()d.
850 allocvnode(int lktimeout, int lkflags)
855 * Try to reuse vnodes if we hit the max. This situation only
856 * occurs in certain large-memory (2G+) situations. We cannot
857 * attempt to directly reclaim vnodes due to nasty recursion
860 while (numvnodes - freevnodes > desiredvnodes)
864 * Try to build up as many vnodes as we can before reallocating
865 * from the free list. A vnode on the free list simply means
866 * that it is inactive with no resident pages. It may or may not
867 * have been reclaimed and could have valuable information associated
868 * with it that we shouldn't throw away unless we really need to.
870 * HAMMER NOTE: Re-establishing a vnode is a fairly expensive
871 * operation for HAMMER but this should benefit UFS as well.
873 if (freevnodes >= wantfreevnodes && numvnodes >= desiredvnodes)
874 vp = allocfreevnode();
878 vp = sysref_alloc(&vnode_sysref_class);
879 KKASSERT((vp->v_flag & (VCACHED|VFREE)) == 0);
880 lockmgr(&vp->v_lock, LK_EXCLUSIVE);
885 * We are using a managed sysref class, vnode fields are only
886 * zerod on initial allocation from the backing store, not
887 * on reallocation. Thus we have to clear these fields for both
888 * reallocation and reuse.
892 panic("cleaned vnode isn't");
893 if (bio_track_active(&vp->v_track_read) ||
894 bio_track_active(&vp->v_track_write)) {
895 panic("Clean vnode has pending I/O's");
897 if (vp->v_flag & VONWORKLST)
898 panic("Clean vnode still pending on syncer worklist!");
899 if (!RB_EMPTY(&vp->v_rbdirty_tree))
900 panic("Clean vnode still has dirty buffers!");
901 if (!RB_EMPTY(&vp->v_rbclean_tree))
902 panic("Clean vnode still has clean buffers!");
903 if (!RB_EMPTY(&vp->v_rbhash_tree))
904 panic("Clean vnode still on hash tree!");
905 KKASSERT(vp->v_mount == NULL);
907 vp->v_flag = VAGE0 | VAGE1;
914 vp->v_writecount = 0; /* XXX */
917 * lktimeout only applies when LK_TIMELOCK is used, and only
918 * the pageout daemon uses it. The timeout may not be zero
919 * or the pageout daemon can deadlock in low-VM situations.
923 lockreinit(&vp->v_lock, "vnode", lktimeout, lkflags);
924 KKASSERT(TAILQ_EMPTY(&vp->v_namecache));
925 /* exclusive lock still held */
928 * Note: sysref needs to be activated to convert -0x40000000 to +1.
929 * The -0x40000000 comes from the last ref on reuse, and from
930 * sysref_init() on allocate.
932 sysref_activate(&vp->v_sysref);
933 vp->v_filesize = NOOFFSET;
938 KKASSERT(vp->v_mount == NULL);
947 freesomevnodes(int n)
954 if ((vp = allocfreevnode()) == NULL)