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  * If not NULL, the returned mp is held and the caller is expected to drop
 379  * it via mount_drop().
 380  */
 381 struct mount *
 382 vfs_getvfs(fsid_t *fsid)
 383 {
 384         struct mount *mp;
 385
 386         lwkt_gettoken_shared(&mountlist_token);
 387         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
 388                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
 389                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
 390                         mount_hold(mp);
 391                         break;
 392                 }
 393         }
 394         lwkt_reltoken(&mountlist_token);
 395         return (mp);
 396 }
 397
 398 /*
 399  * Get a new unique fsid.  Try to make its val[0] unique, since this value
 400  * will be used to create fake device numbers for stat().  Also try (but
 401  * not so hard) make its val[0] unique mod 2^16, since some emulators only
 402  * support 16-bit device numbers.  We end up with unique val[0]'s for the
 403  * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
 404  *
 405  * Keep in mind that several mounts may be running in parallel.  Starting
 406  * the search one past where the previous search terminated is both a
 407  * micro-optimization and a defense against returning the same fsid to
 408  * different mounts.
 409  */
 410 void
 411 vfs_getnewfsid(struct mount *mp)
 412 {
 413         static u_int16_t mntid_base;
 414         struct mount *mptmp;
 415         fsid_t tfsid;
 416         int mtype;
 417
 418         lwkt_gettoken(&mntid_token);
 419         mtype = mp->mnt_vfc->vfc_typenum;
 420         tfsid.val[1] = mtype;
 421         mtype = (mtype & 0xFF) << 24;
 422         for (;;) {
 423                 tfsid.val[0] = makeudev(255,
 424                     mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
 425                 mntid_base++;
 426                 mptmp = vfs_getvfs(&tfsid);
 427                 if (mptmp == NULL)
 428                         break;
 429                 mount_drop(mptmp);
 430         }
 431         mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
 432         mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
 433         lwkt_reltoken(&mntid_token);
 434 }
 435
 436 /*
 437  * Set the FSID for a new mount point to the template.  Adjust
 438  * the FSID to avoid collisions.
 439  */
 440 int
 441 vfs_setfsid(struct mount *mp, fsid_t *template)
 442 {
 443         struct mount *mptmp;
 444         int didmunge = 0;
 445
 446         bzero(&mp->mnt_stat.f_fsid, sizeof(mp->mnt_stat.f_fsid));
 447
 448         lwkt_gettoken(&mntid_token);
 449         for (;;) {
 450                 mptmp = vfs_getvfs(template);
 451                 if (mptmp == NULL)
 452                         break;
 453                 mount_drop(mptmp);
 454                 didmunge = 1;
 455                 ++template->val[1];
 456         }
 457         mp->mnt_stat.f_fsid = *template;
 458         lwkt_reltoken(&mntid_token);
 459
 460         return(didmunge);
 461 }
 462
 463 /*
 464  * This routine is called when we have too many vnodes.  It attempts
 465  * to free <count> vnodes and will potentially free vnodes that still
 466  * have VM backing store (VM backing store is typically the cause
 467  * of a vnode blowout so we want to do this).  Therefore, this operation
 468  * is not considered cheap.
 469  *
 470  * A number of conditions may prevent a vnode from being reclaimed.
 471  * the buffer cache may have references on the vnode, a directory
 472  * vnode may still have references due to the namei cache representing
 473  * underlying files, or the vnode may be in active use.   It is not
 474  * desireable to reuse such vnodes.  These conditions may cause the
 475  * number of vnodes to reach some minimum value regardless of what
 476  * you set kern.maxvnodes to.  Do not set kern.maxvnodes too low.
 477  */
 478
 479 /*
 480  * Attempt to recycle vnodes in a context that is always safe to block.
 481  * Calling vlrurecycle() from the bowels of file system code has some
 482  * interesting deadlock problems.
 483  */
 484 static struct thread *vnlruthread;
 485
 486 static void
 487 vnlru_proc(void)
 488 {
 489         struct thread *td = curthread;
 490
 491         EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, td,
 492                               SHUTDOWN_PRI_FIRST);
 493
 494         for (;;) {
 495                 int ncached;
 496
 497                 kproc_suspend_loop();
 498
 499                 /*
 500                  * Try to free some vnodes if we have too many.  Trigger based
 501                  * on potentially freeable vnodes but calculate the count
 502                  * based on total vnodes.
 503                  *
 504                  * (long) -> deal with 64 bit machines, intermediate overflow
 505                  */
 506                 ncached = countcachedvnodes(1);
 507                 if (numvnodes >= maxvnodes * 9 / 10 &&
 508                     ncached + inactivevnodes >= maxvnodes * 5 / 10) {
 509                         int count = numvnodes - maxvnodes * 9 / 10;
 510
 511                         if (count > (ncached + inactivevnodes) / 100)
 512                                 count = (ncached + inactivevnodes) / 100;
 513                         if (count < 5)
 514                                 count = 5;
 515                         freesomevnodes(count);
 516                 }
 517
 518                 /*
 519                  * Do non-critical-path (more robust) cache cleaning,
 520                  * even if vnode counts are nominal, to try to avoid
 521                  * having to do it in the critical path.
 522                  */
 523                 cache_hysteresis(0);
 524
 525                 /*
 526                  * Nothing to do if most of our vnodes are already on
 527                  * the free list.
 528                  */
 529                 ncached = countcachedvnodes(1);
 530                 if (numvnodes <= maxvnodes * 9 / 10 ||
 531                     ncached + inactivevnodes <= maxvnodes * 5 / 10) {
 532                         tsleep(vnlruthread, 0, "vlruwt", hz);
 533                         continue;
 534                 }
 535         }
 536 }
 537
 538 /*
 539  * MOUNTLIST FUNCTIONS
 540  */
 541
 542 /*
 543  * mountlist_insert (MP SAFE)
 544  *
 545  * Add a new mount point to the mount list.
 546  */
 547 void
 548 mountlist_insert(struct mount *mp, int how)
 549 {
 550         lwkt_gettoken(&mountlist_token);
 551         if (how == MNTINS_FIRST)
 552                 TAILQ_INSERT_HEAD(&mountlist, mp, mnt_list);
 553         else
 554                 TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
 555         lwkt_reltoken(&mountlist_token);
 556 }
 557
 558 /*
 559  * mountlist_interlock (MP SAFE)
 560  *
 561  * Execute the specified interlock function with the mountlist token
 562  * held.  The function will be called in a serialized fashion verses
 563  * other functions called through this mechanism.
 564  *
 565  * The function is expected to be very short-lived.
 566  */
 567 int
 568 mountlist_interlock(int (*callback)(struct mount *), struct mount *mp)
 569 {
 570         int error;
 571
 572         lwkt_gettoken(&mountlist_token);
 573         error = callback(mp);
 574         lwkt_reltoken(&mountlist_token);
 575         return (error);
 576 }
 577
 578 /*
 579  * mountlist_boot_getfirst (DURING BOOT ONLY)
 580  *
 581  * This function returns the first mount on the mountlist, which is
 582  * expected to be the root mount.  Since no interlocks are obtained
 583  * this function is only safe to use during booting.
 584  */
 585
 586 struct mount *
 587 mountlist_boot_getfirst(void)
 588 {
 589         return(TAILQ_FIRST(&mountlist));
 590 }
 591
 592 /*
 593  * mountlist_remove (MP SAFE)
 594  *
 595  * Remove a node from the mountlist.  If this node is the next scan node
 596  * for any active mountlist scans, the active mountlist scan will be
 597  * adjusted to skip the node, thus allowing removals during mountlist
 598  * scans.
 599  */
 600 void
 601 mountlist_remove(struct mount *mp)
 602 {
 603         struct mountscan_info *msi;
 604
 605         lwkt_gettoken(&mountlist_token);
 606         TAILQ_FOREACH(msi, &mountscan_list, msi_entry) {
 607                 if (msi->msi_node == mp) {
 608                         if (msi->msi_how & MNTSCAN_FORWARD)
 609                                 msi->msi_node = TAILQ_NEXT(mp, mnt_list);
 610                         else
 611                                 msi->msi_node = TAILQ_PREV(mp, mntlist,
 612                                                            mnt_list);
 613                 }
 614         }
 615         TAILQ_REMOVE(&mountlist, mp, mnt_list);
 616         lwkt_reltoken(&mountlist_token);
 617 }
 618
 619 /*
 620  * mountlist_exists (MP SAFE)
 621  *
 622  * Checks if a node exists in the mountlist.
 623  * This function is mainly used by VFS quota code to check if a
 624  * cached nullfs struct mount pointer is still valid at use time
 625  *
 626  * FIXME: there is no warranty the mp passed to that function
 627  * will be the same one used by VFS_ACCOUNT() later
 628  */
 629 int
 630 mountlist_exists(struct mount *mp)
 631 {
 632         int node_exists = 0;
 633         struct mount* lmp;
 634
 635         lwkt_gettoken_shared(&mountlist_token);
 636         TAILQ_FOREACH(lmp, &mountlist, mnt_list) {
 637                 if (lmp == mp) {
 638                         node_exists = 1;
 639                         break;
 640                 }
 641         }
 642         lwkt_reltoken(&mountlist_token);
 643
 644         return(node_exists);
 645 }
 646
 647 /*
 648  * mountlist_scan
 649  *
 650  * Safely scan the mount points on the mount list.  Each mountpoint
 651  * is held across the callback.  The callback is responsible for
 652  * acquiring any further tokens or locks.
 653  *
 654  * Unless otherwise specified each mount point will be busied prior to the
 655  * callback and unbusied afterwords.  The callback may safely remove any
 656  * mount point without interfering with the scan.  If the current callback
 657  * mount is removed the scanner will not attempt to unbusy it.
 658  *
 659  * If a mount node cannot be busied it is silently skipped.
 660  *
 661  * The callback return value is aggregated and a total is returned.  A return
 662  * value of < 0 is not aggregated and will terminate the scan.
 663  *
 664  * MNTSCAN_FORWARD      - the mountlist is scanned in the forward direction
 665  * MNTSCAN_REVERSE      - the mountlist is scanned in reverse
 666  * MNTSCAN_NOBUSY       - the scanner will make the callback without busying
 667  *                        the mount node.
 668  *
 669  * NOTE: mountlist_token is not held across the callback.
 670  */
 671 int
 672 mountlist_scan(int (*callback)(struct mount *, void *), void *data, int how)
 673 {
 674         struct mountscan_info info;
 675         struct mount *mp;
 676         int count;
 677         int res;
 678
 679         lwkt_gettoken(&mountlist_token);
 680         info.msi_how = how;
 681         info.msi_node = NULL;   /* paranoia */
 682         TAILQ_INSERT_TAIL(&mountscan_list, &info, msi_entry);
 683         lwkt_reltoken(&mountlist_token);
 684
 685         res = 0;
 686         lwkt_gettoken_shared(&mountlist_token);
 687
 688         if (how & MNTSCAN_FORWARD) {
 689                 info.msi_node = TAILQ_FIRST(&mountlist);
 690                 while ((mp = info.msi_node) != NULL) {
 691                         mount_hold(mp);
 692                         if (how & MNTSCAN_NOBUSY) {
 693                                 lwkt_reltoken(&mountlist_token);
 694                                 count = callback(mp, data);
 695                                 lwkt_gettoken_shared(&mountlist_token);
 696                         } else if (vfs_busy(mp, LK_NOWAIT) == 0) {
 697                                 lwkt_reltoken(&mountlist_token);
 698                                 count = callback(mp, data);
 699                                 lwkt_gettoken_shared(&mountlist_token);
 700                                 if (mp == info.msi_node)
 701                                         vfs_unbusy(mp);
 702                         } else {
 703                                 count = 0;
 704                         }
 705                         mount_drop(mp);
 706                         if (count < 0)
 707                                 break;
 708                         res += count;
 709                         if (mp == info.msi_node)
 710                                 info.msi_node = TAILQ_NEXT(mp, mnt_list);
 711                 }
 712         } else if (how & MNTSCAN_REVERSE) {
 713                 info.msi_node = TAILQ_LAST(&mountlist, mntlist);
 714                 while ((mp = info.msi_node) != NULL) {
 715                         mount_hold(mp);
 716                         if (how & MNTSCAN_NOBUSY) {
 717                                 lwkt_reltoken(&mountlist_token);
 718                                 count = callback(mp, data);
 719                                 lwkt_gettoken_shared(&mountlist_token);
 720                         } else if (vfs_busy(mp, LK_NOWAIT) == 0) {
 721                                 lwkt_reltoken(&mountlist_token);
 722                                 count = callback(mp, data);
 723                                 lwkt_gettoken_shared(&mountlist_token);
 724                                 if (mp == info.msi_node)
 725                                         vfs_unbusy(mp);
 726                         } else {
 727                                 count = 0;
 728                         }
 729                         mount_drop(mp);
 730                         if (count < 0)
 731                                 break;
 732                         res += count;
 733                         if (mp == info.msi_node)
 734                                 info.msi_node = TAILQ_PREV(mp, mntlist,
 735                                                            mnt_list);
 736                 }
 737         }
 738         lwkt_reltoken(&mountlist_token);
 739
 740         lwkt_gettoken(&mountlist_token);
 741         TAILQ_REMOVE(&mountscan_list, &info, msi_entry);
 742         lwkt_reltoken(&mountlist_token);
 743
 744         return(res);
 745 }
 746
 747 /*
 748  * MOUNT RELATED VNODE FUNCTIONS
 749  */
 750
 751 static struct kproc_desc vnlru_kp = {
 752         "vnlru",
 753         vnlru_proc,
 754         &vnlruthread
 755 };
 756 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &vnlru_kp);
 757
 758 /*
 759  * Move a vnode from one mount queue to another.
 760  */
 761 void
 762 insmntque(struct vnode *vp, struct mount *mp)
 763 {
 764         struct mount *omp;
 765
 766         /*
 767          * Delete from old mount point vnode list, if on one.
 768          */
 769         if ((omp = vp->v_mount) != NULL) {
 770                 lwkt_gettoken(&omp->mnt_token);
 771                 KKASSERT(omp == vp->v_mount);
 772                 KASSERT(omp->mnt_nvnodelistsize > 0,
 773                         ("bad mount point vnode list size"));
 774                 vremovevnodemnt(vp);
 775                 omp->mnt_nvnodelistsize--;
 776                 lwkt_reltoken(&omp->mnt_token);
 777         }
 778
 779         /*
 780          * Insert into list of vnodes for the new mount point, if available.
 781          * The 'end' of the LRU list is the vnode prior to mp->mnt_syncer.
 782          */
 783         if (mp == NULL) {
 784                 vp->v_mount = NULL;
 785                 return;
 786         }
 787         lwkt_gettoken(&mp->mnt_token);
 788         vp->v_mount = mp;
 789         if (mp->mnt_syncer) {
 790                 TAILQ_INSERT_BEFORE(mp->mnt_syncer, vp, v_nmntvnodes);
 791         } else {
 792                 TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
 793         }
 794         mp->mnt_nvnodelistsize++;
 795         lwkt_reltoken(&mp->mnt_token);
 796 }
 797
 798
 799 /*
 800  * Scan the vnodes under a mount point and issue appropriate callbacks.
 801  *
 802  * The fastfunc() callback is called with just the mountlist token held
 803  * (no vnode lock).  It may not block and the vnode may be undergoing
 804  * modifications while the caller is processing it.  The vnode will
 805  * not be entirely destroyed, however, due to the fact that the mountlist
 806  * token is held.  A return value < 0 skips to the next vnode without calling
 807  * the slowfunc(), a return value > 0 terminates the loop.
 808  *
 809  * WARNING! The fastfunc() should not indirect through vp->v_object, the vp
 810  *          data structure is unstable when called from fastfunc().
 811  *
 812  * The slowfunc() callback is called after the vnode has been successfully
 813  * locked based on passed flags.  The vnode is skipped if it gets rearranged
 814  * or destroyed while blocking on the lock.  A non-zero return value from
 815  * the slow function terminates the loop.  The slow function is allowed to
 816  * arbitrarily block.  The scanning code guarentees consistency of operation
 817  * even if the slow function deletes or moves the node, or blocks and some
 818  * other thread deletes or moves the node.
 819  */
 820 int
 821 vmntvnodescan(
 822     struct mount *mp,
 823     int flags,
 824     int (*fastfunc)(struct mount *mp, struct vnode *vp, void *data),
 825     int (*slowfunc)(struct mount *mp, struct vnode *vp, void *data),
 826     void *data
 827 ) {
 828         struct vmntvnodescan_info info;
 829         struct vnode *vp;
 830         int r = 0;
 831         int maxcount = mp->mnt_nvnodelistsize * 2;
 832         int stopcount = 0;
 833         int count = 0;
 834
 835         lwkt_gettoken(&mp->mnt_token);
 836
 837         /*
 838          * If asked to do one pass stop after iterating available vnodes.
 839          * Under heavy loads new vnodes can be added while we are scanning,
 840          * so this isn't perfect.  Create a slop factor of 2x.
 841          */
 842         if (flags & VMSC_ONEPASS)
 843                 stopcount = mp->mnt_nvnodelistsize;
 844
 845         info.vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
 846         TAILQ_INSERT_TAIL(&mp->mnt_vnodescan_list, &info, entry);
 847
 848         while ((vp = info.vp) != NULL) {
 849                 if (--maxcount == 0) {
 850                         kprintf("Warning: excessive fssync iteration\n");
 851                         maxcount = mp->mnt_nvnodelistsize * 2;
 852                 }
 853
 854                 /*
 855                  * Skip if visible but not ready, or special (e.g.
 856                  * mp->mnt_syncer)
 857                  */
 858                 if (vp->v_type == VNON)
 859                         goto next;
 860                 KKASSERT(vp->v_mount == mp);
 861
 862                 /*
 863                  * Quick test.  A negative return continues the loop without
 864                  * calling the slow test.  0 continues onto the slow test.
 865                  * A positive number aborts the loop.
 866                  */
 867                 if (fastfunc) {
 868                         if ((r = fastfunc(mp, vp, data)) < 0) {
 869                                 r = 0;
 870                                 goto next;
 871                         }
 872                         if (r)
 873                                 break;
 874                 }
 875
 876                 /*
 877                  * Get a vxlock on the vnode, retry if it has moved or isn't
 878                  * in the mountlist where we expect it.
 879                  */
 880                 if (slowfunc) {
 881                         int error;
 882
 883                         switch(flags & (VMSC_GETVP|VMSC_GETVX|VMSC_NOWAIT)) {
 884                         case VMSC_GETVP:
 885                                 error = vget(vp, LK_EXCLUSIVE);
 886                                 break;
 887                         case VMSC_GETVP|VMSC_NOWAIT:
 888                                 error = vget(vp, LK_EXCLUSIVE|LK_NOWAIT);
 889                                 break;
 890                         case VMSC_GETVX:
 891                                 vx_get(vp);
 892                                 error = 0;
 893                                 break;
 894                         default:
 895                                 error = 0;
 896                                 break;
 897                         }
 898                         if (error)
 899                                 goto next;
 900                         /*
 901                          * Do not call the slow function if the vnode is
 902                          * invalid or if it was ripped out from under us
 903                          * while we (potentially) blocked.
 904                          */
 905                         if (info.vp == vp && vp->v_type != VNON)
 906                                 r = slowfunc(mp, vp, data);
 907
 908                         /*
 909                          * Cleanup
 910                          */
 911                         switch(flags & (VMSC_GETVP|VMSC_GETVX|VMSC_NOWAIT)) {
 912                         case VMSC_GETVP:
 913                         case VMSC_GETVP|VMSC_NOWAIT:
 914                                 vput(vp);
 915                                 break;
 916                         case VMSC_GETVX:
 917                                 vx_put(vp);
 918                                 break;
 919                         default:
 920                                 break;
 921                         }
 922                         if (r != 0)
 923                                 break;
 924                 }
 925
 926 next:
 927                 /*
 928                  * Yield after some processing.  Depending on the number
 929                  * of vnodes, we might wind up running for a long time.
 930                  * Because threads are not preemptable, time critical
 931                  * userland processes might starve.  Give them a chance
 932                  * now and then.
 933                  */
 934                 if (++count == 10000) {
 935                         /*
 936                          * We really want to yield a bit, so we simply
 937                          * sleep a tick
 938                          */
 939                         tsleep(mp, 0, "vnodescn", 1);
 940                         count = 0;
 941                 }
 942
 943                 /*
 944                  * If doing one pass this decrements to zero.  If it starts
 945                  * at zero it is effectively unlimited for the purposes of
 946                  * this loop.
 947                  */
 948                 if (--stopcount == 0)
 949                         break;
 950
 951                 /*
 952                  * Iterate.  If the vnode was ripped out from under us
 953                  * info.vp will already point to the next vnode, otherwise
 954                  * we have to obtain the next valid vnode ourselves.
 955                  */
 956                 if (info.vp == vp)
 957                         info.vp = TAILQ_NEXT(vp, v_nmntvnodes);
 958         }
 959
 960         TAILQ_REMOVE(&mp->mnt_vnodescan_list, &info, entry);
 961         lwkt_reltoken(&mp->mnt_token);
 962         return(r);
 963 }
 964
 965 /*
 966  * Remove any vnodes in the vnode table belonging to mount point mp.
 967  *
 968  * If FORCECLOSE is not specified, there should not be any active ones,
 969  * return error if any are found (nb: this is a user error, not a
 970  * system error). If FORCECLOSE is specified, detach any active vnodes
 971  * that are found.
 972  *
 973  * If WRITECLOSE is set, only flush out regular file vnodes open for
 974  * writing.
 975  *
 976  * SKIPSYSTEM causes any vnodes marked VSYSTEM to be skipped.
 977  *
 978  * `rootrefs' specifies the base reference count for the root vnode
 979  * of this filesystem. The root vnode is considered busy if its
 980  * v_refcnt exceeds this value. On a successful return, vflush()
 981  * will call vrele() on the root vnode exactly rootrefs times.
 982  * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
 983  * be zero.
 984  */
 985 #ifdef DIAGNOSTIC
 986 static int busyprt = 0;         /* print out busy vnodes */
 987 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
 988 #endif
 989
 990 static int vflush_scan(struct mount *mp, struct vnode *vp, void *data);
 991
 992 struct vflush_info {
 993         int flags;
 994         int busy;
 995         thread_t td;
 996 };
 997
 998 int
 999 vflush(struct mount *mp, int rootrefs, int flags)
1000 {
1001         struct thread *td = curthread;  /* XXX */
1002         struct vnode *rootvp = NULL;
1003         int error;
1004         struct vflush_info vflush_info;
1005
1006         if (rootrefs > 0) {
1007                 KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0,
1008                     ("vflush: bad args"));
1009                 /*
1010                  * Get the filesystem root vnode. We can vput() it
1011                  * immediately, since with rootrefs > 0, it won't go away.
1012                  */
1013                 if ((error = VFS_ROOT(mp, &rootvp)) != 0) {
1014                         if ((flags & FORCECLOSE) == 0)
1015                                 return (error);
1016                         rootrefs = 0;
1017                         /* continue anyway */
1018                 }
1019                 if (rootrefs)
1020                         vput(rootvp);
1021         }
1022
1023         vflush_info.busy = 0;
1024         vflush_info.flags = flags;
1025         vflush_info.td = td;
1026         vmntvnodescan(mp, VMSC_GETVX, NULL, vflush_scan, &vflush_info);
1027
1028         if (rootrefs > 0 && (flags & FORCECLOSE) == 0) {
1029                 /*
1030                  * If just the root vnode is busy, and if its refcount
1031                  * is equal to `rootrefs', then go ahead and kill it.
1032                  */
1033                 KASSERT(vflush_info.busy > 0, ("vflush: not busy"));
1034                 KASSERT(VREFCNT(rootvp) >= rootrefs, ("vflush: rootrefs"));
1035                 if (vflush_info.busy == 1 && VREFCNT(rootvp) == rootrefs) {
1036                         vx_lock(rootvp);
1037                         vgone_vxlocked(rootvp);
1038                         vx_unlock(rootvp);
1039                         vflush_info.busy = 0;
1040                 }
1041         }
1042         if (vflush_info.busy)
1043                 return (EBUSY);
1044         for (; rootrefs > 0; rootrefs--)
1045                 vrele(rootvp);
1046         return (0);
1047 }
1048
1049 /*
1050  * The scan callback is made with an VX locked vnode.
1051  */
1052 static int
1053 vflush_scan(struct mount *mp, struct vnode *vp, void *data)
1054 {
1055         struct vflush_info *info = data;
1056         struct vattr vattr;
1057         int flags = info->flags;
1058
1059         /*
1060          * Generally speaking try to deactivate on 0 refs (catch-all)
1061          */
1062         atomic_set_int(&vp->v_refcnt, VREF_FINALIZE);
1063
1064         /*
1065          * Skip over a vnodes marked VSYSTEM.
1066          */
1067         if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
1068                 return(0);
1069         }
1070
1071         /*
1072          * Do not force-close VCHR or VBLK vnodes
1073          */
1074         if (vp->v_type == VCHR || vp->v_type == VBLK)
1075                 flags &= ~(WRITECLOSE|FORCECLOSE);
1076
1077         /*
1078          * If WRITECLOSE is set, flush out unlinked but still open
1079          * files (even if open only for reading) and regular file
1080          * vnodes open for writing.
1081          */
1082         if ((flags & WRITECLOSE) &&
1083             (vp->v_type == VNON ||
1084             (VOP_GETATTR(vp, &vattr) == 0 &&
1085             vattr.va_nlink > 0)) &&
1086             (vp->v_writecount == 0 || vp->v_type != VREG)) {
1087                 return(0);
1088         }
1089
1090         /*
1091          * If we are the only holder (refcnt of 1) or the vnode is in
1092          * termination (refcnt < 0), we can vgone the vnode.
1093          */
1094         if (VREFCNT(vp) <= 1) {
1095                 vgone_vxlocked(vp);
1096                 return(0);
1097         }
1098
1099         /*
1100          * If FORCECLOSE is set, forcibly destroy the vnode and then move
1101          * it to a dummymount structure so vop_*() functions don't deref
1102          * a NULL pointer.
1103          */
1104         if (flags & FORCECLOSE) {
1105                 vhold(vp);
1106                 vgone_vxlocked(vp);
1107                 if (vp->v_mount == NULL)
1108                         insmntque(vp, &dummymount);
1109                 vdrop(vp);
1110                 return(0);
1111         }
1112         if (vp->v_type == VCHR || vp->v_type == VBLK)
1113                 kprintf("vflush: Warning, cannot destroy busy device vnode\n");
1114 #ifdef DIAGNOSTIC
1115         if (busyprt)
1116                 vprint("vflush: busy vnode", vp);
1117 #endif
1118         ++info->busy;
1119         return(0);
1120 }
1121
1122 void
1123 add_bio_ops(struct bio_ops *ops)
1124 {
1125         TAILQ_INSERT_TAIL(&bio_ops_list, ops, entry);
1126 }
1127
1128 void
1129 rem_bio_ops(struct bio_ops *ops)
1130 {
1131         TAILQ_REMOVE(&bio_ops_list, ops, entry);
1132 }
1133
1134 /*
1135  * This calls the bio_ops io_sync function either for a mount point
1136  * or generally.
1137  *
1138  * WARNING: softdeps is weirdly coded and just isn't happy unless
1139  * io_sync is called with a NULL mount from the general syncing code.
1140  */
1141 void
1142 bio_ops_sync(struct mount *mp)
1143 {
1144         struct bio_ops *ops;
1145
1146         if (mp) {
1147                 if ((ops = mp->mnt_bioops) != NULL)
1148                         ops->io_sync(mp);
1149         } else {
1150                 TAILQ_FOREACH(ops, &bio_ops_list, entry) {
1151                         ops->io_sync(NULL);
1152                 }
1153         }
1154 }
1155
1156 /*
1157  * Lookup a mount point by nch
1158  */
1159 struct mount *
1160 mount_get_by_nc(struct namecache *ncp)
1161 {
1162         struct mount *mp = NULL;
1163
1164         lwkt_gettoken_shared(&mountlist_token);
1165         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
1166                 if (ncp == mp->mnt_ncmountpt.ncp)
1167                         break;
1168         }
1169         lwkt_reltoken(&mountlist_token);
1170
1171         return (mp);
1172 }
1173