The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/vfs_mount.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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 

Cache object: 56cb4049aceb5cbcb013c8faa0e09eb0


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.