1 /* 2 * Copyright (c) 2004 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 16 * distribution. 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. 20 * 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 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sys/kern/vfs_lock.c,v 1.30 2008/06/30 03:57:41 dillon Exp $ 35 */ 36 37 /* 38 * External virtual filesystem routines 39 */ 40 #include "opt_ddb.h" 41 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> 47 #include <sys/proc.h> 48 #include <sys/vnode.h> 49 #include <sys/buf.h> 50 #include <sys/sysctl.h> 51 52 #include <machine/limits.h> 53 54 #include <vm/vm.h> 55 #include <vm/vm_object.h> 56 57 #include <sys/buf2.h> 58 #include <sys/thread2.h> 59 #include <sys/sysref2.h> 60 61 static void vnode_terminate(struct vnode *vp); 62 static boolean_t vnode_ctor(void *obj, void *private, int ocflags); 63 static void vnode_dtor(void *obj, void *private); 64 65 static MALLOC_DEFINE(M_VNODE, "vnodes", "vnode structures"); 66 static struct sysref_class vnode_sysref_class = { 67 .name = "vnode", 68 .mtype = M_VNODE, 69 .proto = SYSREF_PROTO_VNODE, 70 .offset = offsetof(struct vnode, v_sysref), 71 .objsize = sizeof(struct vnode), 72 .mag_capacity = 256, 73 .flags = SRC_MANAGEDINIT, 74 .ctor = vnode_ctor, 75 .dtor = vnode_dtor, 76 .ops = { 77 .terminate = (sysref_terminate_func_t)vnode_terminate 78 } 79 }; 80 81 /* 82 * The vnode free list hold inactive vnodes. Aged inactive vnodes 83 * are inserted prior to the mid point, and otherwise inserted 84 * at the tail. 85 */ 86 static TAILQ_HEAD(freelst, vnode) vnode_free_list; 87 static struct vnode vnode_free_mid; 88 static struct spinlock vfs_spin = SPINLOCK_INITIALIZER(vfs_spin); 89 90 int freevnodes = 0; 91 SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD, 92 &freevnodes, 0, ""); 93 static int wantfreevnodes = 25; 94 SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW, 95 &wantfreevnodes, 0, ""); 96 #ifdef TRACKVNODE 97 static ulong trackvnode; 98 SYSCTL_ULONG(_debug, OID_AUTO, trackvnode, CTLFLAG_RW, 99 &trackvnode, 0, ""); 100 #endif 101 102 /* 103 * Called from vfsinit() 104 */ 105 void 106 vfs_lock_init(void) 107 { 108 TAILQ_INIT(&vnode_free_list); 109 TAILQ_INSERT_HEAD(&vnode_free_list, &vnode_free_mid, v_freelist); 110 spin_init(&vfs_spin); 111 } 112 113 /* 114 * Misc functions 115 */ 116 static __inline 117 void 118 _vsetflags(struct vnode *vp, int flags) 119 { 120 atomic_set_int(&vp->v_flag, flags); 121 } 122 123 static __inline 124 void 125 _vclrflags(struct vnode *vp, int flags) 126 { 127 atomic_clear_int(&vp->v_flag, flags); 128 } 129 130 void 131 vsetflags(struct vnode *vp, int flags) 132 { 133 _vsetflags(vp, flags); 134 } 135 136 void 137 vclrflags(struct vnode *vp, int flags) 138 { 139 _vclrflags(vp, flags); 140 } 141 142 /* 143 * Inline helper functions. vbusy() and vfree() must be called while 144 * vp->v_spinlock is held. 145 * 146 * WARNING! This functions is typically called with v_spinlock held. 147 * 148 * MPSAFE 149 */ 150 static __inline 151 void 152 __vbusy(struct vnode *vp) 153 { 154 #ifdef TRACKVNODE 155 if ((ulong)vp == trackvnode) 156 kprintf("__vbusy %p %08x\n", vp, vp->v_flag); 157 #endif 158 spin_lock_wr(&vfs_spin); 159 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 160 freevnodes--; 161 _vclrflags(vp, VFREE); 162 spin_unlock_wr(&vfs_spin); 163 } 164 165 /* 166 * WARNING! This functions is typically called with v_spinlock held. 167 * 168 * MPSAFE 169 */ 170 static __inline 171 void 172 __vfree(struct vnode *vp) 173 { 174 #ifdef TRACKVNODE 175 if ((ulong)vp == trackvnode) { 176 kprintf("__vfree %p %08x\n", vp, vp->v_flag); 177 print_backtrace(); 178 } 179 #endif 180 spin_lock_wr(&vfs_spin); 181 if (vp->v_flag & VRECLAIMED) 182 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist); 183 else if (vp->v_flag & (VAGE0 | VAGE1)) 184 TAILQ_INSERT_BEFORE(&vnode_free_mid, vp, v_freelist); 185 else 186 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 187 freevnodes++; 188 _vsetflags(vp, VFREE); 189 spin_unlock_wr(&vfs_spin); 190 } 191 192 /* 193 * WARNING! This functions is typically called with v_spinlock held. 194 * 195 * MPSAFE 196 */ 197 static __inline 198 void 199 __vfreetail(struct vnode *vp) 200 { 201 #ifdef TRACKVNODE 202 if ((ulong)vp == trackvnode) 203 kprintf("__vfreetail %p %08x\n", vp, vp->v_flag); 204 #endif 205 spin_lock_wr(&vfs_spin); 206 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist); 207 freevnodes++; 208 _vsetflags(vp, VFREE); 209 spin_unlock_wr(&vfs_spin); 210 } 211 212 /* 213 * Return a C boolean if we should put the vnode on the freelist (VFREE), 214 * or leave it / mark it as VCACHED. 215 * 216 * This routine is only valid if the vnode is already either VFREE or 217 * VCACHED, or if it can become VFREE or VCACHED via vnode_terminate(). 218 * 219 * WARNING! This functions is typically called with v_spinlock held. 220 * 221 * MPSAFE 222 */ 223 static __inline boolean_t 224 vshouldfree(struct vnode *vp) 225 { 226 return (vp->v_auxrefs == 0 && 227 (vp->v_object == NULL || vp->v_object->resident_page_count == 0)); 228 } 229 230 /* 231 * Add a ref to an active vnode. This function should never be called 232 * with an inactive vnode (use vget() instead). 233 * 234 * MPSAFE 235 */ 236 void 237 vref(struct vnode *vp) 238 { 239 KKASSERT(vp->v_sysref.refcnt > 0 && 240 (vp->v_flag & (VFREE|VINACTIVE)) == 0); 241 sysref_get(&vp->v_sysref); 242 } 243 244 /* 245 * Release a ref on an active or inactive vnode. The sysref termination 246 * function will be called when the active last active reference is released, 247 * and the vnode is returned to the objcache when the last inactive 248 * reference is released. 249 */ 250 void 251 vrele(struct vnode *vp) 252 { 253 sysref_put(&vp->v_sysref); 254 } 255 256 /* 257 * Add an auxiliary data structure reference to the vnode. Auxiliary 258 * references do not change the state of the vnode or prevent them 259 * from being deactivated, reclaimed, or placed on the free list. 260 * 261 * An auxiliary reference DOES prevent the vnode from being destroyed, 262 * allowing you to vx_lock() it, test state, etc. 263 * 264 * An auxiliary reference DOES NOT move a vnode out of the VFREE state 265 * once it has entered it. 266 * 267 * MPSAFE 268 */ 269 void 270 vhold(struct vnode *vp) 271 { 272 KKASSERT(vp->v_sysref.refcnt != 0); 273 atomic_add_int(&vp->v_auxrefs, 1); 274 } 275 276 /* 277 * Remove an auxiliary reference from the vnode. 278 * 279 * vdrop needs to check for a VCACHE->VFREE transition to catch cases 280 * where a vnode is held past its reclamation. 281 * 282 * MPSAFE 283 */ 284 void 285 vdrop(struct vnode *vp) 286 { 287 KKASSERT(vp->v_sysref.refcnt != 0 && vp->v_auxrefs > 0); 288 spin_lock_wr(&vp->v_spinlock); 289 atomic_subtract_int(&vp->v_auxrefs, 1); 290 if ((vp->v_flag & VCACHED) && vshouldfree(vp)) { 291 _vclrflags(vp, VCACHED); 292 __vfree(vp); 293 } 294 spin_unlock_wr(&vp->v_spinlock); 295 } 296 297 /* 298 * This function is called when the last active reference on the vnode 299 * is released, typically via vrele(). SYSREF will give the vnode a 300 * negative ref count, indicating that it is undergoing termination or 301 * is being set aside for the cache, and one final sysref_put() is 302 * required to actually return it to the memory subsystem. 303 * 304 * However, because vnodes may have auxiliary structural references via 305 * v_auxrefs, we must interlock auxiliary references against termination 306 * via the VX lock mechanism. It is possible for a vnode to be reactivated 307 * while we were blocked on the lock. 308 * 309 * MPSAFE 310 */ 311 void 312 vnode_terminate(struct vnode *vp) 313 { 314 vx_lock(vp); 315 if (sysref_isinactive(&vp->v_sysref)) { 316 /* 317 * Deactivate the vnode by marking it VFREE or VCACHED. 318 * The vnode can be reactivated from either state until 319 * reclaimed. These states inherit the 'last' sysref on the 320 * vnode. 321 * 322 * NOTE: There may be additional inactive references from 323 * other entities blocking on the VX lock while we hold it, 324 * but this does not prevent us from changing the vnode's 325 * state. 326 * 327 * NOTE: The vnode could already be marked inactive. XXX 328 * how? 329 * 330 * NOTE: v_mount may be NULL due to assignment to 331 * dead_vnode_vops 332 * 333 * NOTE: The vnode may be marked inactive with dirty buffers 334 * or dirty pages in its cached VM object still present. 335 */ 336 if ((vp->v_flag & VINACTIVE) == 0) { 337 _vsetflags(vp, VINACTIVE); 338 if (vp->v_mount) 339 VOP_INACTIVE(vp); 340 } 341 spin_lock_wr(&vp->v_spinlock); 342 KKASSERT((vp->v_flag & (VFREE|VCACHED)) == 0); 343 if (vshouldfree(vp)) 344 __vfree(vp); 345 else 346 _vsetflags(vp, VCACHED); /* inactive but not yet free*/ 347 spin_unlock_wr(&vp->v_spinlock); 348 vx_unlock(vp); 349 } else { 350 /* 351 * Someone reactivated the vnode while were blocked on the 352 * VX lock. Release the VX lock and release the (now active) 353 * last reference which is no longer last. 354 */ 355 vx_unlock(vp); 356 vrele(vp); 357 } 358 } 359 360 /* 361 * Physical vnode constructor / destructor. These are only executed on 362 * the backend of the objcache. They are NOT executed on every vnode 363 * allocation or deallocation. 364 * 365 * MPSAFE 366 */ 367 boolean_t 368 vnode_ctor(void *obj, void *private, int ocflags) 369 { 370 struct vnode *vp = obj; 371 372 lwkt_token_init(&vp->v_token); 373 lockinit(&vp->v_lock, "vnode", 0, 0); 374 ccms_dataspace_init(&vp->v_ccms); 375 TAILQ_INIT(&vp->v_namecache); 376 RB_INIT(&vp->v_rbclean_tree); 377 RB_INIT(&vp->v_rbdirty_tree); 378 RB_INIT(&vp->v_rbhash_tree); 379 return(TRUE); 380 } 381 382 /* 383 * MPSAFE 384 */ 385 void 386 vnode_dtor(void *obj, void *private) 387 { 388 struct vnode *vp = obj; 389 390 ccms_dataspace_destroy(&vp->v_ccms); 391 } 392 393 /**************************************************************** 394 * VX LOCKING FUNCTIONS * 395 **************************************************************** 396 * 397 * These functions lock vnodes for reclamation and deactivation related 398 * activities. The caller must already be holding some sort of reference 399 * on the vnode. 400 * 401 * MPSAFE 402 */ 403 void 404 vx_lock(struct vnode *vp) 405 { 406 lockmgr(&vp->v_lock, LK_EXCLUSIVE); 407 } 408 409 static int 410 vx_lock_nonblock(struct vnode *vp) 411 { 412 return(lockmgr(&vp->v_lock, LK_EXCLUSIVE | LK_NOWAIT)); 413 } 414 415 void 416 vx_unlock(struct vnode *vp) 417 { 418 lockmgr(&vp->v_lock, LK_RELEASE); 419 } 420 421 /**************************************************************** 422 * VNODE ACQUISITION FUNCTIONS * 423 **************************************************************** 424 * 425 * These functions must be used when accessing a vnode via an auxiliary 426 * reference such as the namecache or free list, or when you wish to 427 * do a combo ref+lock sequence. 428 * 429 * These functions are MANDATORY for any code chain accessing a vnode 430 * whos activation state is not known. 431 * 432 * vget() can be called with LK_NOWAIT and will return EBUSY if the 433 * lock cannot be immediately acquired. 434 * 435 * vget()/vput() are used when reactivation is desired. 436 * 437 * vx_get() and vx_put() are used when reactivation is not desired. 438 */ 439 int 440 vget(struct vnode *vp, int flags) 441 { 442 int error; 443 444 /* 445 * A lock type must be passed 446 */ 447 if ((flags & LK_TYPE_MASK) == 0) { 448 panic("vget() called with no lock specified!"); 449 /* NOT REACHED */ 450 } 451 452 /* 453 * Reference the structure and then acquire the lock. 0->1 454 * transitions and refs during termination are allowed here so 455 * call sysref directly. 456 * 457 * NOTE: The requested lock might be a shared lock and does 458 * not protect our access to the refcnt or other fields. 459 */ 460 sysref_get(&vp->v_sysref); 461 if ((error = vn_lock(vp, flags)) != 0) { 462 /* 463 * The lock failed, undo and return an error. 464 */ 465 sysref_put(&vp->v_sysref); 466 } else if (vp->v_flag & VRECLAIMED) { 467 /* 468 * The node is being reclaimed and cannot be reactivated 469 * any more, undo and return ENOENT. 470 */ 471 vn_unlock(vp); 472 vrele(vp); 473 error = ENOENT; 474 } else { 475 /* 476 * If the vnode is marked VFREE or VCACHED it needs to be 477 * reactivated, otherwise it had better already be active. 478 * VINACTIVE must also be cleared. 479 * 480 * In the VFREE/VCACHED case we have to throw away the 481 * sysref that was earmarking those cases and preventing 482 * the vnode from being destroyed. Our sysref is still held. 483 * 484 * The spinlock is our only real protection here. 485 */ 486 spin_lock_wr(&vp->v_spinlock); 487 if (vp->v_flag & VFREE) { 488 __vbusy(vp); 489 sysref_activate(&vp->v_sysref); 490 spin_unlock_wr(&vp->v_spinlock); 491 sysref_put(&vp->v_sysref); 492 } else if (vp->v_flag & VCACHED) { 493 _vclrflags(vp, VCACHED); 494 sysref_activate(&vp->v_sysref); 495 spin_unlock_wr(&vp->v_spinlock); 496 sysref_put(&vp->v_sysref); 497 } else { 498 if (sysref_isinactive(&vp->v_sysref)) { 499 sysref_activate(&vp->v_sysref); 500 kprintf("Warning vp %p reactivation race\n", 501 vp); 502 } 503 spin_unlock_wr(&vp->v_spinlock); 504 } 505 _vclrflags(vp, VINACTIVE); 506 error = 0; 507 } 508 return(error); 509 } 510 511 /* 512 * MPSAFE 513 */ 514 void 515 vput(struct vnode *vp) 516 { 517 vn_unlock(vp); 518 vrele(vp); 519 } 520 521 /* 522 * XXX The vx_*() locks should use auxrefs, not the main reference counter. 523 * 524 * MPSAFE 525 */ 526 void 527 vx_get(struct vnode *vp) 528 { 529 sysref_get(&vp->v_sysref); 530 lockmgr(&vp->v_lock, LK_EXCLUSIVE); 531 } 532 533 /* 534 * MPSAFE 535 */ 536 int 537 vx_get_nonblock(struct vnode *vp) 538 { 539 int error; 540 541 sysref_get(&vp->v_sysref); 542 error = lockmgr(&vp->v_lock, LK_EXCLUSIVE | LK_NOWAIT); 543 if (error) 544 sysref_put(&vp->v_sysref); 545 return(error); 546 } 547 548 /* 549 * Relase a VX lock that also held a ref on the vnode. 550 * 551 * vx_put needs to check for a VCACHE->VFREE transition to catch the 552 * case where e.g. vnlru issues a vgone*(). 553 * 554 * MPSAFE 555 */ 556 void 557 vx_put(struct vnode *vp) 558 { 559 spin_lock_wr(&vp->v_spinlock); 560 if ((vp->v_flag & VCACHED) && vshouldfree(vp)) { 561 _vclrflags(vp, VCACHED); 562 __vfree(vp); 563 } 564 spin_unlock_wr(&vp->v_spinlock); 565 lockmgr(&vp->v_lock, LK_RELEASE); 566 sysref_put(&vp->v_sysref); 567 } 568 569 /* 570 * Try to reuse a vnode from the free list. NOTE: The returned vnode 571 * is not completely initialized. 572 * 573 * MPSAFE 574 */ 575 static 576 struct vnode * 577 allocfreevnode(void) 578 { 579 struct vnode *vp; 580 int count; 581 582 for (count = 0; count < freevnodes; count++) { 583 /* 584 * Note that regardless of how we block in this loop, 585 * we only get here if freevnodes != 0 so there 586 * had better be something on the list. 587 * 588 * Try to lock the first vnode on the free list. 589 * Cycle if we can't. 590 * 591 * XXX NOT MP SAFE 592 */ 593 spin_lock_wr(&vfs_spin); 594 vp = TAILQ_FIRST(&vnode_free_list); 595 if (vp == &vnode_free_mid) 596 vp = TAILQ_NEXT(vp, v_freelist); 597 if (vx_lock_nonblock(vp)) { 598 KKASSERT(vp->v_flag & VFREE); 599 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist); 600 TAILQ_INSERT_TAIL(&vnode_free_list, 601 vp, v_freelist); 602 spin_unlock_wr(&vfs_spin); 603 continue; 604 } 605 spin_unlock_wr(&vfs_spin); 606 #ifdef TRACKVNODE 607 if ((ulong)vp == trackvnode) 608 kprintf("allocfreevnode %p %08x\n", vp, vp->v_flag); 609 #endif 610 /* 611 * Do not reclaim a vnode with auxillary refs. This includes 612 * namecache refs due to a related ncp being locked or having 613 * children. 614 */ 615 if (vp->v_auxrefs) { 616 __vfreetail(vp); 617 vx_unlock(vp); 618 continue; 619 } 620 621 /* 622 * With the vnode locked we can safely remove it 623 * from the free list. We inherit the reference 624 * that was previously associated with the vnode 625 * being on the free list. 626 */ 627 KKASSERT((vp->v_flag & (VFREE|VINACTIVE)) == 628 (VFREE|VINACTIVE)); 629 KKASSERT(sysref_isinactive(&vp->v_sysref)); 630 __vbusy(vp); 631 632 /* 633 * Holding the VX lock on an inactive vnode prevents it 634 * from being reactivated or reused. New namecache 635 * associations can only be made using active vnodes. 636 * 637 * Another thread may be blocked on our vnode lock while 638 * holding a namecache lock. We can only reuse this vnode 639 * if we can clear all namecache associations without 640 * blocking. 641 */ 642 if ((vp->v_flag & VRECLAIMED) == 0) { 643 if (cache_inval_vp_nonblock(vp)) { 644 __vfreetail(vp); 645 vx_unlock(vp); 646 continue; 647 } 648 vgone_vxlocked(vp); 649 /* vnode is still VX locked */ 650 } 651 652 /* 653 * We can reuse the vnode if no primary or auxiliary 654 * references remain other then ours, else put it 655 * back on the free list and keep looking. 656 * 657 * Either the free list inherits the last reference 658 * or we fall through and sysref_activate() the last 659 * reference. 660 * 661 * Since the vnode is in a VRECLAIMED state, no new 662 * namecache associations could have been made. 663 */ 664 KKASSERT(TAILQ_EMPTY(&vp->v_namecache)); 665 if (vp->v_auxrefs || 666 !sysref_islastdeactivation(&vp->v_sysref)) { 667 __vfreetail(vp); 668 vx_unlock(vp); 669 continue; 670 } 671 672 /* 673 * Return a VX locked vnode suitable for reuse. The caller 674 * inherits the sysref. 675 */ 676 return(vp); 677 } 678 return(NULL); 679 } 680 681 /* 682 * Obtain a new vnode from the freelist, allocating more if necessary. 683 * The returned vnode is VX locked & refd. 684 * 685 * All new vnodes set the VAGE flags. An open() of the vnode will 686 * decrement the (2-bit) flags. Vnodes which are opened several times 687 * are thus retained in the cache over vnodes which are merely stat()d. 688 * 689 * MPSAFE 690 */ 691 struct vnode * 692 allocvnode(int lktimeout, int lkflags) 693 { 694 struct vnode *vp; 695 696 /* 697 * Try to reuse vnodes if we hit the max. This situation only 698 * occurs in certain large-memory (2G+) situations. We cannot 699 * attempt to directly reclaim vnodes due to nasty recursion 700 * problems. 701 */ 702 while (numvnodes - freevnodes > desiredvnodes) 703 vnlru_proc_wait(); 704 705 /* 706 * Try to build up as many vnodes as we can before reallocating 707 * from the free list. A vnode on the free list simply means 708 * that it is inactive with no resident pages. It may or may not 709 * have been reclaimed and could have valuable information associated 710 * with it that we shouldn't throw away unless we really need to. 711 * 712 * HAMMER NOTE: Re-establishing a vnode is a fairly expensive 713 * operation for HAMMER but this should benefit UFS as well. 714 */ 715 if (freevnodes >= wantfreevnodes && numvnodes >= desiredvnodes) 716 vp = allocfreevnode(); 717 else 718 vp = NULL; 719 if (vp == NULL) { 720 vp = sysref_alloc(&vnode_sysref_class); 721 lockmgr(&vp->v_lock, LK_EXCLUSIVE); 722 numvnodes++; 723 } 724 725 /* 726 * We are using a managed sysref class, vnode fields are only 727 * zerod on initial allocation from the backing store, not 728 * on reallocation. Thus we have to clear these fields for both 729 * reallocation and reuse. 730 */ 731 #ifdef INVARIANTS 732 if (vp->v_data) 733 panic("cleaned vnode isn't"); 734 if (bio_track_active(&vp->v_track_read) || 735 bio_track_active(&vp->v_track_write)) { 736 panic("Clean vnode has pending I/O's"); 737 } 738 if (vp->v_flag & VONWORKLST) 739 panic("Clean vnode still pending on syncer worklist!"); 740 if (!RB_EMPTY(&vp->v_rbdirty_tree)) 741 panic("Clean vnode still has dirty buffers!"); 742 if (!RB_EMPTY(&vp->v_rbclean_tree)) 743 panic("Clean vnode still has clean buffers!"); 744 if (!RB_EMPTY(&vp->v_rbhash_tree)) 745 panic("Clean vnode still on hash tree!"); 746 KKASSERT(vp->v_mount == NULL); 747 #endif 748 vp->v_flag = VAGE0 | VAGE1; 749 vp->v_lastw = 0; 750 vp->v_lasta = 0; 751 vp->v_cstart = 0; 752 vp->v_clen = 0; 753 vp->v_socket = 0; 754 vp->v_opencount = 0; 755 vp->v_writecount = 0; /* XXX */ 756 757 /* 758 * lktimeout only applies when LK_TIMELOCK is used, and only 759 * the pageout daemon uses it. The timeout may not be zero 760 * or the pageout daemon can deadlock in low-VM situations. 761 */ 762 if (lktimeout == 0) 763 lktimeout = hz / 10; 764 lockreinit(&vp->v_lock, "vnode", lktimeout, lkflags); 765 KKASSERT(TAILQ_EMPTY(&vp->v_namecache)); 766 /* exclusive lock still held */ 767 768 /* 769 * Note: sysref needs to be activated to convert -0x40000000 to +1. 770 * The -0x40000000 comes from the last ref on reuse, and from 771 * sysref_init() on allocate. 772 */ 773 sysref_activate(&vp->v_sysref); 774 vp->v_filesize = NOOFFSET; 775 vp->v_type = VNON; 776 vp->v_tag = 0; 777 vp->v_ops = NULL; 778 vp->v_data = NULL; 779 KKASSERT(vp->v_mount == NULL); 780 781 return (vp); 782 } 783 784 /* 785 * MPSAFE 786 */ 787 int 788 freesomevnodes(int n) 789 { 790 struct vnode *vp; 791 int count = 0; 792 793 while (n) { 794 --n; 795 if ((vp = allocfreevnode()) == NULL) 796 break; 797 vx_put(vp); 798 --numvnodes; 799 } 800 return(count); 801 } 802 803