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