sys/kern/vfs_mount.c

   1 /*
   2  * Copyright (c) 2004,2013 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. Neither the name of the University nor the names of its contributors
  51  *    may be used to endorse or promote products derived from this software
  52  *    without specific prior written permission.
  53  *
  54  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  55  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64  * SUCH DAMAGE.
  65  */
  66
  67 /*
  68  * External virtual filesystem routines
  69  */
  70
  71 #include <sys/param.h>
  72 #include <sys/systm.h>
  73 #include <sys/kernel.h>
  74 #include <sys/malloc.h>
  75 #include <sys/mount.h>
  76 #include <sys/proc.h>
  77 #include <sys/vnode.h>
  78 #include <sys/buf.h>
  79 #include <sys/eventhandler.h>
  80 #include <sys/kthread.h>
  81 #include <sys/sysctl.h>
  82
  83 #include <machine/limits.h>
  84
  85 #include <sys/buf2.h>
  86 #include <sys/thread2.h>
  87 #include <sys/sysref2.h>
  88
  89 #include <vm/vm.h>
  90 #include <vm/vm_object.h>
  91
  92 struct mountscan_info {
  93         TAILQ_ENTRY(mountscan_info) msi_entry;
  94         int msi_how;
  95         struct mount *msi_node;
  96 };
  97
  98 struct vmntvnodescan_info {
  99         TAILQ_ENTRY(vmntvnodescan_info) entry;
 100         struct vnode *vp;
 101 };
 102
 103 struct vnlru_info {
 104         int     pass;
 105 };
 106
 107 static int vnlru_nowhere = 0;
 108 SYSCTL_INT(_debug, OID_AUTO, vnlru_nowhere, CTLFLAG_RD,
 109             &vnlru_nowhere, 0,
 110             "Number of times the vnlru process ran without success");
 111
 112
 113 static struct lwkt_token mntid_token;
 114 static struct mount dummymount;
 115
 116 /* note: mountlist exported to pstat */
 117 struct mntlist mountlist = TAILQ_HEAD_INITIALIZER(mountlist);
 118 static TAILQ_HEAD(,mountscan_info) mountscan_list;
 119 static struct lwkt_token mountlist_token;
 120
 121 static TAILQ_HEAD(,bio_ops) bio_ops_list = TAILQ_HEAD_INITIALIZER(bio_ops_list);
 122
 123 /*
 124  * Called from vfsinit()
 125  */
 126 void
 127 vfs_mount_init(void)
 128 {
 129         lwkt_token_init(&mountlist_token, "mntlist");
 130         lwkt_token_init(&mntid_token, "mntid");
 131         TAILQ_INIT(&mountscan_list);
 132         mount_init(&dummymount);
 133         dummymount.mnt_flag |= MNT_RDONLY;
 134         dummymount.mnt_kern_flag |= MNTK_ALL_MPSAFE;
 135 }
 136
 137 /*
 138  * Support function called to remove a vnode from the mountlist and
 139  * deal with side effects for scans in progress.
 140  *
 141  * Target mnt_token is held on call.
 142  */
 143 static void
 144 vremovevnodemnt(struct vnode *vp)
 145 {
 146         struct vmntvnodescan_info *info;
 147         struct mount *mp = vp->v_mount;
 148
 149         TAILQ_FOREACH(info, &mp->mnt_vnodescan_list, entry) {
 150                 if (info->vp == vp)
 151                         info->vp = TAILQ_NEXT(vp, v_nmntvnodes);
 152         }
 153         TAILQ_REMOVE(&vp->v_mount->mnt_nvnodelist, vp, v_nmntvnodes);
 154 }
 155
 156 /*
 157  * Allocate a new vnode and associate it with a tag, mount point, and
 158  * operations vector.
 159  *
 160  * A VX locked and refd vnode is returned.  The caller should setup the
 161  * remaining fields and vx_put() or, if he wishes to leave a vref,
 162  * vx_unlock() the vnode.
 163  */
 164 int
 165 getnewvnode(enum vtagtype tag, struct mount *mp,
 166                 struct vnode **vpp, int lktimeout, int lkflags)
 167 {
 168         struct vnode *vp;
 169
 170         KKASSERT(mp != NULL);
 171
 172         vp = allocvnode(lktimeout, lkflags);
 173         vp->v_tag = tag;
 174         vp->v_data = NULL;
 175
 176         /*
 177          * By default the vnode is assigned the mount point's normal
 178          * operations vector.
 179          */
 180         vp->v_ops = &mp->mnt_vn_use_ops;
 181         vp->v_pbuf_count = nswbuf_kva / NSWBUF_SPLIT;
 182
 183         /*
 184          * Placing the vnode on the mount point's queue makes it visible.
 185          * VNON prevents it from being messed with, however.
 186          */
 187         insmntque(vp, mp);
 188
 189         /*
 190          * A VX locked & refd vnode is returned.
 191          */
 192         *vpp = vp;
 193         return (0);
 194 }
 195
 196 /*
 197  * This function creates vnodes with special operations vectors.  The
 198  * mount point is optional.
 199  *
 200  * This routine is being phased out but is still used by vfs_conf to
 201  * create vnodes for devices prior to the root mount (with mp == NULL).
 202  */
 203 int
 204 getspecialvnode(enum vtagtype tag, struct mount *mp,
 205                 struct vop_ops **ops,
 206                 struct vnode **vpp, int lktimeout, int lkflags)
 207 {
 208         struct vnode *vp;
 209
 210         vp = allocvnode(lktimeout, lkflags);
 211         vp->v_tag = tag;
 212         vp->v_data = NULL;
 213         vp->v_ops = ops;
 214
 215         if (mp == NULL)
 216                 mp = &dummymount;
 217
 218         /*
 219          * Placing the vnode on the mount point's queue makes it visible.
 220          * VNON prevents it from being messed with, however.
 221          */
 222         insmntque(vp, mp);
 223
 224         /*
 225          * A VX locked & refd vnode is returned.
 226          */
 227         *vpp = vp;
 228         return (0);
 229 }
 230
 231 /*
 232  * Interlock against an unmount, return 0 on success, non-zero on failure.
 233  *
 234  * The passed flag may be 0 or LK_NOWAIT and is only used if an unmount
 235  * is in-progress.
 236  *
 237  * If no unmount is in-progress LK_NOWAIT is ignored.  No other flag bits
 238  * are used.  A shared locked will be obtained and the filesystem will not
 239  * be unmountable until the lock is released.
 240  */
 241 int
 242 vfs_busy(struct mount *mp, int flags)
 243 {
 244         int lkflags;
 245
 246         atomic_add_int(&mp->mnt_refs, 1);
 247         lwkt_gettoken(&mp->mnt_token);
 248         if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
 249                 if (flags & LK_NOWAIT) {
 250                         lwkt_reltoken(&mp->mnt_token);
 251                         atomic_add_int(&mp->mnt_refs, -1);
 252                         return (ENOENT);
 253                 }
 254                 /* XXX not MP safe */
 255                 mp->mnt_kern_flag |= MNTK_MWAIT;
 256
 257                 /*
 258                  * Since all busy locks are shared except the exclusive
 259                  * lock granted when unmounting, the only place that a
 260                  * wakeup needs to be done is at the release of the
 261                  * exclusive lock at the end of dounmount.
 262                  *
 263                  * WARNING! mp can potentially go away once we release
 264                  *          our ref.
 265                  */
 266                 tsleep((caddr_t)mp, 0, "vfs_busy", 0);
 267                 lwkt_reltoken(&mp->mnt_token);
 268                 atomic_add_int(&mp->mnt_refs, -1);
 269                 return (ENOENT);
 270         }
 271         lkflags = LK_SHARED;
 272         if (lockmgr(&mp->mnt_lock, lkflags))
 273                 panic("vfs_busy: unexpected lock failure");
 274         lwkt_reltoken(&mp->mnt_token);
 275         return (0);
 276 }
 277
 278 /*
 279  * Free a busy filesystem.
 280  *
 281  * Once refs is decremented the mount point can potentially get ripped
 282  * out from under us, but we want to clean up our refs before unlocking
 283  * so do a hold/drop around the whole mess.
 284  *
 285  * This is not in the critical path (I hope).
 286  */
 287 void
 288 vfs_unbusy(struct mount *mp)
 289 {
 290         mount_hold(mp);
 291         atomic_add_int(&mp->mnt_refs, -1);
 292         lockmgr(&mp->mnt_lock, LK_RELEASE);
 293         mount_drop(mp);
 294 }
 295
 296 /*
 297  * Lookup a filesystem type, and if found allocate and initialize
 298  * a mount structure for it.
 299  *
 300  * Devname is usually updated by mount(8) after booting.
 301  */
 302 int
 303 vfs_rootmountalloc(char *fstypename, char *devname, struct mount **mpp)
 304 {
 305         struct vfsconf *vfsp;
 306         struct mount *mp;
 307
 308         if (fstypename == NULL)
 309                 return (ENODEV);
 310
 311         vfsp = vfsconf_find_by_name(fstypename);
 312         if (vfsp == NULL)
 313                 return (ENODEV);
 314         mp = kmalloc(sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO);
 315         mount_init(mp);
 316         lockinit(&mp->mnt_lock, "vfslock", VLKTIMEOUT, 0);
 317
 318         vfs_busy(mp, 0);
 319         mp->mnt_vfc = vfsp;
 320         mp->mnt_op = vfsp->vfc_vfsops;
 321         mp->mnt_pbuf_count = nswbuf_kva / NSWBUF_SPLIT;
 322         vfsp->vfc_refcount++;
 323         mp->mnt_stat.f_type = vfsp->vfc_typenum;
 324         mp->mnt_flag |= MNT_RDONLY;
 325         mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
 326         strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
 327         copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0);
 328
 329         /*
 330          * Pre-set MPSAFE flags for VFS_MOUNT() call.
 331          */
 332         if (vfsp->vfc_flags & VFCF_MPSAFE)
 333                 mp->mnt_kern_flag |= MNTK_ALL_MPSAFE;
 334
 335         *mpp = mp;
 336
 337         return (0);
 338 }
 339
 340 /*
 341  * Basic mount structure initialization
 342  */
 343 void
 344 mount_init(struct mount *mp)
 345 {
 346         lockinit(&mp->mnt_lock, "vfslock", hz*5, 0);
 347         lwkt_token_init(&mp->mnt_token, "permnt");
 348
 349         TAILQ_INIT(&mp->mnt_vnodescan_list);
 350         TAILQ_INIT(&mp->mnt_nvnodelist);
 351         TAILQ_INIT(&mp->mnt_reservedvnlist);
 352         TAILQ_INIT(&mp->mnt_jlist);
 353         mp->mnt_nvnodelistsize = 0;
 354         mp->mnt_flag = 0;
 355         mp->mnt_hold = 1;               /* hold for umount last drop */
 356         mp->mnt_iosize_max = MAXPHYS;
 357         vn_syncer_thr_create(mp);
 358 }
 359
 360 void
 361 mount_hold(struct mount *mp)
 362 {
 363         atomic_add_int(&mp->mnt_hold, 1);
 364 }
 365
 366 void
 367 mount_drop(struct mount *mp)
 368 {
 369         if (atomic_fetchadd_int(&mp->mnt_hold, -1) == 1) {
 370                 KKASSERT(mp->mnt_refs == 0);
 371                 kfree(mp, M_MOUNT);
 372         }
 373 }
 374
 375 /*
 376  * Lookup a mount point by filesystem identifier.
 377  */
 378 struct mount *
 379 vfs_getvfs(fsid_t *fsid)
 380 {
 381         struct mount *mp;
 382
 383         lwkt_gettoken(&mountlist_token);
 384         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
 385                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
 386                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
 387                         break;
 388                 }
 389         }
 390         lwkt_reltoken(&mountlist_token);
 391         return (mp);
 392 }
 393
 394 /*
 395  * Get a new unique fsid.  Try to make its val[0] unique, since this value
 396  * will be used to create fake device numbers for stat().  Also try (but
 397  * not so hard) make its val[0] unique mod 2^16, since some emulators only
 398  * support 16-bit device numbers.  We end up with unique val[0]'s for the
 399  * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
 400  *
 401  * Keep in mind that several mounts may be running in parallel.  Starting
 402  * the search one past where the previous search terminated is both a
 403  * micro-optimization and a defense against returning the same fsid to
 404  * different mounts.
 405  */
 406 void
 407 vfs_getnewfsid(struct mount *mp)
 408 {
 409         static u_int16_t mntid_base;
 410         fsid_t tfsid;
 411         int mtype;
 412
 413         lwkt_gettoken(&mntid_token);
 414         mtype = mp->mnt_vfc->vfc_typenum;
 415         tfsid.val[1] = mtype;
 416         mtype = (mtype & 0xFF) << 24;
 417         for (;;) {
 418                 tfsid.val[0] = makeudev(255,
 419                     mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
 420                 mntid_base++;
 421                 if (vfs_getvfs(&tfsid) == NULL)
 422                         break;
 423         }
 424         mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
 425         mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
 426         lwkt_reltoken(&mntid_token);
 427 }
 428
 429 /*
 430  * Set the FSID for a new mount point to the template.  Adjust
 431  * the FSID to avoid collisions.
 432  */
 433 int
 434 vfs_setfsid(struct mount *mp, fsid_t *template)
 435 {
 436         int didmunge = 0;
 437
 438         bzero(&mp->mnt_stat.f_fsid, sizeof(mp->mnt_stat.f_fsid));
 439         for (;;) {
 440                 if (vfs_getvfs(template) == NULL)
 441                         break;
 442                 didmunge = 1;
 443                 ++template->val[1];
 444         }
 445         mp->mnt_stat.f_fsid = *template;
 446         return(didmunge);
 447 }
 448
 449 /*
 450  * This routine is called when we have too many vnodes.  It attempts
 451  * to free <count> vnodes and will potentially free vnodes that still
 452  * have VM backing store (VM backing store is typically the cause
 453  * of a vnode blowout so we want to do this).  Therefore, this operation
 454  * is not considered cheap.
 455  *
 456  * A number of conditions may prevent a vnode from being reclaimed.
 457  * the buffer cache may have references on the vnode, a directory
 458  * vnode may still have references due to the namei cache representing
 459  * underlying files, or the vnode may be in active use.   It is not
 460  * desireable to reuse such vnodes.  These conditions may cause the
 461  * number of vnodes to reach some minimum value regardless of what
 462  * you set kern.maxvnodes to.  Do not set kern.maxvnodes too low.
 463  */
 464
 465 /*
 466  * Attempt to recycle vnodes in a context that is always safe to block.
 467  * Calling vlrurecycle() from the bowels of file system code has some
 468  * interesting deadlock problems.
 469  */
 470 static struct thread *vnlruthread;
 471
 472 static void
 473 vnlru_proc(void)
 474 {
 475         struct thread *td = curthread;
 476
 477         EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
 478                               SHUTDOWN_PRI_FIRST);
 479
 480         for (;;) {
 481                 int ncached;
 482
 483                 kproc_suspend_loop();
 484
 485                 /*
 486                  * Try to free some vnodes if we have too many.  Trigger based
 487                  * on potentially freeable vnodes but calculate the count
 488                  * based on total vnodes.
 489                  *
 490                  * (long) -> deal with 64 bit machines, intermediate overflow
 491                  */
 492                 ncached = countcachedvnodes(1);
 493                 if (numvnodes >= maxvnodes * 9 / 10 &&
 494                     ncached + inactivevnodes >= maxvnodes * 5 / 10) {
 495                         int count = numvnodes - maxvnodes * 9 / 10;
 496
 497                         if (count > (ncached + inactivevnodes) / 100)
 498                                 count = (ncached + inactivevnodes) / 100;
 499                         if (count < 5)
 500                                 count = 5;
 501                         freesomevnodes(count);
 502                 }
 503
 504                 /*
 505                  * Do non-critical-path (more robust) cache cleaning,
 506                  * even if vnode counts are nominal, to try to avoid
 507                  * having to do it in the critical path.
 508                  */
 509                 cache_hysteresis(0);
 510
 511                 /*
 512                  * Nothing to do if most of our vnodes are already on
 513                  * the free list.
 514                  */
 515                 ncached = countcachedvnodes(1);
 516                 if (numvnodes <= maxvnodes * 9 / 10 ||
 517                     ncached + inactivevnodes <= maxvnodes * 5 / 10) {
 518                         tsleep(vnlruthread, 0, "vlruwt", hz);
 519                         continue;
 520                 }
 521         }
 522 }
 523
 524 /*
 525  * MOUNTLIST FUNCTIONS
 526  */
 527
 528 /*
 529  * mountlist_insert (MP SAFE)
 530  *
 531  * Add a new mount point to the mount list.
 532  */
 533 void
 534 mountlist_insert(struct mount *mp, int how)
 535 {
 536         lwkt_gettoken(&mountlist_token);
 537         if (how == MNTINS_FIRST)
 538             TAILQ_INSERT_HEAD(&mountlist, mp, mnt_list);
 539         else
 540             TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
 541         lwkt_reltoken(&mountlist_token);
 542 }
 543
 544 /*
 545  * mountlist_interlock (MP SAFE)
 546  *
 547  * Execute the specified interlock function with the mountlist token
 548  * held.  The function will be called in a serialized fashion verses
 549  * other functions called through this mechanism.
 550  */
 551 int
 552 mountlist_interlock(int (*callback)(struct mount *), struct mount *mp)
 553 {
 554         int error;
 555
 556         lwkt_gettoken(&mountlist_token);
 557         error = callback(mp);
 558         lwkt_reltoken(&mountlist_token);
 559         return (error);
 560 }
 561
 562 /*
 563  * mountlist_boot_getfirst (DURING BOOT ONLY)
 564  *
 565  * This function returns the first mount on the mountlist, which is
 566  * expected to be the root mount.  Since no interlocks are obtained
 567  * this function is only safe to use during booting.
 568  */
 569
 570 struct mount *
 571 mountlist_boot_getfirst(void)
 572 {
 573         return(TAILQ_FIRST(&mountlist));
 574 }
 575
 576 /*
 577  * mountlist_remove (MP SAFE)
 578  *
 579  * Remove a node from the mountlist.  If this node is the next scan node
 580  * for any active mountlist scans, the active mountlist scan will be
 581  * adjusted to skip the node, thus allowing removals during mountlist
 582  * scans.
 583  */
 584 void
 585 mountlist_remove(struct mount *mp)
 586 {
 587         struct mountscan_info *msi;
 588
 589         lwkt_gettoken(&mountlist_token);
 590         TAILQ_FOREACH(msi, &mountscan_list, msi_entry) {
 591                 if (msi->msi_node == mp) {
 592                         if (msi->msi_how & MNTSCAN_FORWARD)
 593                                 msi->msi_node = TAILQ_NEXT(mp, mnt_list);
 594                         else
 595                                 msi->msi_node = TAILQ_PREV(mp, mntlist, mnt_list);
 596                 }
 597         }
 598         TAILQ_REMOVE(&mountlist, mp, mnt_list);
 599         lwkt_reltoken(&mountlist_token);
 600 }
 601
 602 /*
 603  * mountlist_exists (MP SAFE)
 604  *
 605  * Checks if a node exists in the mountlist.
 606  * This function is mainly used by VFS quota code to check if a
 607  * cached nullfs struct mount pointer is still valid at use time
 608  *
 609  * FIXME: there is no warranty the mp passed to that function
 610  * will be the same one used by VFS_ACCOUNT() later
 611  */
 612 int
 613 mountlist_exists(struct mount *mp)
 614 {
 615         int node_exists = 0;
 616         struct mount* lmp;
 617
 618         lwkt_gettoken(&mountlist_token);
 619         TAILQ_FOREACH(lmp, &mountlist, mnt_list) {
 620                 if (lmp == mp) {
 621                         node_exists = 1;
 622                         break;
 623                 }
 624         }
 625         lwkt_reltoken(&mountlist_token);
 626         return(node_exists);
 627 }
 628
 629 /*
 630  * mountlist_scan (MP SAFE)
 631  *
 632  * Safely scan the mount points on the mount list.  Unless otherwise
 633  * specified each mount point will be busied prior to the callback and
 634  * unbusied afterwords.  The callback may safely remove any mount point
 635  * without interfering with the scan.  If the current callback
 636  * mount is removed the scanner will not attempt to unbusy it.
 637  *
 638  * If a mount node cannot be busied it is silently skipped.
 639  *
 640  * The callback return value is aggregated and a total is returned.  A return
 641  * value of < 0 is not aggregated and will terminate the scan.
 642  *
 643  * MNTSCAN_FORWARD      - the mountlist is scanned in the forward direction
 644  * MNTSCAN_REVERSE      - the mountlist is scanned in reverse
 645  * MNTSCAN_NOBUSY       - the scanner will make the callback without busying
 646  *                        the mount node.
 647  *
 648  * NOTE: mount_hold()/mount_drop() sequence primarily helps us avoid
 649  *       confusion for the unbusy check, particularly if a kfree/kmalloc
 650  *       occurs quickly (lots of processes mounting and unmounting at the
 651  *       same time).
 652  */
 653 int
 654 mountlist_scan(int (*callback)(struct mount *, void *), void *data, int how)
 655 {
 656         struct mountscan_info info;
 657         struct mount *mp;
 658         int count;
 659         int res;
 660
 661         lwkt_gettoken(&mountlist_token);
 662
 663         info.msi_how = how;
 664         info.msi_node = NULL;   /* paranoia */
 665         TAILQ_INSERT_TAIL(&mountscan_list, &info, msi_entry);
 666
 667         res = 0;
 668
 669         if (how & MNTSCAN_FORWARD) {
 670                 info.msi_node = TAILQ_FIRST(&mountlist);
 671                 while ((mp = info.msi_node) != NULL) {
 672                         mount_hold(mp);
 673                         if (how & MNTSCAN_NOBUSY) {
 674                                 count = callback(mp, data);
 675                         } else if (vfs_busy(mp, LK_NOWAIT) == 0) {
 676                                 count = callback(mp, data);
 677                                 if (mp == info.msi_node)
 678                                         vfs_unbusy(mp);
 679                         } else {
 680                                 count = 0;
 681                         }
 682                         mount_drop(mp);
 683                         if (count < 0)
 684                                 break;
 685                         res += count;
 686                         if (mp == info.msi_node)
 687                                 info.msi_node = TAILQ_NEXT(mp, mnt_list);
 688                 }
 689         } else if (how & MNTSCAN_REVERSE) {
 690                 info.msi_node = TAILQ_LAST(&mountlist, mntlist);
 691                 while ((mp = info.msi_node) != NULL) {
 692                         mount_hold(mp);
 693                         if (how & MNTSCAN_NOBUSY) {
 694                                 count = callback(mp, data);
 695                         } else if (vfs_busy(mp, LK_NOWAIT) == 0) {
 696                                 count = callback(mp, data);
 697                                 if (mp == info.msi_node)
 698                                         vfs_unbusy(mp);
 699                         } else {
 700                                 count = 0;
 701                         }
 702                         mount_drop(mp);
 703                         if (count < 0)
 704                                 break;
 705                         res += count;
 706                         if (mp == info.msi_node)
 707                                 info.msi_node = TAILQ_PREV(mp, mntlist, mnt_list);
 708                 }
 709         }
 710         TAILQ_REMOVE(&mountscan_list, &info, msi_entry);
 711         lwkt_reltoken(&mountlist_token);
 712         return(res);
 713 }
 714
 715 /*
 716  * MOUNT RELATED VNODE FUNCTIONS
 717  */
 718
 719 static struct kproc_desc vnlru_kp = {
 720         "vnlru",
 721         vnlru_proc,
 722         &vnlruthread
 723 };
 724 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp);
 725
 726 /*
 727  * Move a vnode from one mount queue to another.
 728  */
 729 void
 730 insmntque(struct vnode *vp, struct mount *mp)
 731 {
 732         struct mount *omp;
 733
 734         /*
 735          * Delete from old mount point vnode list, if on one.
 736          */
 737         if ((omp = vp->v_mount) != NULL) {
 738                 lwkt_gettoken(&omp->mnt_token);
 739                 KKASSERT(omp == vp->v_mount);
 740                 KASSERT(omp->mnt_nvnodelistsize > 0,
 741                         ("bad mount point vnode list size"));
 742                 vremovevnodemnt(vp);
 743                 omp->mnt_nvnodelistsize--;
 744                 lwkt_reltoken(&omp->mnt_token);
 745         }
 746
 747         /*
 748          * Insert into list of vnodes for the new mount point, if available.
 749          * The 'end' of the LRU list is the vnode prior to mp->mnt_syncer.
 750          */
 751         if (mp == NULL) {
 752                 vp->v_mount = NULL;
 753                 return;
 754         }
 755         lwkt_gettoken(&mp->mnt_token);
 756         vp->v_mount = mp;
 757         if (mp->mnt_syncer) {
 758                 TAILQ_INSERT_BEFORE(mp->mnt_syncer, vp, v_nmntvnodes);
 759         } else {
 760                 TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
 761         }
 762         mp->mnt_nvnodelistsize++;
 763         lwkt_reltoken(&mp->mnt_token);
 764 }
 765
 766
 767 /*
 768  * Scan the vnodes under a mount point and issue appropriate callbacks.
 769  *
 770  * The fastfunc() callback is called with just the mountlist token held
 771  * (no vnode lock).  It may not block and the vnode may be undergoing
 772  * modifications while the caller is processing it.  The vnode will
 773  * not be entirely destroyed, however, due to the fact that the mountlist
 774  * token is held.  A return value < 0 skips to the next vnode without calling
 775  * the slowfunc(), a return value > 0 terminates the loop.
 776  *
 777  * WARNING! The fastfunc() should not indirect through vp->v_object, the vp
 778  *          data structure is unstable when called from fastfunc().
 779  *
 780  * The slowfunc() callback is called after the vnode has been successfully
 781  * locked based on passed flags.  The vnode is skipped if it gets rearranged
 782  * or destroyed while blocking on the lock.  A non-zero return value from
 783  * the slow function terminates the loop.  The slow function is allowed to
 784  * arbitrarily block.  The scanning code guarentees consistency of operation
 785  * even if the slow function deletes or moves the node, or blocks and some
 786  * other thread deletes or moves the node.
 787  */
 788 int
 789 vmntvnodescan(
 790     struct mount *mp,
 791     int flags,
 792     int (*fastfunc)(struct mount *mp, struct vnode *vp, void *data),
 793     int (*slowfunc)(struct mount *mp, struct vnode *vp, void *data),
 794     void *data
 795 ) {
 796         struct vmntvnodescan_info info;
 797         struct vnode *vp;
 798         int r = 0;
 799         int maxcount = mp->mnt_nvnodelistsize * 2;
 800         int stopcount = 0;
 801         int count = 0;
 802
 803         lwkt_gettoken(&mp->mnt_token);
 804
 805         /*
 806          * If asked to do one pass stop after iterating available vnodes.
 807          * Under heavy loads new vnodes can be added while we are scanning,
 808          * so this isn't perfect.  Create a slop factor of 2x.
 809          */
 810         if (flags & VMSC_ONEPASS)
 811                 stopcount = mp->mnt_nvnodelistsize;
 812
 813         info.vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
 814         TAILQ_INSERT_TAIL(&mp->mnt_vnodescan_list, &info, entry);
 815
 816         while ((vp = info.vp) != NULL) {
 817                 if (--maxcount == 0) {
 818                         kprintf("Warning: excessive fssync iteration\n");
 819                         maxcount = mp->mnt_nvnodelistsize * 2;
 820                 }
 821
 822                 /*
 823                  * Skip if visible but not ready, or special (e.g.
 824                  * mp->mnt_syncer)
 825                  */
 826                 if (vp->v_type == VNON)
 827                         goto next;
 828                 KKASSERT(vp->v_mount == mp);
 829
 830                 /*
 831                  * Quick test.  A negative return continues the loop without
 832                  * calling the slow test.  0 continues onto the slow test.
 833                  * A positive number aborts the loop.
 834                  */
 835                 if (fastfunc) {
 836                         if ((r = fastfunc(mp, vp, data)) < 0) {
 837                                 r = 0;
 838                                 goto next;
 839                         }
 840                         if (r)
 841                                 break;
 842                 }
 843
 844                 /*
 845                  * Get a vxlock on the vnode, retry if it has moved or isn't
 846                  * in the mountlist where we expect it.
 847                  */
 848                 if (slowfunc) {
 849                         int error;
 850
 851                         switch(flags & (VMSC_GETVP|VMSC_GETVX|VMSC_NOWAIT)) {
 852                         case VMSC_GETVP:
 853                                 error = vget(vp, LK_EXCLUSIVE);
 854                                 break;
 855                         case VMSC_GETVP|VMSC_NOWAIT:
 856                                 error = vget(vp, LK_EXCLUSIVE|LK_NOWAIT);
 857                                 break;
 858                         case VMSC_GETVX:
 859                                 vx_get(vp);
 860                                 error = 0;
 861                                 break;
 862                         default:
 863                                 error = 0;
 864                                 break;
 865                         }
 866                         if (error)
 867                                 goto next;
 868                         /*
 869                          * Do not call the slow function if the vnode is
 870                          * invalid or if it was ripped out from under us
 871                          * while we (potentially) blocked.
 872                          */
 873                         if (info.vp == vp && vp->v_type != VNON)
 874                                 r = slowfunc(mp, vp, data);
 875
 876                         /*
 877                          * Cleanup
 878                          */
 879                         switch(flags & (VMSC_GETVP|VMSC_GETVX|VMSC_NOWAIT)) {
 880                         case VMSC_GETVP:
 881                         case VMSC_GETVP|VMSC_NOWAIT:
 882                                 vput(vp);
 883                                 break;
 884                         case VMSC_GETVX:
 885                                 vx_put(vp);
 886                                 break;
 887                         default:
 888                                 break;
 889                         }
 890                         if (r != 0)
 891                                 break;
 892                 }
 893
 894 next:
 895                 /*
 896                  * Yield after some processing.  Depending on the number
 897                  * of vnodes, we might wind up running for a long time.
 898                  * Because threads are not preemptable, time critical
 899                  * userland processes might starve.  Give them a chance
 900                  * now and then.
 901                  */
 902                 if (++count == 10000) {
 903                         /*
 904                          * We really want to yield a bit, so we simply
 905                          * sleep a tick
 906                          */
 907                         tsleep(mp, 0, "vnodescn", 1);
 908                         count = 0;
 909                 }
 910
 911                 /*
 912                  * If doing one pass this decrements to zero.  If it starts
 913                  * at zero it is effectively unlimited for the purposes of
 914                  * this loop.
 915                  */
 916                 if (--stopcount == 0)
 917                         break;
 918
 919                 /*
 920                  * Iterate.  If the vnode was ripped out from under us
 921                  * info.vp will already point to the next vnode, otherwise
 922                  * we have to obtain the next valid vnode ourselves.
 923                  */
 924                 if (info.vp == vp)
 925                         info.vp = TAILQ_NEXT(vp, v_nmntvnodes);
 926         }
 927
 928         TAILQ_REMOVE(&mp->mnt_vnodescan_list, &info, entry);
 929         lwkt_reltoken(&mp->mnt_token);
 930         return(r);
 931 }
 932
 933 /*
 934  * Remove any vnodes in the vnode table belonging to mount point mp.
 935  *
 936  * If FORCECLOSE is not specified, there should not be any active ones,
 937  * return error if any are found (nb: this is a user error, not a
 938  * system error). If FORCECLOSE is specified, detach any active vnodes
 939  * that are found.
 940  *
 941  * If WRITECLOSE is set, only flush out regular file vnodes open for
 942  * writing.
 943  *
 944  * SKIPSYSTEM causes any vnodes marked VSYSTEM to be skipped.
 945  *
 946  * `rootrefs' specifies the base reference count for the root vnode
 947  * of this filesystem. The root vnode is considered busy if its
 948  * v_refcnt exceeds this value. On a successful return, vflush()
 949  * will call vrele() on the root vnode exactly rootrefs times.
 950  * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
 951  * be zero.
 952  */
 953 #ifdef DIAGNOSTIC
 954 static int busyprt = 0;         /* print out busy vnodes */
 955 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
 956 #endif
 957
 958 static int vflush_scan(struct mount *mp, struct vnode *vp, void *data);
 959
 960 struct vflush_info {
 961         int flags;
 962         int busy;
 963         thread_t td;
 964 };
 965
 966 int
 967 vflush(struct mount *mp, int rootrefs, int flags)
 968 {
 969         struct thread *td = curthread;  /* XXX */
 970         struct vnode *rootvp = NULL;
 971         int error;
 972         struct vflush_info vflush_info;
 973
 974         if (rootrefs > 0) {
 975                 KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0,
 976                     ("vflush: bad args"));
 977                 /*
 978                  * Get the filesystem root vnode. We can vput() it
 979                  * immediately, since with rootrefs > 0, it won't go away.
 980                  */
 981                 if ((error = VFS_ROOT(mp, &rootvp)) != 0) {
 982                         if ((flags & FORCECLOSE) == 0)
 983                                 return (error);
 984                         rootrefs = 0;
 985                         /* continue anyway */
 986                 }
 987                 if (rootrefs)
 988                         vput(rootvp);
 989         }
 990
 991         vflush_info.busy = 0;
 992         vflush_info.flags = flags;
 993         vflush_info.td = td;
 994         vmntvnodescan(mp, VMSC_GETVX, NULL, vflush_scan, &vflush_info);
 995
 996         if (rootrefs > 0 && (flags & FORCECLOSE) == 0) {
 997                 /*
 998                  * If just the root vnode is busy, and if its refcount
 999                  * is equal to `rootrefs', then go ahead and kill it.
1000                  */
1001                 KASSERT(vflush_info.busy > 0, ("vflush: not busy"));
1002                 KASSERT(VREFCNT(rootvp) >= rootrefs, ("vflush: rootrefs"));
1003                 if (vflush_info.busy == 1 && VREFCNT(rootvp) == rootrefs) {
1004                         vx_lock(rootvp);
1005                         vgone_vxlocked(rootvp);
1006                         vx_unlock(rootvp);
1007                         vflush_info.busy = 0;
1008                 }
1009         }
1010         if (vflush_info.busy)
1011                 return (EBUSY);
1012         for (; rootrefs > 0; rootrefs--)
1013                 vrele(rootvp);
1014         return (0);
1015 }
1016
1017 /*
1018  * The scan callback is made with an VX locked vnode.
1019  */
1020 static int
1021 vflush_scan(struct mount *mp, struct vnode *vp, void *data)
1022 {
1023         struct vflush_info *info = data;
1024         struct vattr vattr;
1025         int flags = info->flags;
1026
1027         /*
1028          * Generally speaking try to deactivate on 0 refs (catch-all)
1029          */
1030         atomic_set_int(&vp->v_refcnt, VREF_FINALIZE);
1031
1032         /*
1033          * Skip over a vnodes marked VSYSTEM.
1034          */
1035         if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
1036                 return(0);
1037         }
1038
1039         /*
1040          * Do not force-close VCHR or VBLK vnodes
1041          */
1042         if (vp->v_type == VCHR || vp->v_type == VBLK)
1043                 flags &= ~(WRITECLOSE|FORCECLOSE);
1044
1045         /*
1046          * If WRITECLOSE is set, flush out unlinked but still open
1047          * files (even if open only for reading) and regular file
1048          * vnodes open for writing.
1049          */
1050         if ((flags & WRITECLOSE) &&
1051             (vp->v_type == VNON ||
1052             (VOP_GETATTR(vp, &vattr) == 0 &&
1053             vattr.va_nlink > 0)) &&
1054             (vp->v_writecount == 0 || vp->v_type != VREG)) {
1055                 return(0);
1056         }
1057
1058         /*
1059          * If we are the only holder (refcnt of 1) or the vnode is in
1060          * termination (refcnt < 0), we can vgone the vnode.
1061          */
1062         if (VREFCNT(vp) <= 1) {
1063                 vgone_vxlocked(vp);
1064                 return(0);
1065         }
1066
1067         /*
1068          * If FORCECLOSE is set, forcibly destroy the vnode and then move
1069          * it to a dummymount structure so vop_*() functions don't deref
1070          * a NULL pointer.
1071          */
1072         if (flags & FORCECLOSE) {
1073                 vhold(vp);
1074                 vgone_vxlocked(vp);
1075                 if (vp->v_mount == NULL)
1076                         insmntque(vp, &dummymount);
1077                 vdrop(vp);
1078                 return(0);
1079         }
1080         if (vp->v_type == VCHR || vp->v_type == VBLK)
1081                 kprintf("vflush: Warning, cannot destroy busy device vnode\n");
1082 #ifdef DIAGNOSTIC
1083         if (busyprt)
1084                 vprint("vflush: busy vnode", vp);
1085 #endif
1086         ++info->busy;
1087         return(0);
1088 }
1089
1090 void
1091 add_bio_ops(struct bio_ops *ops)
1092 {
1093         TAILQ_INSERT_TAIL(&bio_ops_list, ops, entry);
1094 }
1095
1096 void
1097 rem_bio_ops(struct bio_ops *ops)
1098 {
1099         TAILQ_REMOVE(&bio_ops_list, ops, entry);
1100 }
1101
1102 /*
1103  * This calls the bio_ops io_sync function either for a mount point
1104  * or generally.
1105  *
1106  * WARNING: softdeps is weirdly coded and just isn't happy unless
1107  * io_sync is called with a NULL mount from the general syncing code.
1108  */
1109 void
1110 bio_ops_sync(struct mount *mp)
1111 {
1112         struct bio_ops *ops;
1113
1114         if (mp) {
1115                 if ((ops = mp->mnt_bioops) != NULL)
1116                         ops->io_sync(mp);
1117         } else {
1118                 TAILQ_FOREACH(ops, &bio_ops_list, entry) {
1119                         ops->io_sync(NULL);
1120                 }
1121         }
1122 }
1123
1124 /*
1125  * Lookup a mount point by nch
1126  */
1127 struct mount *
1128 mount_get_by_nc(struct namecache *ncp)
1129 {
1130         struct mount *mp = NULL;
1131
1132         lwkt_gettoken(&mountlist_token);
1133         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
1134                 if (ncp == mp->mnt_ncmountpt.ncp)
1135                         break;
1136         }
1137         lwkt_reltoken(&mountlist_token);
1138         return (mp);
1139 }
1140