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 * Copyright (c) 1989, 1993 35 * The Regents of the University of California. All rights reserved. 36 * (c) UNIX System Laboratories, Inc. 37 * All or some portions of this file are derived from material licensed 38 * to the University of California by American Telephone and Telegraph 39 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 40 * the permission of UNIX System Laboratories, Inc. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. 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. 57 * 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 68 * SUCH DAMAGE. 69 * 70 * $DragonFly: src/sys/kern/vfs_mount.c,v 1.25 2007/01/12 03:05:49 dillon Exp $ 71 */ 72 73 /* 74 * External virtual filesystem routines 75 */ 76 #include "opt_ddb.h" 77 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> 83 #include <sys/proc.h> 84 #include <sys/vnode.h> 85 #include <sys/buf.h> 86 #include <sys/eventhandler.h> 87 #include <sys/kthread.h> 88 #include <sys/sysctl.h> 89 90 #include <machine/limits.h> 91 92 #include <sys/buf2.h> 93 #include <sys/thread2.h> 94 95 #include <vm/vm.h> 96 #include <vm/vm_object.h> 97 98 struct mountscan_info { 99 TAILQ_ENTRY(mountscan_info) msi_entry; 100 int msi_how; 101 struct mount *msi_node; 102 }; 103 104 struct vmntvnodescan_info { 105 TAILQ_ENTRY(vmntvnodescan_info) entry; 106 struct vnode *vp; 107 }; 108 109 static int vnlru_nowhere = 0; 110 SYSCTL_INT(_debug, OID_AUTO, vnlru_nowhere, CTLFLAG_RD, 111 &vnlru_nowhere, 0, 112 "Number of times the vnlru process ran without success"); 113 114 115 static struct lwkt_token mntid_token; 116 117 /* note: mountlist exported to pstat */ 118 struct mntlist mountlist = TAILQ_HEAD_INITIALIZER(mountlist); 119 static TAILQ_HEAD(,mountscan_info) mountscan_list; 120 static struct lwkt_token mountlist_token; 121 static TAILQ_HEAD(,vmntvnodescan_info) mntvnodescan_list; 122 struct lwkt_token mntvnode_token; 123 124 /* 125 * Called from vfsinit() 126 */ 127 void 128 vfs_mount_init(void) 129 { 130 lwkt_token_init(&mountlist_token); 131 lwkt_token_init(&mntvnode_token); 132 lwkt_token_init(&mntid_token); 133 TAILQ_INIT(&mountscan_list); 134 TAILQ_INIT(&mntvnodescan_list); 135 } 136 137 /* 138 * Support function called with mntvnode_token held to remove a vnode 139 * from the mountlist. We must update any list scans which are in progress. 140 */ 141 static void 142 vremovevnodemnt(struct vnode *vp) 143 { 144 struct vmntvnodescan_info *info; 145 146 TAILQ_FOREACH(info, &mntvnodescan_list, entry) { 147 if (info->vp == vp) 148 info->vp = TAILQ_NEXT(vp, v_nmntvnodes); 149 } 150 TAILQ_REMOVE(&vp->v_mount->mnt_nvnodelist, vp, v_nmntvnodes); 151 } 152 153 /* 154 * Support function called with mntvnode_token held to move a vnode to 155 * the end of the list. 156 */ 157 static void 158 vmovevnodetoend(struct mount *mp, struct vnode *vp) 159 { 160 vremovevnodemnt(vp); 161 TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes); 162 } 163 164 165 /* 166 * Allocate a new vnode and associate it with a tag, mount point, and 167 * operations vector. 168 * 169 * A VX locked and refd vnode is returned. The caller should setup the 170 * remaining fields and vx_put() or, if he wishes to leave a vref, 171 * vx_unlock() the vnode. 172 */ 173 int 174 getnewvnode(enum vtagtype tag, struct mount *mp, 175 struct vnode **vpp, int lktimeout, int lkflags) 176 { 177 struct vnode *vp; 178 179 KKASSERT(mp != NULL); 180 181 vp = allocvnode(lktimeout, lkflags); 182 vp->v_tag = tag; 183 vp->v_data = NULL; 184 185 /* 186 * By default the vnode is assigned the mount point's normal 187 * operations vector. 188 */ 189 vp->v_ops = &mp->mnt_vn_use_ops; 190 191 /* 192 * Placing the vnode on the mount point's queue makes it visible. 193 * VNON prevents it from being messed with, however. 194 */ 195 insmntque(vp, mp); 196 197 /* 198 * A VX locked & refd vnode is returned. 199 */ 200 *vpp = vp; 201 return (0); 202 } 203 204 /* 205 * This function creates vnodes with special operations vectors. The 206 * mount point is optional. 207 * 208 * This routine is being phased out. 209 */ 210 int 211 getspecialvnode(enum vtagtype tag, struct mount *mp, 212 struct vop_ops **ops, 213 struct vnode **vpp, int lktimeout, int lkflags) 214 { 215 struct vnode *vp; 216 217 vp = allocvnode(lktimeout, lkflags); 218 vp->v_tag = tag; 219 vp->v_data = NULL; 220 vp->v_ops = ops; 221 222 /* 223 * Placing the vnode on the mount point's queue makes it visible. 224 * VNON prevents it from being messed with, however. 225 */ 226 insmntque(vp, mp); 227 228 /* 229 * A VX locked & refd vnode is returned. 230 */ 231 *vpp = vp; 232 return (0); 233 } 234 235 /* 236 * Interlock against an unmount, return 0 on success, non-zero on failure. 237 * 238 * The passed flag may be 0 or LK_NOWAIT and is only used if an unmount 239 * is in-progress. 240 * 241 * If no unmount is in-progress LK_NOWAIT is ignored. No other flag bits 242 * are used. A shared locked will be obtained and the filesystem will not 243 * be unmountable until the lock is released. 244 */ 245 int 246 vfs_busy(struct mount *mp, int flags) 247 { 248 int lkflags; 249 250 if (mp->mnt_kern_flag & MNTK_UNMOUNT) { 251 if (flags & LK_NOWAIT) 252 return (ENOENT); 253 /* XXX not MP safe */ 254 mp->mnt_kern_flag |= MNTK_MWAIT; 255 /* 256 * Since all busy locks are shared except the exclusive 257 * lock granted when unmounting, the only place that a 258 * wakeup needs to be done is at the release of the 259 * exclusive lock at the end of dounmount. 260 */ 261 tsleep((caddr_t)mp, 0, "vfs_busy", 0); 262 return (ENOENT); 263 } 264 lkflags = LK_SHARED; 265 if (lockmgr(&mp->mnt_lock, lkflags)) 266 panic("vfs_busy: unexpected lock failure"); 267 return (0); 268 } 269 270 /* 271 * Free a busy filesystem. 272 */ 273 void 274 vfs_unbusy(struct mount *mp) 275 { 276 lockmgr(&mp->mnt_lock, LK_RELEASE); 277 } 278 279 /* 280 * Lookup a filesystem type, and if found allocate and initialize 281 * a mount structure for it. 282 * 283 * Devname is usually updated by mount(8) after booting. 284 */ 285 int 286 vfs_rootmountalloc(char *fstypename, char *devname, struct mount **mpp) 287 { 288 struct vfsconf *vfsp; 289 struct mount *mp; 290 291 if (fstypename == NULL) 292 return (ENODEV); 293 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) { 294 if (!strcmp(vfsp->vfc_name, fstypename)) 295 break; 296 } 297 if (vfsp == NULL) 298 return (ENODEV); 299 mp = kmalloc(sizeof(struct mount), M_MOUNT, M_WAITOK); 300 bzero((char *)mp, (u_long)sizeof(struct mount)); 301 lockinit(&mp->mnt_lock, "vfslock", VLKTIMEOUT, 0); 302 vfs_busy(mp, LK_NOWAIT); 303 TAILQ_INIT(&mp->mnt_nvnodelist); 304 TAILQ_INIT(&mp->mnt_reservedvnlist); 305 TAILQ_INIT(&mp->mnt_jlist); 306 mp->mnt_nvnodelistsize = 0; 307 mp->mnt_vfc = vfsp; 308 mp->mnt_op = vfsp->vfc_vfsops; 309 mp->mnt_flag = MNT_RDONLY; 310 vfsp->vfc_refcount++; 311 mp->mnt_iosize_max = DFLTPHYS; 312 mp->mnt_stat.f_type = vfsp->vfc_typenum; 313 mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK; 314 strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN); 315 copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0); 316 *mpp = mp; 317 return (0); 318 } 319 320 /* 321 * Lookup a mount point by filesystem identifier. 322 */ 323 struct mount * 324 vfs_getvfs(fsid_t *fsid) 325 { 326 struct mount *mp; 327 lwkt_tokref ilock; 328 329 lwkt_gettoken(&ilock, &mountlist_token); 330 TAILQ_FOREACH(mp, &mountlist, mnt_list) { 331 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] && 332 mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) { 333 break; 334 } 335 } 336 lwkt_reltoken(&ilock); 337 return (mp); 338 } 339 340 /* 341 * Get a new unique fsid. Try to make its val[0] unique, since this value 342 * will be used to create fake device numbers for stat(). Also try (but 343 * not so hard) make its val[0] unique mod 2^16, since some emulators only 344 * support 16-bit device numbers. We end up with unique val[0]'s for the 345 * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls. 346 * 347 * Keep in mind that several mounts may be running in parallel. Starting 348 * the search one past where the previous search terminated is both a 349 * micro-optimization and a defense against returning the same fsid to 350 * different mounts. 351 */ 352 void 353 vfs_getnewfsid(struct mount *mp) 354 { 355 static u_int16_t mntid_base; 356 lwkt_tokref ilock; 357 fsid_t tfsid; 358 int mtype; 359 360 lwkt_gettoken(&ilock, &mntid_token); 361 mtype = mp->mnt_vfc->vfc_typenum; 362 tfsid.val[1] = mtype; 363 mtype = (mtype & 0xFF) << 24; 364 for (;;) { 365 tfsid.val[0] = makeudev(255, 366 mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF)); 367 mntid_base++; 368 if (vfs_getvfs(&tfsid) == NULL) 369 break; 370 } 371 mp->mnt_stat.f_fsid.val[0] = tfsid.val[0]; 372 mp->mnt_stat.f_fsid.val[1] = tfsid.val[1]; 373 lwkt_reltoken(&ilock); 374 } 375 376 /* 377 * This routine is called when we have too many vnodes. It attempts 378 * to free <count> vnodes and will potentially free vnodes that still 379 * have VM backing store (VM backing store is typically the cause 380 * of a vnode blowout so we want to do this). Therefore, this operation 381 * is not considered cheap. 382 * 383 * A number of conditions may prevent a vnode from being reclaimed. 384 * the buffer cache may have references on the vnode, a directory 385 * vnode may still have references due to the namei cache representing 386 * underlying files, or the vnode may be in active use. It is not 387 * desireable to reuse such vnodes. These conditions may cause the 388 * number of vnodes to reach some minimum value regardless of what 389 * you set kern.maxvnodes to. Do not set kern.maxvnodes too low. 390 */ 391 392 /* 393 * This is a quick non-blocking check to determine if the vnode is a good 394 * candidate for being (eventually) vgone()'d. Returns 0 if the vnode is 395 * not a good candidate, 1 if it is. 396 * 397 * Note that a vnode can be marked VFREE without really being free, so 398 * we don't use the flag for any tests. 399 */ 400 static __inline int 401 vmightfree(struct vnode *vp, int page_count) 402 { 403 if (vp->v_flag & VRECLAIMED) 404 return (0); 405 #if 0 406 if ((vp->v_flag & VFREE) && TAILQ_EMPTY(&vp->v_namecache)) 407 return (0); 408 #endif 409 if (vp->v_usecount != 0) 410 return (0); 411 if (vp->v_object && vp->v_object->resident_page_count >= page_count) 412 return (0); 413 return (1); 414 } 415 416 /* 417 * The vnode was found to be possibly vgone()able and the caller has locked it 418 * (thus the usecount should be 1 now). Determine if the vnode is actually 419 * vgone()able, doing some cleanups in the process. Returns 1 if the vnode 420 * can be vgone()'d, 0 otherwise. 421 * 422 * Note that v_holdcnt may be non-zero because (A) this vnode is not a leaf 423 * in the namecache topology and (B) this vnode has buffer cache bufs. 424 * We cannot remove vnodes with non-leaf namecache associations. We do a 425 * tentitive leaf check prior to attempting to flush out any buffers but the 426 * 'real' test when all is said in done is that v_holdcnt must become 0 for 427 * the vnode to be freeable. 428 * 429 * We could theoretically just unconditionally flush when v_holdcnt != 0, 430 * but flushing data associated with non-leaf nodes (which are always 431 * directories), just throws it away for no benefit. It is the buffer 432 * cache's responsibility to choose buffers to recycle from the cached 433 * data point of view. 434 */ 435 static int 436 visleaf(struct vnode *vp) 437 { 438 struct namecache *ncp; 439 440 TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) { 441 if (!TAILQ_EMPTY(&ncp->nc_list)) 442 return(0); 443 } 444 return(1); 445 } 446 447 /* 448 * Try to clean up the vnode to the point where it can be vgone()'d, returning 449 * 0 if it cannot be vgone()'d (or already has been), 1 if it can. Unlike 450 * vmightfree() this routine may flush the vnode and block. Vnodes marked 451 * VFREE are still candidates for vgone()ing because they may hold namecache 452 * resources and could be blocking the namecache directory hierarchy (and 453 * related vnodes) from being freed. 454 */ 455 static int 456 vtrytomakegoneable(struct vnode *vp, int page_count) 457 { 458 if (vp->v_flag & VRECLAIMED) 459 return (0); 460 if (vp->v_usecount != 1) 461 return (0); 462 if (vp->v_object && vp->v_object->resident_page_count >= page_count) 463 return (0); 464 if (vp->v_holdcnt && visleaf(vp)) { 465 vinvalbuf(vp, V_SAVE, 0, 0); 466 #if 0 /* DEBUG */ 467 kprintf((vp->v_holdcnt ? "vrecycle: vp %p failed: %s\n" : 468 "vrecycle: vp %p succeeded: %s\n"), vp, 469 (TAILQ_FIRST(&vp->v_namecache) ? 470 TAILQ_FIRST(&vp->v_namecache)->nc_name : "?")); 471 #endif 472 } 473 return(vp->v_usecount == 1 && vp->v_holdcnt == 0); 474 } 475 476 /* 477 * Reclaim up to 1/10 of the vnodes associated with a mount point. Try 478 * to avoid vnodes which have lots of resident pages (we are trying to free 479 * vnodes, not memory). 480 * 481 * This routine is a callback from the mountlist scan. The mount point 482 * in question will be busied. 483 */ 484 static int 485 vlrureclaim(struct mount *mp, void *data) 486 { 487 struct vnode *vp; 488 lwkt_tokref ilock; 489 int done; 490 int trigger; 491 int usevnodes; 492 int count; 493 int trigger_mult = vnlru_nowhere; 494 495 /* 496 * Calculate the trigger point for the resident pages check. The 497 * minimum trigger value is approximately the number of pages in 498 * the system divded by the number of vnodes. However, due to 499 * various other system memory overheads unrelated to data caching 500 * it is a good idea to double the trigger (at least). 501 * 502 * trigger_mult starts at 0. If the recycler is having problems 503 * finding enough freeable vnodes it will increase trigger_mult. 504 * This should not happen in normal operation, even on machines with 505 * low amounts of memory, but extraordinary memory use by the system 506 * verses the amount of cached data can trigger it. 507 */ 508 usevnodes = desiredvnodes; 509 if (usevnodes <= 0) 510 usevnodes = 1; 511 trigger = vmstats.v_page_count * (trigger_mult + 2) / usevnodes; 512 513 done = 0; 514 lwkt_gettoken(&ilock, &mntvnode_token); 515 count = mp->mnt_nvnodelistsize / 10 + 1; 516 while (count && (vp = TAILQ_FIRST(&mp->mnt_nvnodelist)) != NULL) { 517 /* 518 * __VNODESCAN__ 519 * 520 * The VP will stick around while we hold mntvnode_token, 521 * at least until we block, so we can safely do an initial 522 * check, and then must check again after we lock the vnode. 523 */ 524 if (vp->v_type == VNON || /* XXX */ 525 vp->v_type == VBAD || /* XXX */ 526 !vmightfree(vp, trigger) /* critical path opt */ 527 ) { 528 vmovevnodetoend(mp, vp); 529 --count; 530 continue; 531 } 532 533 /* 534 * VX get the candidate vnode. If the VX get fails the 535 * vnode might still be on the mountlist. Our loop depends 536 * on us at least cycling the vnode to the end of the 537 * mountlist. 538 */ 539 if (vx_get_nonblock(vp) != 0) { 540 if (vp->v_mount == mp) 541 vmovevnodetoend(mp, vp); 542 --count; 543 continue; 544 } 545 546 /* 547 * Since we blocked locking the vp, make sure it is still 548 * a candidate for reclamation. That is, it has not already 549 * been reclaimed and only has our VX reference associated 550 * with it. 551 */ 552 if (vp->v_type == VNON || /* XXX */ 553 vp->v_type == VBAD || /* XXX */ 554 (vp->v_flag & VRECLAIMED) || 555 vp->v_mount != mp || 556 !vtrytomakegoneable(vp, trigger) /* critical path opt */ 557 ) { 558 if (vp->v_mount == mp) 559 vmovevnodetoend(mp, vp); 560 --count; 561 vx_put(vp); 562 continue; 563 } 564 565 /* 566 * All right, we are good, move the vp to the end of the 567 * mountlist and clean it out. The vget will have returned 568 * an error if the vnode was destroyed (VRECLAIMED set), so we 569 * do not have to check again. The vput() will move the 570 * vnode to the free list if the vgone() was successful. 571 */ 572 KKASSERT(vp->v_mount == mp); 573 vmovevnodetoend(mp, vp); 574 vgone(vp); 575 vx_put(vp); 576 ++done; 577 --count; 578 } 579 lwkt_reltoken(&ilock); 580 return (done); 581 } 582 583 /* 584 * Attempt to recycle vnodes in a context that is always safe to block. 585 * Calling vlrurecycle() from the bowels of file system code has some 586 * interesting deadlock problems. 587 */ 588 static struct thread *vnlruthread; 589 static int vnlruproc_sig; 590 591 void 592 vnlru_proc_wait(void) 593 { 594 if (vnlruproc_sig == 0) { 595 vnlruproc_sig = 1; /* avoid unnecessary wakeups */ 596 wakeup(vnlruthread); 597 } 598 tsleep(&vnlruproc_sig, 0, "vlruwk", hz); 599 } 600 601 static void 602 vnlru_proc(void) 603 { 604 struct thread *td = curthread; 605 int done; 606 607 EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td, 608 SHUTDOWN_PRI_FIRST); 609 610 crit_enter(); 611 for (;;) { 612 kproc_suspend_loop(); 613 if (numvnodes - freevnodes <= desiredvnodes * 9 / 10) { 614 vnlruproc_sig = 0; 615 wakeup(&vnlruproc_sig); 616 tsleep(td, 0, "vlruwt", hz); 617 continue; 618 } 619 cache_cleanneg(0); 620 done = mountlist_scan(vlrureclaim, NULL, MNTSCAN_FORWARD); 621 622 /* 623 * The vlrureclaim() call only processes 1/10 of the vnodes 624 * on each mount. If we couldn't find any repeat the loop 625 * at least enough times to cover all available vnodes before 626 * we start sleeping. Complain if the failure extends past 627 * 30 second, every 30 seconds. 628 */ 629 if (done == 0) { 630 ++vnlru_nowhere; 631 if (vnlru_nowhere % 10 == 0) 632 tsleep(td, 0, "vlrup", hz * 3); 633 if (vnlru_nowhere % 100 == 0) 634 kprintf("vnlru_proc: vnode recycler stopped working!\n"); 635 if (vnlru_nowhere == 1000) 636 vnlru_nowhere = 900; 637 } else { 638 vnlru_nowhere = 0; 639 } 640 } 641 crit_exit(); 642 } 643 644 /* 645 * MOUNTLIST FUNCTIONS 646 */ 647 648 /* 649 * mountlist_insert (MP SAFE) 650 * 651 * Add a new mount point to the mount list. 652 */ 653 void 654 mountlist_insert(struct mount *mp, int how) 655 { 656 lwkt_tokref ilock; 657 658 lwkt_gettoken(&ilock, &mountlist_token); 659 if (how == MNTINS_FIRST) 660 TAILQ_INSERT_HEAD(&mountlist, mp, mnt_list); 661 else 662 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list); 663 lwkt_reltoken(&ilock); 664 } 665 666 /* 667 * mountlist_interlock (MP SAFE) 668 * 669 * Execute the specified interlock function with the mountlist token 670 * held. The function will be called in a serialized fashion verses 671 * other functions called through this mechanism. 672 */ 673 int 674 mountlist_interlock(int (*callback)(struct mount *), struct mount *mp) 675 { 676 lwkt_tokref ilock; 677 int error; 678 679 lwkt_gettoken(&ilock, &mountlist_token); 680 error = callback(mp); 681 lwkt_reltoken(&ilock); 682 return (error); 683 } 684 685 /* 686 * mountlist_boot_getfirst (DURING BOOT ONLY) 687 * 688 * This function returns the first mount on the mountlist, which is 689 * expected to be the root mount. Since no interlocks are obtained 690 * this function is only safe to use during booting. 691 */ 692 693 struct mount * 694 mountlist_boot_getfirst(void) 695 { 696 return(TAILQ_FIRST(&mountlist)); 697 } 698 699 /* 700 * mountlist_remove (MP SAFE) 701 * 702 * Remove a node from the mountlist. If this node is the next scan node 703 * for any active mountlist scans, the active mountlist scan will be 704 * adjusted to skip the node, thus allowing removals during mountlist 705 * scans. 706 */ 707 void 708 mountlist_remove(struct mount *mp) 709 { 710 struct mountscan_info *msi; 711 lwkt_tokref ilock; 712 713 lwkt_gettoken(&ilock, &mountlist_token); 714 TAILQ_FOREACH(msi, &mountscan_list, msi_entry) { 715 if (msi->msi_node == mp) { 716 if (msi->msi_how & MNTSCAN_FORWARD) 717 msi->msi_node = TAILQ_NEXT(mp, mnt_list); 718 else 719 msi->msi_node = TAILQ_PREV(mp, mntlist, mnt_list); 720 } 721 } 722 TAILQ_REMOVE(&mountlist, mp, mnt_list); 723 lwkt_reltoken(&ilock); 724 } 725 726 /* 727 * mountlist_scan (MP SAFE) 728 * 729 * Safely scan the mount points on the mount list. Unless otherwise 730 * specified each mount point will be busied prior to the callback and 731 * unbusied afterwords. The callback may safely remove any mount point 732 * without interfering with the scan. If the current callback 733 * mount is removed the scanner will not attempt to unbusy it. 734 * 735 * If a mount node cannot be busied it is silently skipped. 736 * 737 * The callback return value is aggregated and a total is returned. A return 738 * value of < 0 is not aggregated and will terminate the scan. 739 * 740 * MNTSCAN_FORWARD - the mountlist is scanned in the forward direction 741 * MNTSCAN_REVERSE - the mountlist is scanned in reverse 742 * MNTSCAN_NOBUSY - the scanner will make the callback without busying 743 * the mount node. 744 */ 745 int 746 mountlist_scan(int (*callback)(struct mount *, void *), void *data, int how) 747 { 748 struct mountscan_info info; 749 lwkt_tokref ilock; 750 struct mount *mp; 751 thread_t td; 752 int count; 753 int res; 754 755 lwkt_gettoken(&ilock, &mountlist_token); 756 757 info.msi_how = how; 758 info.msi_node = NULL; /* paranoia */ 759 TAILQ_INSERT_TAIL(&mountscan_list, &info, msi_entry); 760 761 res = 0; 762 td = curthread; 763 764 if (how & MNTSCAN_FORWARD) { 765 info.msi_node = TAILQ_FIRST(&mountlist); 766 while ((mp = info.msi_node) != NULL) { 767 if (how & MNTSCAN_NOBUSY) { 768 count = callback(mp, data); 769 } else if (vfs_busy(mp, LK_NOWAIT) == 0) { 770 count = callback(mp, data); 771 if (mp == info.msi_node) 772 vfs_unbusy(mp); 773 } else { 774 count = 0; 775 } 776 if (count < 0) 777 break; 778 res += count; 779 if (mp == info.msi_node) 780 info.msi_node = TAILQ_NEXT(mp, mnt_list); 781 } 782 } else if (how & MNTSCAN_REVERSE) { 783 info.msi_node = TAILQ_LAST(&mountlist, mntlist); 784 while ((mp = info.msi_node) != NULL) { 785 if (how & MNTSCAN_NOBUSY) { 786 count = callback(mp, data); 787 } else if (vfs_busy(mp, LK_NOWAIT) == 0) { 788 count = callback(mp, data); 789 if (mp == info.msi_node) 790 vfs_unbusy(mp); 791 } else { 792 count = 0; 793 } 794 if (count < 0) 795 break; 796 res += count; 797 if (mp == info.msi_node) 798 info.msi_node = TAILQ_PREV(mp, mntlist, mnt_list); 799 } 800 } 801 TAILQ_REMOVE(&mountscan_list, &info, msi_entry); 802 lwkt_reltoken(&ilock); 803 return(res); 804 } 805 806 /* 807 * MOUNT RELATED VNODE FUNCTIONS 808 */ 809 810 static struct kproc_desc vnlru_kp = { 811 "vnlru", 812 vnlru_proc, 813 &vnlruthread 814 }; 815 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp) 816 817 /* 818 * Move a vnode from one mount queue to another. 819 */ 820 void 821 insmntque(struct vnode *vp, struct mount *mp) 822 { 823 lwkt_tokref ilock; 824 825 lwkt_gettoken(&ilock, &mntvnode_token); 826 /* 827 * Delete from old mount point vnode list, if on one. 828 */ 829 if (vp->v_mount != NULL) { 830 KASSERT(vp->v_mount->mnt_nvnodelistsize > 0, 831 ("bad mount point vnode list size")); 832 vremovevnodemnt(vp); 833 vp->v_mount->mnt_nvnodelistsize--; 834 } 835 /* 836 * Insert into list of vnodes for the new mount point, if available. 837 */ 838 if ((vp->v_mount = mp) == NULL) { 839 lwkt_reltoken(&ilock); 840 return; 841 } 842 TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes); 843 mp->mnt_nvnodelistsize++; 844 lwkt_reltoken(&ilock); 845 } 846 847 848 /* 849 * Scan the vnodes under a mount point and issue appropriate callbacks. 850 * 851 * The fastfunc() callback is called with just the mountlist token held 852 * (no vnode lock). It may not block and the vnode may be undergoing 853 * modifications while the caller is processing it. The vnode will 854 * not be entirely destroyed, however, due to the fact that the mountlist 855 * token is held. A return value < 0 skips to the next vnode without calling 856 * the slowfunc(), a return value > 0 terminates the loop. 857 * 858 * The slowfunc() callback is called after the vnode has been successfully 859 * locked based on passed flags. The vnode is skipped if it gets rearranged 860 * or destroyed while blocking on the lock. A non-zero return value from 861 * the slow function terminates the loop. The slow function is allowed to 862 * arbitrarily block. The scanning code guarentees consistency of operation 863 * even if the slow function deletes or moves the node, or blocks and some 864 * other thread deletes or moves the node. 865 */ 866 int 867 vmntvnodescan( 868 struct mount *mp, 869 int flags, 870 int (*fastfunc)(struct mount *mp, struct vnode *vp, void *data), 871 int (*slowfunc)(struct mount *mp, struct vnode *vp, void *data), 872 void *data 873 ) { 874 struct vmntvnodescan_info info; 875 lwkt_tokref ilock; 876 struct vnode *vp; 877 int r = 0; 878 int maxcount = 1000000; 879 880 lwkt_gettoken(&ilock, &mntvnode_token); 881 882 info.vp = TAILQ_FIRST(&mp->mnt_nvnodelist); 883 TAILQ_INSERT_TAIL(&mntvnodescan_list, &info, entry); 884 while ((vp = info.vp) != NULL) { 885 if (--maxcount == 0) 886 panic("maxcount reached during vmntvnodescan"); 887 888 if (vp->v_type == VNON) /* visible but not ready */ 889 goto next; 890 KKASSERT(vp->v_mount == mp); 891 892 /* 893 * Quick test. A negative return continues the loop without 894 * calling the slow test. 0 continues onto the slow test. 895 * A positive number aborts the loop. 896 */ 897 if (fastfunc) { 898 if ((r = fastfunc(mp, vp, data)) < 0) 899 goto next; 900 if (r) 901 break; 902 } 903 904 /* 905 * Get a vxlock on the vnode, retry if it has moved or isn't 906 * in the mountlist where we expect it. 907 */ 908 if (slowfunc) { 909 int error; 910 911 switch(flags) { 912 case VMSC_GETVP: 913 error = vget(vp, LK_EXCLUSIVE); 914 break; 915 case VMSC_GETVP|VMSC_NOWAIT: 916 error = vget(vp, LK_EXCLUSIVE|LK_NOWAIT); 917 break; 918 case VMSC_GETVX: 919 vx_get(vp); 920 error = 0; 921 break; 922 default: 923 error = 0; 924 break; 925 } 926 if (error) 927 goto next; 928 /* 929 * Do not call the slow function if the vnode is 930 * invalid or if it was ripped out from under us 931 * while we (potentially) blocked. 932 */ 933 if (info.vp == vp && vp->v_type != VNON) 934 r = slowfunc(mp, vp, data); 935 936 /* 937 * Cleanup 938 */ 939 switch(flags) { 940 case VMSC_GETVP: 941 case VMSC_GETVP|VMSC_NOWAIT: 942 vput(vp); 943 break; 944 case VMSC_GETVX: 945 vx_put(vp); 946 break; 947 default: 948 break; 949 } 950 if (r != 0) 951 break; 952 } 953 954 /* 955 * Iterate. If the vnode was ripped out from under us 956 * info.vp will already point to the next vnode, otherwise 957 * we have to obtain the next valid vnode ourselves. 958 */ 959 next: 960 if (info.vp == vp) 961 info.vp = TAILQ_NEXT(vp, v_nmntvnodes); 962 } 963 TAILQ_REMOVE(&mntvnodescan_list, &info, entry); 964 lwkt_reltoken(&ilock); 965 return(r); 966 } 967 968 /* 969 * Remove any vnodes in the vnode table belonging to mount point mp. 970 * 971 * If FORCECLOSE is not specified, there should not be any active ones, 972 * return error if any are found (nb: this is a user error, not a 973 * system error). If FORCECLOSE is specified, detach any active vnodes 974 * that are found. 975 * 976 * If WRITECLOSE is set, only flush out regular file vnodes open for 977 * writing. 978 * 979 * SKIPSYSTEM causes any vnodes marked VSYSTEM to be skipped. 980 * 981 * `rootrefs' specifies the base reference count for the root vnode 982 * of this filesystem. The root vnode is considered busy if its 983 * v_usecount exceeds this value. On a successful return, vflush() 984 * will call vrele() on the root vnode exactly rootrefs times. 985 * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must 986 * be zero. 987 */ 988 #ifdef DIAGNOSTIC 989 static int busyprt = 0; /* print out busy vnodes */ 990 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, ""); 991 #endif 992 993 static int vflush_scan(struct mount *mp, struct vnode *vp, void *data); 994 995 struct vflush_info { 996 int flags; 997 int busy; 998 thread_t td; 999 }; 1000 1001 int 1002 vflush(struct mount *mp, int rootrefs, int flags) 1003 { 1004 struct thread *td = curthread; /* XXX */ 1005 struct vnode *rootvp = NULL; 1006 int error; 1007 struct vflush_info vflush_info; 1008 1009 if (rootrefs > 0) { 1010 KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0, 1011 ("vflush: bad args")); 1012 /* 1013 * Get the filesystem root vnode. We can vput() it 1014 * immediately, since with rootrefs > 0, it won't go away. 1015 */ 1016 if ((error = VFS_ROOT(mp, &rootvp)) != 0) 1017 return (error); 1018 vput(rootvp); 1019 } 1020 1021 vflush_info.busy = 0; 1022 vflush_info.flags = flags; 1023 vflush_info.td = td; 1024 vmntvnodescan(mp, VMSC_GETVX, NULL, vflush_scan, &vflush_info); 1025 1026 if (rootrefs > 0 && (flags & FORCECLOSE) == 0) { 1027 /* 1028 * If just the root vnode is busy, and if its refcount 1029 * is equal to `rootrefs', then go ahead and kill it. 1030 */ 1031 KASSERT(vflush_info.busy > 0, ("vflush: not busy")); 1032 KASSERT(rootvp->v_usecount >= rootrefs, ("vflush: rootrefs")); 1033 if (vflush_info.busy == 1 && rootvp->v_usecount == rootrefs) { 1034 vx_lock(rootvp); 1035 vgone(rootvp); 1036 vx_unlock(rootvp); 1037 vflush_info.busy = 0; 1038 } 1039 } 1040 if (vflush_info.busy) 1041 return (EBUSY); 1042 for (; rootrefs > 0; rootrefs--) 1043 vrele(rootvp); 1044 return (0); 1045 } 1046 1047 /* 1048 * The scan callback is made with an VX locked vnode. 1049 */ 1050 static int 1051 vflush_scan(struct mount *mp, struct vnode *vp, void *data) 1052 { 1053 struct vflush_info *info = data; 1054 struct vattr vattr; 1055 1056 /* 1057 * Skip over a vnodes marked VSYSTEM. 1058 */ 1059 if ((info->flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) { 1060 return(0); 1061 } 1062 1063 /* 1064 * If WRITECLOSE is set, flush out unlinked but still open 1065 * files (even if open only for reading) and regular file 1066 * vnodes open for writing. 1067 */ 1068 if ((info->flags & WRITECLOSE) && 1069 (vp->v_type == VNON || 1070 (VOP_GETATTR(vp, &vattr) == 0 && 1071 vattr.va_nlink > 0)) && 1072 (vp->v_writecount == 0 || vp->v_type != VREG)) { 1073 return(0); 1074 } 1075 1076 /* 1077 * With v_usecount == 0, all we need to do is clear out the 1078 * vnode data structures and we are done. 1079 */ 1080 if (vp->v_usecount == 1) { 1081 vgone(vp); 1082 return(0); 1083 } 1084 1085 /* 1086 * If FORCECLOSE is set, forcibly close the vnode. For block 1087 * or character devices, revert to an anonymous device. For 1088 * all other files, just kill them. 1089 */ 1090 if (info->flags & FORCECLOSE) { 1091 if (vp->v_type != VBLK && vp->v_type != VCHR) { 1092 vgone(vp); 1093 } else { 1094 spin_lock_wr(&vp->v_spinlock); 1095 vclean_interlocked(vp, 0); 1096 /* spinlock unlocked */ 1097 vp->v_ops = &spec_vnode_vops_p; 1098 insmntque(vp, NULL); 1099 } 1100 return(0); 1101 } 1102 #ifdef DIAGNOSTIC 1103 if (busyprt) 1104 vprint("vflush: busy vnode", vp); 1105 #endif 1106 ++info->busy; 1107 return(0); 1108 } 1109 1110