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_subr.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1989, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)vfs_subr.c  8.31 (Berkeley) 5/26/95
   35  */
   36 
   37 /*
   38  * External virtual filesystem routines
   39  */
   40 
   41 #include <sys/cdefs.h>
   42 __FBSDID("$FreeBSD: releng/8.2/sys/kern/vfs_subr.c 216096 2010-12-01 15:28:23Z kib $");
   43 
   44 #include "opt_ddb.h"
   45 
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/bio.h>
   49 #include <sys/buf.h>
   50 #include <sys/condvar.h>
   51 #include <sys/conf.h>
   52 #include <sys/dirent.h>
   53 #include <sys/event.h>
   54 #include <sys/eventhandler.h>
   55 #include <sys/extattr.h>
   56 #include <sys/file.h>
   57 #include <sys/fcntl.h>
   58 #include <sys/jail.h>
   59 #include <sys/kdb.h>
   60 #include <sys/kernel.h>
   61 #include <sys/kthread.h>
   62 #include <sys/lockf.h>
   63 #include <sys/malloc.h>
   64 #include <sys/mount.h>
   65 #include <sys/namei.h>
   66 #include <sys/priv.h>
   67 #include <sys/reboot.h>
   68 #include <sys/sleepqueue.h>
   69 #include <sys/stat.h>
   70 #include <sys/sysctl.h>
   71 #include <sys/syslog.h>
   72 #include <sys/vmmeter.h>
   73 #include <sys/vnode.h>
   74 
   75 #include <machine/stdarg.h>
   76 
   77 #include <security/mac/mac_framework.h>
   78 
   79 #include <vm/vm.h>
   80 #include <vm/vm_object.h>
   81 #include <vm/vm_extern.h>
   82 #include <vm/pmap.h>
   83 #include <vm/vm_map.h>
   84 #include <vm/vm_page.h>
   85 #include <vm/vm_kern.h>
   86 #include <vm/uma.h>
   87 
   88 #ifdef DDB
   89 #include <ddb/ddb.h>
   90 #endif
   91 
   92 #define WI_MPSAFEQ      0
   93 #define WI_GIANTQ       1
   94 
   95 static MALLOC_DEFINE(M_NETADDR, "subr_export_host", "Export host address structure");
   96 
   97 static void     delmntque(struct vnode *vp);
   98 static int      flushbuflist(struct bufv *bufv, int flags, struct bufobj *bo,
   99                     int slpflag, int slptimeo);
  100 static void     syncer_shutdown(void *arg, int howto);
  101 static int      vtryrecycle(struct vnode *vp);
  102 static void     vbusy(struct vnode *vp);
  103 static void     vinactive(struct vnode *, struct thread *);
  104 static void     v_incr_usecount(struct vnode *);
  105 static void     v_decr_usecount(struct vnode *);
  106 static void     v_decr_useonly(struct vnode *);
  107 static void     v_upgrade_usecount(struct vnode *);
  108 static void     vfree(struct vnode *);
  109 static void     vnlru_free(int);
  110 static void     vgonel(struct vnode *);
  111 static void     vfs_knllock(void *arg);
  112 static void     vfs_knlunlock(void *arg);
  113 static void     vfs_knl_assert_locked(void *arg);
  114 static void     vfs_knl_assert_unlocked(void *arg);
  115 static void     destroy_vpollinfo(struct vpollinfo *vi);
  116 
  117 /*
  118  * Number of vnodes in existence.  Increased whenever getnewvnode()
  119  * allocates a new vnode, decreased on vdestroy() called on VI_DOOMed
  120  * vnode.
  121  */
  122 static unsigned long    numvnodes;
  123 
  124 SYSCTL_LONG(_vfs, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0,
  125     "Number of vnodes in existence");
  126 
  127 /*
  128  * Conversion tables for conversion from vnode types to inode formats
  129  * and back.
  130  */
  131 enum vtype iftovt_tab[16] = {
  132         VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
  133         VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
  134 };
  135 int vttoif_tab[10] = {
  136         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
  137         S_IFSOCK, S_IFIFO, S_IFMT, S_IFMT
  138 };
  139 
  140 /*
  141  * List of vnodes that are ready for recycling.
  142  */
  143 static TAILQ_HEAD(freelst, vnode) vnode_free_list;
  144 
  145 /*
  146  * Free vnode target.  Free vnodes may simply be files which have been stat'd
  147  * but not read.  This is somewhat common, and a small cache of such files
  148  * should be kept to avoid recreation costs.
  149  */
  150 static u_long wantfreevnodes;
  151 SYSCTL_LONG(_vfs, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
  152 /* Number of vnodes in the free list. */
  153 static u_long freevnodes;
  154 SYSCTL_LONG(_vfs, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0,
  155     "Number of vnodes in the free list");
  156 
  157 static int vlru_allow_cache_src;
  158 SYSCTL_INT(_vfs, OID_AUTO, vlru_allow_cache_src, CTLFLAG_RW,
  159     &vlru_allow_cache_src, 0, "Allow vlru to reclaim source vnode");
  160 
  161 /*
  162  * Various variables used for debugging the new implementation of
  163  * reassignbuf().
  164  * XXX these are probably of (very) limited utility now.
  165  */
  166 static int reassignbufcalls;
  167 SYSCTL_INT(_vfs, OID_AUTO, reassignbufcalls, CTLFLAG_RW, &reassignbufcalls, 0,
  168     "Number of calls to reassignbuf");
  169 
  170 /*
  171  * Cache for the mount type id assigned to NFS.  This is used for
  172  * special checks in nfs/nfs_nqlease.c and vm/vnode_pager.c.
  173  */
  174 int     nfs_mount_type = -1;
  175 
  176 /* To keep more than one thread at a time from running vfs_getnewfsid */
  177 static struct mtx mntid_mtx;
  178 
  179 /*
  180  * Lock for any access to the following:
  181  *      vnode_free_list
  182  *      numvnodes
  183  *      freevnodes
  184  */
  185 static struct mtx vnode_free_list_mtx;
  186 
  187 /* Publicly exported FS */
  188 struct nfs_public nfs_pub;
  189 
  190 /* Zone for allocation of new vnodes - used exclusively by getnewvnode() */
  191 static uma_zone_t vnode_zone;
  192 static uma_zone_t vnodepoll_zone;
  193 
  194 /* Set to 1 to print out reclaim of active vnodes */
  195 int     prtactive;
  196 
  197 /*
  198  * The workitem queue.
  199  *
  200  * It is useful to delay writes of file data and filesystem metadata
  201  * for tens of seconds so that quickly created and deleted files need
  202  * not waste disk bandwidth being created and removed. To realize this,
  203  * we append vnodes to a "workitem" queue. When running with a soft
  204  * updates implementation, most pending metadata dependencies should
  205  * not wait for more than a few seconds. Thus, mounted on block devices
  206  * are delayed only about a half the time that file data is delayed.
  207  * Similarly, directory updates are more critical, so are only delayed
  208  * about a third the time that file data is delayed. Thus, there are
  209  * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
  210  * one each second (driven off the filesystem syncer process). The
  211  * syncer_delayno variable indicates the next queue that is to be processed.
  212  * Items that need to be processed soon are placed in this queue:
  213  *
  214  *      syncer_workitem_pending[syncer_delayno]
  215  *
  216  * A delay of fifteen seconds is done by placing the request fifteen
  217  * entries later in the queue:
  218  *
  219  *      syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
  220  *
  221  */
  222 static int syncer_delayno;
  223 static long syncer_mask;
  224 LIST_HEAD(synclist, bufobj);
  225 static struct synclist *syncer_workitem_pending[2];
  226 /*
  227  * The sync_mtx protects:
  228  *      bo->bo_synclist
  229  *      sync_vnode_count
  230  *      syncer_delayno
  231  *      syncer_state
  232  *      syncer_workitem_pending
  233  *      syncer_worklist_len
  234  *      rushjob
  235  */
  236 static struct mtx sync_mtx;
  237 static struct cv sync_wakeup;
  238 
  239 #define SYNCER_MAXDELAY         32
  240 static int syncer_maxdelay = SYNCER_MAXDELAY;   /* maximum delay time */
  241 static int syncdelay = 30;              /* max time to delay syncing data */
  242 static int filedelay = 30;              /* time to delay syncing files */
  243 SYSCTL_INT(_kern, OID_AUTO, filedelay, CTLFLAG_RW, &filedelay, 0,
  244     "Time to delay syncing files (in seconds)");
  245 static int dirdelay = 29;               /* time to delay syncing directories */
  246 SYSCTL_INT(_kern, OID_AUTO, dirdelay, CTLFLAG_RW, &dirdelay, 0,
  247     "Time to delay syncing directories (in seconds)");
  248 static int metadelay = 28;              /* time to delay syncing metadata */
  249 SYSCTL_INT(_kern, OID_AUTO, metadelay, CTLFLAG_RW, &metadelay, 0,
  250     "Time to delay syncing metadata (in seconds)");
  251 static int rushjob;             /* number of slots to run ASAP */
  252 static int stat_rush_requests;  /* number of times I/O speeded up */
  253 SYSCTL_INT(_debug, OID_AUTO, rush_requests, CTLFLAG_RW, &stat_rush_requests, 0,
  254     "Number of times I/O speeded up (rush requests)");
  255 
  256 /*
  257  * When shutting down the syncer, run it at four times normal speed.
  258  */
  259 #define SYNCER_SHUTDOWN_SPEEDUP         4
  260 static int sync_vnode_count;
  261 static int syncer_worklist_len;
  262 static enum { SYNCER_RUNNING, SYNCER_SHUTTING_DOWN, SYNCER_FINAL_DELAY }
  263     syncer_state;
  264 
  265 /*
  266  * Number of vnodes we want to exist at any one time.  This is mostly used
  267  * to size hash tables in vnode-related code.  It is normally not used in
  268  * getnewvnode(), as wantfreevnodes is normally nonzero.)
  269  *
  270  * XXX desiredvnodes is historical cruft and should not exist.
  271  */
  272 int desiredvnodes;
  273 SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW,
  274     &desiredvnodes, 0, "Maximum number of vnodes");
  275 SYSCTL_INT(_kern, OID_AUTO, minvnodes, CTLFLAG_RW,
  276     &wantfreevnodes, 0, "Minimum number of vnodes (legacy)");
  277 static int vnlru_nowhere;
  278 SYSCTL_INT(_debug, OID_AUTO, vnlru_nowhere, CTLFLAG_RW,
  279     &vnlru_nowhere, 0, "Number of times the vnlru process ran without success");
  280 
  281 /*
  282  * Macros to control when a vnode is freed and recycled.  All require
  283  * the vnode interlock.
  284  */
  285 #define VCANRECYCLE(vp) (((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
  286 #define VSHOULDFREE(vp) (!((vp)->v_iflag & VI_FREE) && !(vp)->v_holdcnt)
  287 #define VSHOULDBUSY(vp) (((vp)->v_iflag & VI_FREE) && (vp)->v_holdcnt)
  288 
  289 
  290 /*
  291  * Initialize the vnode management data structures.
  292  *
  293  * Reevaluate the following cap on the number of vnodes after the physical
  294  * memory size exceeds 512GB.  In the limit, as the physical memory size
  295  * grows, the ratio of physical pages to vnodes approaches sixteen to one.
  296  */
  297 #ifndef MAXVNODES_MAX
  298 #define MAXVNODES_MAX   (512 * (1024 * 1024 * 1024 / (int)PAGE_SIZE / 16))
  299 #endif
  300 static void
  301 vntblinit(void *dummy __unused)
  302 {
  303         int physvnodes, virtvnodes;
  304 
  305         /*
  306          * Desiredvnodes is a function of the physical memory size and the
  307          * kernel's heap size.  Generally speaking, it scales with the
  308          * physical memory size.  The ratio of desiredvnodes to physical pages
  309          * is one to four until desiredvnodes exceeds 98,304.  Thereafter, the
  310          * marginal ratio of desiredvnodes to physical pages is one to
  311          * sixteen.  However, desiredvnodes is limited by the kernel's heap
  312          * size.  The memory required by desiredvnodes vnodes and vm objects
  313          * may not exceed one seventh of the kernel's heap size.
  314          */
  315         physvnodes = maxproc + cnt.v_page_count / 16 + 3 * min(98304 * 4,
  316             cnt.v_page_count) / 16;
  317         virtvnodes = vm_kmem_size / (7 * (sizeof(struct vm_object) +
  318             sizeof(struct vnode)));
  319         desiredvnodes = min(physvnodes, virtvnodes);
  320         if (desiredvnodes > MAXVNODES_MAX) {
  321                 if (bootverbose)
  322                         printf("Reducing kern.maxvnodes %d -> %d\n",
  323                             desiredvnodes, MAXVNODES_MAX);
  324                 desiredvnodes = MAXVNODES_MAX;
  325         }
  326         wantfreevnodes = desiredvnodes / 4;
  327         mtx_init(&mntid_mtx, "mntid", NULL, MTX_DEF);
  328         TAILQ_INIT(&vnode_free_list);
  329         mtx_init(&vnode_free_list_mtx, "vnode_free_list", NULL, MTX_DEF);
  330         vnode_zone = uma_zcreate("VNODE", sizeof (struct vnode), NULL, NULL,
  331             NULL, NULL, UMA_ALIGN_PTR, 0);
  332         vnodepoll_zone = uma_zcreate("VNODEPOLL", sizeof (struct vpollinfo),
  333             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
  334         /*
  335          * Initialize the filesystem syncer.
  336          */
  337         syncer_workitem_pending[WI_MPSAFEQ] = hashinit(syncer_maxdelay, M_VNODE,
  338             &syncer_mask);
  339         syncer_workitem_pending[WI_GIANTQ] = hashinit(syncer_maxdelay, M_VNODE,
  340             &syncer_mask);
  341         syncer_maxdelay = syncer_mask + 1;
  342         mtx_init(&sync_mtx, "Syncer mtx", NULL, MTX_DEF);
  343         cv_init(&sync_wakeup, "syncer");
  344 }
  345 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_FIRST, vntblinit, NULL);
  346 
  347 
  348 /*
  349  * Mark a mount point as busy. Used to synchronize access and to delay
  350  * unmounting. Eventually, mountlist_mtx is not released on failure.
  351  */
  352 int
  353 vfs_busy(struct mount *mp, int flags)
  354 {
  355 
  356         MPASS((flags & ~MBF_MASK) == 0);
  357         CTR3(KTR_VFS, "%s: mp %p with flags %d", __func__, mp, flags);
  358 
  359         MNT_ILOCK(mp);
  360         MNT_REF(mp);
  361         /*
  362          * If mount point is currenly being unmounted, sleep until the
  363          * mount point fate is decided.  If thread doing the unmounting fails,
  364          * it will clear MNTK_UNMOUNT flag before waking us up, indicating
  365          * that this mount point has survived the unmount attempt and vfs_busy
  366          * should retry.  Otherwise the unmounter thread will set MNTK_REFEXPIRE
  367          * flag in addition to MNTK_UNMOUNT, indicating that mount point is
  368          * about to be really destroyed.  vfs_busy needs to release its
  369          * reference on the mount point in this case and return with ENOENT,
  370          * telling the caller that mount mount it tried to busy is no longer
  371          * valid.
  372          */
  373         while (mp->mnt_kern_flag & MNTK_UNMOUNT) {
  374                 if (flags & MBF_NOWAIT || mp->mnt_kern_flag & MNTK_REFEXPIRE) {
  375                         MNT_REL(mp);
  376                         MNT_IUNLOCK(mp);
  377                         CTR1(KTR_VFS, "%s: failed busying before sleeping",
  378                             __func__);
  379                         return (ENOENT);
  380                 }
  381                 if (flags & MBF_MNTLSTLOCK)
  382                         mtx_unlock(&mountlist_mtx);
  383                 mp->mnt_kern_flag |= MNTK_MWAIT;
  384                 msleep(mp, MNT_MTX(mp), PVFS, "vfs_busy", 0);
  385                 if (flags & MBF_MNTLSTLOCK)
  386                         mtx_lock(&mountlist_mtx);
  387         }
  388         if (flags & MBF_MNTLSTLOCK)
  389                 mtx_unlock(&mountlist_mtx);
  390         mp->mnt_lockref++;
  391         MNT_IUNLOCK(mp);
  392         return (0);
  393 }
  394 
  395 /*
  396  * Free a busy filesystem.
  397  */
  398 void
  399 vfs_unbusy(struct mount *mp)
  400 {
  401 
  402         CTR2(KTR_VFS, "%s: mp %p", __func__, mp);
  403         MNT_ILOCK(mp);
  404         MNT_REL(mp);
  405         KASSERT(mp->mnt_lockref > 0, ("negative mnt_lockref"));
  406         mp->mnt_lockref--;
  407         if (mp->mnt_lockref == 0 && (mp->mnt_kern_flag & MNTK_DRAINING) != 0) {
  408                 MPASS(mp->mnt_kern_flag & MNTK_UNMOUNT);
  409                 CTR1(KTR_VFS, "%s: waking up waiters", __func__);
  410                 mp->mnt_kern_flag &= ~MNTK_DRAINING;
  411                 wakeup(&mp->mnt_lockref);
  412         }
  413         MNT_IUNLOCK(mp);
  414 }
  415 
  416 /*
  417  * Lookup a mount point by filesystem identifier.
  418  */
  419 struct mount *
  420 vfs_getvfs(fsid_t *fsid)
  421 {
  422         struct mount *mp;
  423 
  424         CTR2(KTR_VFS, "%s: fsid %p", __func__, fsid);
  425         mtx_lock(&mountlist_mtx);
  426         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
  427                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
  428                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
  429                         vfs_ref(mp);
  430                         mtx_unlock(&mountlist_mtx);
  431                         return (mp);
  432                 }
  433         }
  434         mtx_unlock(&mountlist_mtx);
  435         CTR2(KTR_VFS, "%s: lookup failed for %p id", __func__, fsid);
  436         return ((struct mount *) 0);
  437 }
  438 
  439 /*
  440  * Lookup a mount point by filesystem identifier, busying it before
  441  * returning.
  442  */
  443 struct mount *
  444 vfs_busyfs(fsid_t *fsid)
  445 {
  446         struct mount *mp;
  447         int error;
  448 
  449         CTR2(KTR_VFS, "%s: fsid %p", __func__, fsid);
  450         mtx_lock(&mountlist_mtx);
  451         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
  452                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
  453                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
  454                         error = vfs_busy(mp, MBF_MNTLSTLOCK);
  455                         if (error) {
  456                                 mtx_unlock(&mountlist_mtx);
  457                                 return (NULL);
  458                         }
  459                         return (mp);
  460                 }
  461         }
  462         CTR2(KTR_VFS, "%s: lookup failed for %p id", __func__, fsid);
  463         mtx_unlock(&mountlist_mtx);
  464         return ((struct mount *) 0);
  465 }
  466 
  467 /*
  468  * Check if a user can access privileged mount options.
  469  */
  470 int
  471 vfs_suser(struct mount *mp, struct thread *td)
  472 {
  473         int error;
  474 
  475         /*
  476          * If the thread is jailed, but this is not a jail-friendly file
  477          * system, deny immediately.
  478          */
  479         if (!(mp->mnt_vfc->vfc_flags & VFCF_JAIL) && jailed(td->td_ucred))
  480                 return (EPERM);
  481 
  482         /*
  483          * If the file system was mounted outside the jail of the calling
  484          * thread, deny immediately.
  485          */
  486         if (prison_check(td->td_ucred, mp->mnt_cred) != 0)
  487                 return (EPERM);
  488 
  489         /*
  490          * If file system supports delegated administration, we don't check
  491          * for the PRIV_VFS_MOUNT_OWNER privilege - it will be better verified
  492          * by the file system itself.
  493          * If this is not the user that did original mount, we check for
  494          * the PRIV_VFS_MOUNT_OWNER privilege.
  495          */
  496         if (!(mp->mnt_vfc->vfc_flags & VFCF_DELEGADMIN) &&
  497             mp->mnt_cred->cr_uid != td->td_ucred->cr_uid) {
  498                 if ((error = priv_check(td, PRIV_VFS_MOUNT_OWNER)) != 0)
  499                         return (error);
  500         }
  501         return (0);
  502 }
  503 
  504 /*
  505  * Get a new unique fsid.  Try to make its val[0] unique, since this value
  506  * will be used to create fake device numbers for stat().  Also try (but
  507  * not so hard) make its val[0] unique mod 2^16, since some emulators only
  508  * support 16-bit device numbers.  We end up with unique val[0]'s for the
  509  * first 2^16 calls and unique val[0]'s mod 2^16 for the first 2^8 calls.
  510  *
  511  * Keep in mind that several mounts may be running in parallel.  Starting
  512  * the search one past where the previous search terminated is both a
  513  * micro-optimization and a defense against returning the same fsid to
  514  * different mounts.
  515  */
  516 void
  517 vfs_getnewfsid(struct mount *mp)
  518 {
  519         static u_int16_t mntid_base;
  520         struct mount *nmp;
  521         fsid_t tfsid;
  522         int mtype;
  523 
  524         CTR2(KTR_VFS, "%s: mp %p", __func__, mp);
  525         mtx_lock(&mntid_mtx);
  526         mtype = mp->mnt_vfc->vfc_typenum;
  527         tfsid.val[1] = mtype;
  528         mtype = (mtype & 0xFF) << 24;
  529         for (;;) {
  530                 tfsid.val[0] = makedev(255,
  531                     mtype | ((mntid_base & 0xFF00) << 8) | (mntid_base & 0xFF));
  532                 mntid_base++;
  533                 if ((nmp = vfs_getvfs(&tfsid)) == NULL)
  534                         break;
  535                 vfs_rel(nmp);
  536         }
  537         mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
  538         mp->mnt_stat.f_fsid.val[1] = tfsid.val[1];
  539         mtx_unlock(&mntid_mtx);
  540 }
  541 
  542 /*
  543  * Knob to control the precision of file timestamps:
  544  *
  545  *   0 = seconds only; nanoseconds zeroed.
  546  *   1 = seconds and nanoseconds, accurate within 1/HZ.
  547  *   2 = seconds and nanoseconds, truncated to microseconds.
  548  * >=3 = seconds and nanoseconds, maximum precision.
  549  */
  550 enum { TSP_SEC, TSP_HZ, TSP_USEC, TSP_NSEC };
  551 
  552 static int timestamp_precision = TSP_SEC;
  553 SYSCTL_INT(_vfs, OID_AUTO, timestamp_precision, CTLFLAG_RW,
  554     &timestamp_precision, 0, "File timestamp precision (0: seconds, "
  555     "1: sec + ns accurate to 1/HZ, 2: sec + ns truncated to ms, "
  556     "3+: sec + ns (max. precision))");
  557 
  558 /*
  559  * Get a current timestamp.
  560  */
  561 void
  562 vfs_timestamp(struct timespec *tsp)
  563 {
  564         struct timeval tv;
  565 
  566         switch (timestamp_precision) {
  567         case TSP_SEC:
  568                 tsp->tv_sec = time_second;
  569                 tsp->tv_nsec = 0;
  570                 break;
  571         case TSP_HZ:
  572                 getnanotime(tsp);
  573                 break;
  574         case TSP_USEC:
  575                 microtime(&tv);
  576                 TIMEVAL_TO_TIMESPEC(&tv, tsp);
  577                 break;
  578         case TSP_NSEC:
  579         default:
  580                 nanotime(tsp);
  581                 break;
  582         }
  583 }
  584 
  585 /*
  586  * Set vnode attributes to VNOVAL
  587  */
  588 void
  589 vattr_null(struct vattr *vap)
  590 {
  591 
  592         vap->va_type = VNON;
  593         vap->va_size = VNOVAL;
  594         vap->va_bytes = VNOVAL;
  595         vap->va_mode = VNOVAL;
  596         vap->va_nlink = VNOVAL;
  597         vap->va_uid = VNOVAL;
  598         vap->va_gid = VNOVAL;
  599         vap->va_fsid = VNOVAL;
  600         vap->va_fileid = VNOVAL;
  601         vap->va_blocksize = VNOVAL;
  602         vap->va_rdev = VNOVAL;
  603         vap->va_atime.tv_sec = VNOVAL;
  604         vap->va_atime.tv_nsec = VNOVAL;
  605         vap->va_mtime.tv_sec = VNOVAL;
  606         vap->va_mtime.tv_nsec = VNOVAL;
  607         vap->va_ctime.tv_sec = VNOVAL;
  608         vap->va_ctime.tv_nsec = VNOVAL;
  609         vap->va_birthtime.tv_sec = VNOVAL;
  610         vap->va_birthtime.tv_nsec = VNOVAL;
  611         vap->va_flags = VNOVAL;
  612         vap->va_gen = VNOVAL;
  613         vap->va_vaflags = 0;
  614 }
  615 
  616 /*
  617  * This routine is called when we have too many vnodes.  It attempts
  618  * to free <count> vnodes and will potentially free vnodes that still
  619  * have VM backing store (VM backing store is typically the cause
  620  * of a vnode blowout so we want to do this).  Therefore, this operation
  621  * is not considered cheap.
  622  *
  623  * A number of conditions may prevent a vnode from being reclaimed.
  624  * the buffer cache may have references on the vnode, a directory
  625  * vnode may still have references due to the namei cache representing
  626  * underlying files, or the vnode may be in active use.   It is not
  627  * desireable to reuse such vnodes.  These conditions may cause the
  628  * number of vnodes to reach some minimum value regardless of what
  629  * you set kern.maxvnodes to.  Do not set kern.maxvnodes too low.
  630  */
  631 static int
  632 vlrureclaim(struct mount *mp)
  633 {
  634         struct vnode *vp;
  635         int done;
  636         int trigger;
  637         int usevnodes;
  638         int count;
  639 
  640         /*
  641          * Calculate the trigger point, don't allow user
  642          * screwups to blow us up.   This prevents us from
  643          * recycling vnodes with lots of resident pages.  We
  644          * aren't trying to free memory, we are trying to
  645          * free vnodes.
  646          */
  647         usevnodes = desiredvnodes;
  648         if (usevnodes <= 0)
  649                 usevnodes = 1;
  650         trigger = cnt.v_page_count * 2 / usevnodes;
  651         done = 0;
  652         vn_start_write(NULL, &mp, V_WAIT);
  653         MNT_ILOCK(mp);
  654         count = mp->mnt_nvnodelistsize / 10 + 1;
  655         while (count != 0) {
  656                 vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
  657                 while (vp != NULL && vp->v_type == VMARKER)
  658                         vp = TAILQ_NEXT(vp, v_nmntvnodes);
  659                 if (vp == NULL)
  660                         break;
  661                 TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
  662                 TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
  663                 --count;
  664                 if (!VI_TRYLOCK(vp))
  665                         goto next_iter;
  666                 /*
  667                  * If it's been deconstructed already, it's still
  668                  * referenced, or it exceeds the trigger, skip it.
  669                  */
  670                 if (vp->v_usecount ||
  671                     (!vlru_allow_cache_src &&
  672                         !LIST_EMPTY(&(vp)->v_cache_src)) ||
  673                     (vp->v_iflag & VI_DOOMED) != 0 || (vp->v_object != NULL &&
  674                     vp->v_object->resident_page_count > trigger)) {
  675                         VI_UNLOCK(vp);
  676                         goto next_iter;
  677                 }
  678                 MNT_IUNLOCK(mp);
  679                 vholdl(vp);
  680                 if (VOP_LOCK(vp, LK_INTERLOCK|LK_EXCLUSIVE|LK_NOWAIT)) {
  681                         vdrop(vp);
  682                         goto next_iter_mntunlocked;
  683                 }
  684                 VI_LOCK(vp);
  685                 /*
  686                  * v_usecount may have been bumped after VOP_LOCK() dropped
  687                  * the vnode interlock and before it was locked again.
  688                  *
  689                  * It is not necessary to recheck VI_DOOMED because it can
  690                  * only be set by another thread that holds both the vnode
  691                  * lock and vnode interlock.  If another thread has the
  692                  * vnode lock before we get to VOP_LOCK() and obtains the
  693                  * vnode interlock after VOP_LOCK() drops the vnode
  694                  * interlock, the other thread will be unable to drop the
  695                  * vnode lock before our VOP_LOCK() call fails.
  696                  */
  697                 if (vp->v_usecount ||
  698                     (!vlru_allow_cache_src &&
  699                         !LIST_EMPTY(&(vp)->v_cache_src)) ||
  700                     (vp->v_object != NULL &&
  701                     vp->v_object->resident_page_count > trigger)) {
  702                         VOP_UNLOCK(vp, LK_INTERLOCK);
  703                         goto next_iter_mntunlocked;
  704                 }
  705                 KASSERT((vp->v_iflag & VI_DOOMED) == 0,
  706                     ("VI_DOOMED unexpectedly detected in vlrureclaim()"));
  707                 vgonel(vp);
  708                 VOP_UNLOCK(vp, 0);
  709                 vdropl(vp);
  710                 done++;
  711 next_iter_mntunlocked:
  712                 if ((count % 256) != 0)
  713                         goto relock_mnt;
  714                 goto yield;
  715 next_iter:
  716                 if ((count % 256) != 0)
  717                         continue;
  718                 MNT_IUNLOCK(mp);
  719 yield:
  720                 uio_yield();
  721 relock_mnt:
  722                 MNT_ILOCK(mp);
  723         }
  724         MNT_IUNLOCK(mp);
  725         vn_finished_write(mp);
  726         return done;
  727 }
  728 
  729 /*
  730  * Attempt to keep the free list at wantfreevnodes length.
  731  */
  732 static void
  733 vnlru_free(int count)
  734 {
  735         struct vnode *vp;
  736         int vfslocked;
  737 
  738         mtx_assert(&vnode_free_list_mtx, MA_OWNED);
  739         for (; count > 0; count--) {
  740                 vp = TAILQ_FIRST(&vnode_free_list);
  741                 /*
  742                  * The list can be modified while the free_list_mtx
  743                  * has been dropped and vp could be NULL here.
  744                  */
  745                 if (!vp)
  746                         break;
  747                 VNASSERT(vp->v_op != NULL, vp,
  748                     ("vnlru_free: vnode already reclaimed."));
  749                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  750                 /*
  751                  * Don't recycle if we can't get the interlock.
  752                  */
  753                 if (!VI_TRYLOCK(vp)) {
  754                         TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
  755                         continue;
  756                 }
  757                 VNASSERT(VCANRECYCLE(vp), vp,
  758                     ("vp inconsistent on freelist"));
  759                 freevnodes--;
  760                 vp->v_iflag &= ~VI_FREE;
  761                 vholdl(vp);
  762                 mtx_unlock(&vnode_free_list_mtx);
  763                 VI_UNLOCK(vp);
  764                 vfslocked = VFS_LOCK_GIANT(vp->v_mount);
  765                 vtryrecycle(vp);
  766                 VFS_UNLOCK_GIANT(vfslocked);
  767                 /*
  768                  * If the recycled succeeded this vdrop will actually free
  769                  * the vnode.  If not it will simply place it back on
  770                  * the free list.
  771                  */
  772                 vdrop(vp);
  773                 mtx_lock(&vnode_free_list_mtx);
  774         }
  775 }
  776 /*
  777  * Attempt to recycle vnodes in a context that is always safe to block.
  778  * Calling vlrurecycle() from the bowels of filesystem code has some
  779  * interesting deadlock problems.
  780  */
  781 static struct proc *vnlruproc;
  782 static int vnlruproc_sig;
  783 
  784 static void
  785 vnlru_proc(void)
  786 {
  787         struct mount *mp, *nmp;
  788         int done, vfslocked;
  789         struct proc *p = vnlruproc;
  790 
  791         EVENTHANDLER_REGISTER(shutdown_pre_sync, kproc_shutdown, p,
  792             SHUTDOWN_PRI_FIRST);
  793 
  794         for (;;) {
  795                 kproc_suspend_check(p);
  796                 mtx_lock(&vnode_free_list_mtx);
  797                 if (freevnodes > wantfreevnodes)
  798                         vnlru_free(freevnodes - wantfreevnodes);
  799                 if (numvnodes <= desiredvnodes * 9 / 10) {
  800                         vnlruproc_sig = 0;
  801                         wakeup(&vnlruproc_sig);
  802                         msleep(vnlruproc, &vnode_free_list_mtx,
  803                             PVFS|PDROP, "vlruwt", hz);
  804                         continue;
  805                 }
  806                 mtx_unlock(&vnode_free_list_mtx);
  807                 done = 0;
  808                 mtx_lock(&mountlist_mtx);
  809                 for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
  810                         if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK)) {
  811                                 nmp = TAILQ_NEXT(mp, mnt_list);
  812                                 continue;
  813                         }
  814                         vfslocked = VFS_LOCK_GIANT(mp);
  815                         done += vlrureclaim(mp);
  816                         VFS_UNLOCK_GIANT(vfslocked);
  817                         mtx_lock(&mountlist_mtx);
  818                         nmp = TAILQ_NEXT(mp, mnt_list);
  819                         vfs_unbusy(mp);
  820                 }
  821                 mtx_unlock(&mountlist_mtx);
  822                 if (done == 0) {
  823 #if 0
  824                         /* These messages are temporary debugging aids */
  825                         if (vnlru_nowhere < 5)
  826                                 printf("vnlru process getting nowhere..\n");
  827                         else if (vnlru_nowhere == 5)
  828                                 printf("vnlru process messages stopped.\n");
  829 #endif
  830                         vnlru_nowhere++;
  831                         tsleep(vnlruproc, PPAUSE, "vlrup", hz * 3);
  832                 } else
  833                         uio_yield();
  834         }
  835 }
  836 
  837 static struct kproc_desc vnlru_kp = {
  838         "vnlru",
  839         vnlru_proc,
  840         &vnlruproc
  841 };
  842 SYSINIT(vnlru, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start,
  843     &vnlru_kp);
  844  
  845 /*
  846  * Routines having to do with the management of the vnode table.
  847  */
  848 
  849 void
  850 vdestroy(struct vnode *vp)
  851 {
  852         struct bufobj *bo;
  853 
  854         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
  855         mtx_lock(&vnode_free_list_mtx);
  856         numvnodes--;
  857         mtx_unlock(&vnode_free_list_mtx);
  858         bo = &vp->v_bufobj;
  859         VNASSERT((vp->v_iflag & VI_FREE) == 0, vp,
  860             ("cleaned vnode still on the free list."));
  861         VNASSERT(vp->v_data == NULL, vp, ("cleaned vnode isn't"));
  862         VNASSERT(vp->v_holdcnt == 0, vp, ("Non-zero hold count"));
  863         VNASSERT(vp->v_usecount == 0, vp, ("Non-zero use count"));
  864         VNASSERT(vp->v_writecount == 0, vp, ("Non-zero write count"));
  865         VNASSERT(bo->bo_numoutput == 0, vp, ("Clean vnode has pending I/O's"));
  866         VNASSERT(bo->bo_clean.bv_cnt == 0, vp, ("cleanbufcnt not 0"));
  867         VNASSERT(bo->bo_clean.bv_root == NULL, vp, ("cleanblkroot not NULL"));
  868         VNASSERT(bo->bo_dirty.bv_cnt == 0, vp, ("dirtybufcnt not 0"));
  869         VNASSERT(bo->bo_dirty.bv_root == NULL, vp, ("dirtyblkroot not NULL"));
  870         VNASSERT(TAILQ_EMPTY(&vp->v_cache_dst), vp, ("vp has namecache dst"));
  871         VNASSERT(LIST_EMPTY(&vp->v_cache_src), vp, ("vp has namecache src"));
  872         VNASSERT(vp->v_cache_dd == NULL, vp, ("vp has namecache for .."));
  873         VI_UNLOCK(vp);
  874 #ifdef MAC
  875         mac_vnode_destroy(vp);
  876 #endif
  877         if (vp->v_pollinfo != NULL)
  878                 destroy_vpollinfo(vp->v_pollinfo);
  879 #ifdef INVARIANTS
  880         /* XXX Elsewhere we can detect an already freed vnode via NULL v_op. */
  881         vp->v_op = NULL;
  882 #endif
  883         lockdestroy(vp->v_vnlock);
  884         mtx_destroy(&vp->v_interlock);
  885         mtx_destroy(BO_MTX(bo));
  886         uma_zfree(vnode_zone, vp);
  887 }
  888 
  889 /*
  890  * Try to recycle a freed vnode.  We abort if anyone picks up a reference
  891  * before we actually vgone().  This function must be called with the vnode
  892  * held to prevent the vnode from being returned to the free list midway
  893  * through vgone().
  894  */
  895 static int
  896 vtryrecycle(struct vnode *vp)
  897 {
  898         struct mount *vnmp;
  899 
  900         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
  901         VNASSERT(vp->v_holdcnt, vp,
  902             ("vtryrecycle: Recycling vp %p without a reference.", vp));
  903         /*
  904          * This vnode may found and locked via some other list, if so we
  905          * can't recycle it yet.
  906          */
  907         if (VOP_LOCK(vp, LK_EXCLUSIVE | LK_NOWAIT) != 0) {
  908                 CTR2(KTR_VFS,
  909                     "%s: impossible to recycle, vp %p lock is already held",
  910                     __func__, vp);
  911                 return (EWOULDBLOCK);
  912         }
  913         /*
  914          * Don't recycle if its filesystem is being suspended.
  915          */
  916         if (vn_start_write(vp, &vnmp, V_NOWAIT) != 0) {
  917                 VOP_UNLOCK(vp, 0);
  918                 CTR2(KTR_VFS,
  919                     "%s: impossible to recycle, cannot start the write for %p",
  920                     __func__, vp);
  921                 return (EBUSY);
  922         }
  923         /*
  924          * If we got this far, we need to acquire the interlock and see if
  925          * anyone picked up this vnode from another list.  If not, we will
  926          * mark it with DOOMED via vgonel() so that anyone who does find it
  927          * will skip over it.
  928          */
  929         VI_LOCK(vp);
  930         if (vp->v_usecount) {
  931                 VOP_UNLOCK(vp, LK_INTERLOCK);
  932                 vn_finished_write(vnmp);
  933                 CTR2(KTR_VFS,
  934                     "%s: impossible to recycle, %p is already referenced",
  935                     __func__, vp);
  936                 return (EBUSY);
  937         }
  938         if ((vp->v_iflag & VI_DOOMED) == 0)
  939                 vgonel(vp);
  940         VOP_UNLOCK(vp, LK_INTERLOCK);
  941         vn_finished_write(vnmp);
  942         return (0);
  943 }
  944 
  945 /*
  946  * Return the next vnode from the free list.
  947  */
  948 int
  949 getnewvnode(const char *tag, struct mount *mp, struct vop_vector *vops,
  950     struct vnode **vpp)
  951 {
  952         struct vnode *vp = NULL;
  953         struct bufobj *bo;
  954 
  955         CTR3(KTR_VFS, "%s: mp %p with tag %s", __func__, mp, tag);
  956         mtx_lock(&vnode_free_list_mtx);
  957         /*
  958          * Lend our context to reclaim vnodes if they've exceeded the max.
  959          */
  960         if (freevnodes > wantfreevnodes)
  961                 vnlru_free(1);
  962         /*
  963          * Wait for available vnodes.
  964          */
  965         if (numvnodes > desiredvnodes) {
  966                 if (mp != NULL && (mp->mnt_kern_flag & MNTK_SUSPEND)) {
  967                         /*
  968                          * File system is beeing suspended, we cannot risk a
  969                          * deadlock here, so allocate new vnode anyway.
  970                          */
  971                         if (freevnodes > wantfreevnodes)
  972                                 vnlru_free(freevnodes - wantfreevnodes);
  973                         goto alloc;
  974                 }
  975                 if (vnlruproc_sig == 0) {
  976                         vnlruproc_sig = 1;      /* avoid unnecessary wakeups */
  977                         wakeup(vnlruproc);
  978                 }
  979                 msleep(&vnlruproc_sig, &vnode_free_list_mtx, PVFS,
  980                     "vlruwk", hz);
  981 #if 0   /* XXX Not all VFS_VGET/ffs_vget callers check returns. */
  982                 if (numvnodes > desiredvnodes) {
  983                         mtx_unlock(&vnode_free_list_mtx);
  984                         return (ENFILE);
  985                 }
  986 #endif
  987         }
  988 alloc:
  989         numvnodes++;
  990         mtx_unlock(&vnode_free_list_mtx);
  991         vp = (struct vnode *) uma_zalloc(vnode_zone, M_WAITOK|M_ZERO);
  992         /*
  993          * Setup locks.
  994          */
  995         vp->v_vnlock = &vp->v_lock;
  996         mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
  997         /*
  998          * By default, don't allow shared locks unless filesystems
  999          * opt-in.
 1000          */
 1001         lockinit(vp->v_vnlock, PVFS, tag, VLKTIMEOUT, LK_NOSHARE);
 1002         /*
 1003          * Initialize bufobj.
 1004          */
 1005         bo = &vp->v_bufobj;
 1006         bo->__bo_vnode = vp;
 1007         mtx_init(BO_MTX(bo), "bufobj interlock", NULL, MTX_DEF);
 1008         bo->bo_ops = &buf_ops_bio;
 1009         bo->bo_private = vp;
 1010         TAILQ_INIT(&bo->bo_clean.bv_hd);
 1011         TAILQ_INIT(&bo->bo_dirty.bv_hd);
 1012         /*
 1013          * Initialize namecache.
 1014          */
 1015         LIST_INIT(&vp->v_cache_src);
 1016         TAILQ_INIT(&vp->v_cache_dst);
 1017         /*
 1018          * Finalize various vnode identity bits.
 1019          */
 1020         vp->v_type = VNON;
 1021         vp->v_tag = tag;
 1022         vp->v_op = vops;
 1023         v_incr_usecount(vp);
 1024         vp->v_data = 0;
 1025 #ifdef MAC
 1026         mac_vnode_init(vp);
 1027         if (mp != NULL && (mp->mnt_flag & MNT_MULTILABEL) == 0)
 1028                 mac_vnode_associate_singlelabel(mp, vp);
 1029         else if (mp == NULL && vops != &dead_vnodeops)
 1030                 printf("NULL mp in getnewvnode()\n");
 1031 #endif
 1032         if (mp != NULL) {
 1033                 bo->bo_bsize = mp->mnt_stat.f_iosize;
 1034                 if ((mp->mnt_kern_flag & MNTK_NOKNOTE) != 0)
 1035                         vp->v_vflag |= VV_NOKNOTE;
 1036         }
 1037 
 1038         *vpp = vp;
 1039         return (0);
 1040 }
 1041 
 1042 /*
 1043  * Delete from old mount point vnode list, if on one.
 1044  */
 1045 static void
 1046 delmntque(struct vnode *vp)
 1047 {
 1048         struct mount *mp;
 1049 
 1050         mp = vp->v_mount;
 1051         if (mp == NULL)
 1052                 return;
 1053         MNT_ILOCK(mp);
 1054         vp->v_mount = NULL;
 1055         VNASSERT(mp->mnt_nvnodelistsize > 0, vp,
 1056                 ("bad mount point vnode list size"));
 1057         TAILQ_REMOVE(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
 1058         mp->mnt_nvnodelistsize--;
 1059         MNT_REL(mp);
 1060         MNT_IUNLOCK(mp);
 1061 }
 1062 
 1063 static void
 1064 insmntque_stddtr(struct vnode *vp, void *dtr_arg)
 1065 {
 1066 
 1067         vp->v_data = NULL;
 1068         vp->v_op = &dead_vnodeops;
 1069         /* XXX non mp-safe fs may still call insmntque with vnode
 1070            unlocked */
 1071         if (!VOP_ISLOCKED(vp))
 1072                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 1073         vgone(vp);
 1074         vput(vp);
 1075 }
 1076 
 1077 /*
 1078  * Insert into list of vnodes for the new mount point, if available.
 1079  */
 1080 int
 1081 insmntque1(struct vnode *vp, struct mount *mp,
 1082         void (*dtr)(struct vnode *, void *), void *dtr_arg)
 1083 {
 1084         int locked;
 1085 
 1086         KASSERT(vp->v_mount == NULL,
 1087                 ("insmntque: vnode already on per mount vnode list"));
 1088         VNASSERT(mp != NULL, vp, ("Don't call insmntque(foo, NULL)"));
 1089 #ifdef DEBUG_VFS_LOCKS
 1090         if (!VFS_NEEDSGIANT(mp))
 1091                 ASSERT_VOP_ELOCKED(vp,
 1092                     "insmntque: mp-safe fs and non-locked vp");
 1093 #endif
 1094         MNT_ILOCK(mp);
 1095         if ((mp->mnt_kern_flag & MNTK_NOINSMNTQ) != 0 &&
 1096             ((mp->mnt_kern_flag & MNTK_UNMOUNTF) != 0 ||
 1097              mp->mnt_nvnodelistsize == 0)) {
 1098                 locked = VOP_ISLOCKED(vp);
 1099                 if (!locked || (locked == LK_EXCLUSIVE &&
 1100                      (vp->v_vflag & VV_FORCEINSMQ) == 0)) {
 1101                         MNT_IUNLOCK(mp);
 1102                         if (dtr != NULL)
 1103                                 dtr(vp, dtr_arg);
 1104                         return (EBUSY);
 1105                 }
 1106         }
 1107         vp->v_mount = mp;
 1108         MNT_REF(mp);
 1109         TAILQ_INSERT_TAIL(&mp->mnt_nvnodelist, vp, v_nmntvnodes);
 1110         VNASSERT(mp->mnt_nvnodelistsize >= 0, vp,
 1111                 ("neg mount point vnode list size"));
 1112         mp->mnt_nvnodelistsize++;
 1113         MNT_IUNLOCK(mp);
 1114         return (0);
 1115 }
 1116 
 1117 int
 1118 insmntque(struct vnode *vp, struct mount *mp)
 1119 {
 1120 
 1121         return (insmntque1(vp, mp, insmntque_stddtr, NULL));
 1122 }
 1123 
 1124 /*
 1125  * Flush out and invalidate all buffers associated with a bufobj
 1126  * Called with the underlying object locked.
 1127  */
 1128 int
 1129 bufobj_invalbuf(struct bufobj *bo, int flags, int slpflag, int slptimeo)
 1130 {
 1131         int error;
 1132 
 1133         BO_LOCK(bo);
 1134         if (flags & V_SAVE) {
 1135                 error = bufobj_wwait(bo, slpflag, slptimeo);
 1136                 if (error) {
 1137                         BO_UNLOCK(bo);
 1138                         return (error);
 1139                 }
 1140                 if (bo->bo_dirty.bv_cnt > 0) {
 1141                         BO_UNLOCK(bo);
 1142                         if ((error = BO_SYNC(bo, MNT_WAIT)) != 0)
 1143                                 return (error);
 1144                         /*
 1145                          * XXX We could save a lock/unlock if this was only
 1146                          * enabled under INVARIANTS
 1147                          */
 1148                         BO_LOCK(bo);
 1149                         if (bo->bo_numoutput > 0 || bo->bo_dirty.bv_cnt > 0)
 1150                                 panic("vinvalbuf: dirty bufs");
 1151                 }
 1152         }
 1153         /*
 1154          * If you alter this loop please notice that interlock is dropped and
 1155          * reacquired in flushbuflist.  Special care is needed to ensure that
 1156          * no race conditions occur from this.
 1157          */
 1158         do {
 1159                 error = flushbuflist(&bo->bo_clean,
 1160                     flags, bo, slpflag, slptimeo);
 1161                 if (error == 0)
 1162                         error = flushbuflist(&bo->bo_dirty,
 1163                             flags, bo, slpflag, slptimeo);
 1164                 if (error != 0 && error != EAGAIN) {
 1165                         BO_UNLOCK(bo);
 1166                         return (error);
 1167                 }
 1168         } while (error != 0);
 1169 
 1170         /*
 1171          * Wait for I/O to complete.  XXX needs cleaning up.  The vnode can
 1172          * have write I/O in-progress but if there is a VM object then the
 1173          * VM object can also have read-I/O in-progress.
 1174          */
 1175         do {
 1176                 bufobj_wwait(bo, 0, 0);
 1177                 BO_UNLOCK(bo);
 1178                 if (bo->bo_object != NULL) {
 1179                         VM_OBJECT_LOCK(bo->bo_object);
 1180                         vm_object_pip_wait(bo->bo_object, "bovlbx");
 1181                         VM_OBJECT_UNLOCK(bo->bo_object);
 1182                 }
 1183                 BO_LOCK(bo);
 1184         } while (bo->bo_numoutput > 0);
 1185         BO_UNLOCK(bo);
 1186 
 1187         /*
 1188          * Destroy the copy in the VM cache, too.
 1189          */
 1190         if (bo->bo_object != NULL && (flags & (V_ALT | V_NORMAL)) == 0) {
 1191                 VM_OBJECT_LOCK(bo->bo_object);
 1192                 vm_object_page_remove(bo->bo_object, 0, 0,
 1193                         (flags & V_SAVE) ? TRUE : FALSE);
 1194                 VM_OBJECT_UNLOCK(bo->bo_object);
 1195         }
 1196 
 1197 #ifdef INVARIANTS
 1198         BO_LOCK(bo);
 1199         if ((flags & (V_ALT | V_NORMAL)) == 0 &&
 1200             (bo->bo_dirty.bv_cnt > 0 || bo->bo_clean.bv_cnt > 0))
 1201                 panic("vinvalbuf: flush failed");
 1202         BO_UNLOCK(bo);
 1203 #endif
 1204         return (0);
 1205 }
 1206 
 1207 /*
 1208  * Flush out and invalidate all buffers associated with a vnode.
 1209  * Called with the underlying object locked.
 1210  */
 1211 int
 1212 vinvalbuf(struct vnode *vp, int flags, int slpflag, int slptimeo)
 1213 {
 1214 
 1215         CTR3(KTR_VFS, "%s: vp %p with flags %d", __func__, vp, flags);
 1216         ASSERT_VOP_LOCKED(vp, "vinvalbuf");
 1217         return (bufobj_invalbuf(&vp->v_bufobj, flags, slpflag, slptimeo));
 1218 }
 1219 
 1220 /*
 1221  * Flush out buffers on the specified list.
 1222  *
 1223  */
 1224 static int
 1225 flushbuflist( struct bufv *bufv, int flags, struct bufobj *bo, int slpflag,
 1226     int slptimeo)
 1227 {
 1228         struct buf *bp, *nbp;
 1229         int retval, error;
 1230         daddr_t lblkno;
 1231         b_xflags_t xflags;
 1232 
 1233         ASSERT_BO_LOCKED(bo);
 1234 
 1235         retval = 0;
 1236         TAILQ_FOREACH_SAFE(bp, &bufv->bv_hd, b_bobufs, nbp) {
 1237                 if (((flags & V_NORMAL) && (bp->b_xflags & BX_ALTDATA)) ||
 1238                     ((flags & V_ALT) && (bp->b_xflags & BX_ALTDATA) == 0)) {
 1239                         continue;
 1240                 }
 1241                 lblkno = 0;
 1242                 xflags = 0;
 1243                 if (nbp != NULL) {
 1244                         lblkno = nbp->b_lblkno;
 1245                         xflags = nbp->b_xflags &
 1246                                 (BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN);
 1247                 }
 1248                 retval = EAGAIN;
 1249                 error = BUF_TIMELOCK(bp,
 1250                     LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK, BO_MTX(bo),
 1251                     "flushbuf", slpflag, slptimeo);
 1252                 if (error) {
 1253                         BO_LOCK(bo);
 1254                         return (error != ENOLCK ? error : EAGAIN);
 1255                 }
 1256                 KASSERT(bp->b_bufobj == bo,
 1257                     ("bp %p wrong b_bufobj %p should be %p",
 1258                     bp, bp->b_bufobj, bo));
 1259                 if (bp->b_bufobj != bo) {       /* XXX: necessary ? */
 1260                         BUF_UNLOCK(bp);
 1261                         BO_LOCK(bo);
 1262                         return (EAGAIN);
 1263                 }
 1264                 /*
 1265                  * XXX Since there are no node locks for NFS, I
 1266                  * believe there is a slight chance that a delayed
 1267                  * write will occur while sleeping just above, so
 1268                  * check for it.
 1269                  */
 1270                 if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
 1271                     (flags & V_SAVE)) {
 1272                         BO_LOCK(bo);
 1273                         bremfree(bp);
 1274                         BO_UNLOCK(bo);
 1275                         bp->b_flags |= B_ASYNC;
 1276                         bwrite(bp);
 1277                         BO_LOCK(bo);
 1278                         return (EAGAIN);        /* XXX: why not loop ? */
 1279                 }
 1280                 BO_LOCK(bo);
 1281                 bremfree(bp);
 1282                 BO_UNLOCK(bo);
 1283                 bp->b_flags |= (B_INVAL | B_RELBUF);
 1284                 bp->b_flags &= ~B_ASYNC;
 1285                 brelse(bp);
 1286                 BO_LOCK(bo);
 1287                 if (nbp != NULL &&
 1288                     (nbp->b_bufobj != bo ||
 1289                      nbp->b_lblkno != lblkno ||
 1290                      (nbp->b_xflags &
 1291                       (BX_BKGRDMARKER | BX_VNDIRTY | BX_VNCLEAN)) != xflags))
 1292                         break;                  /* nbp invalid */
 1293         }
 1294         return (retval);
 1295 }
 1296 
 1297 /*
 1298  * Truncate a file's buffer and pages to a specified length.  This
 1299  * is in lieu of the old vinvalbuf mechanism, which performed unneeded
 1300  * sync activity.
 1301  */
 1302 int
 1303 vtruncbuf(struct vnode *vp, struct ucred *cred, struct thread *td,
 1304     off_t length, int blksize)
 1305 {
 1306         struct buf *bp, *nbp;
 1307         int anyfreed;
 1308         int trunclbn;
 1309         struct bufobj *bo;
 1310 
 1311         CTR5(KTR_VFS, "%s: vp %p with cred %p and block %d:%ju", __func__,
 1312             vp, cred, blksize, (uintmax_t)length);
 1313 
 1314         /*
 1315          * Round up to the *next* lbn.
 1316          */
 1317         trunclbn = (length + blksize - 1) / blksize;
 1318 
 1319         ASSERT_VOP_LOCKED(vp, "vtruncbuf");
 1320 restart:
 1321         bo = &vp->v_bufobj;
 1322         BO_LOCK(bo);
 1323         anyfreed = 1;
 1324         for (;anyfreed;) {
 1325                 anyfreed = 0;
 1326                 TAILQ_FOREACH_SAFE(bp, &bo->bo_clean.bv_hd, b_bobufs, nbp) {
 1327                         if (bp->b_lblkno < trunclbn)
 1328                                 continue;
 1329                         if (BUF_LOCK(bp,
 1330                             LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 1331                             BO_MTX(bo)) == ENOLCK)
 1332                                 goto restart;
 1333 
 1334                         BO_LOCK(bo);
 1335                         bremfree(bp);
 1336                         BO_UNLOCK(bo);
 1337                         bp->b_flags |= (B_INVAL | B_RELBUF);
 1338                         bp->b_flags &= ~B_ASYNC;
 1339                         brelse(bp);
 1340                         anyfreed = 1;
 1341 
 1342                         if (nbp != NULL &&
 1343                             (((nbp->b_xflags & BX_VNCLEAN) == 0) ||
 1344                             (nbp->b_vp != vp) ||
 1345                             (nbp->b_flags & B_DELWRI))) {
 1346                                 goto restart;
 1347                         }
 1348                         BO_LOCK(bo);
 1349                 }
 1350 
 1351                 TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
 1352                         if (bp->b_lblkno < trunclbn)
 1353                                 continue;
 1354                         if (BUF_LOCK(bp,
 1355                             LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 1356                             BO_MTX(bo)) == ENOLCK)
 1357                                 goto restart;
 1358                         BO_LOCK(bo);
 1359                         bremfree(bp);
 1360                         BO_UNLOCK(bo);
 1361                         bp->b_flags |= (B_INVAL | B_RELBUF);
 1362                         bp->b_flags &= ~B_ASYNC;
 1363                         brelse(bp);
 1364                         anyfreed = 1;
 1365                         if (nbp != NULL &&
 1366                             (((nbp->b_xflags & BX_VNDIRTY) == 0) ||
 1367                             (nbp->b_vp != vp) ||
 1368                             (nbp->b_flags & B_DELWRI) == 0)) {
 1369                                 goto restart;
 1370                         }
 1371                         BO_LOCK(bo);
 1372                 }
 1373         }
 1374 
 1375         if (length > 0) {
 1376 restartsync:
 1377                 TAILQ_FOREACH_SAFE(bp, &bo->bo_dirty.bv_hd, b_bobufs, nbp) {
 1378                         if (bp->b_lblkno > 0)
 1379                                 continue;
 1380                         /*
 1381                          * Since we hold the vnode lock this should only
 1382                          * fail if we're racing with the buf daemon.
 1383                          */
 1384                         if (BUF_LOCK(bp,
 1385                             LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
 1386                             BO_MTX(bo)) == ENOLCK) {
 1387                                 goto restart;
 1388                         }
 1389                         VNASSERT((bp->b_flags & B_DELWRI), vp,
 1390                             ("buf(%p) on dirty queue without DELWRI", bp));
 1391 
 1392                         BO_LOCK(bo);
 1393                         bremfree(bp);
 1394                         BO_UNLOCK(bo);
 1395                         bawrite(bp);
 1396                         BO_LOCK(bo);
 1397                         goto restartsync;
 1398                 }
 1399         }
 1400 
 1401         bufobj_wwait(bo, 0, 0);
 1402         BO_UNLOCK(bo);
 1403         vnode_pager_setsize(vp, length);
 1404 
 1405         return (0);
 1406 }
 1407 
 1408 /*
 1409  * buf_splay() - splay tree core for the clean/dirty list of buffers in
 1410  *               a vnode.
 1411  *
 1412  *      NOTE: We have to deal with the special case of a background bitmap
 1413  *      buffer, a situation where two buffers will have the same logical
 1414  *      block offset.  We want (1) only the foreground buffer to be accessed
 1415  *      in a lookup and (2) must differentiate between the foreground and
 1416  *      background buffer in the splay tree algorithm because the splay
 1417  *      tree cannot normally handle multiple entities with the same 'index'.
 1418  *      We accomplish this by adding differentiating flags to the splay tree's
 1419  *      numerical domain.
 1420  */
 1421 static
 1422 struct buf *
 1423 buf_splay(daddr_t lblkno, b_xflags_t xflags, struct buf *root)
 1424 {
 1425         struct buf dummy;
 1426         struct buf *lefttreemax, *righttreemin, *y;
 1427 
 1428         if (root == NULL)
 1429                 return (NULL);
 1430         lefttreemax = righttreemin = &dummy;
 1431         for (;;) {
 1432                 if (lblkno < root->b_lblkno ||
 1433                     (lblkno == root->b_lblkno &&
 1434                     (xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
 1435                         if ((y = root->b_left) == NULL)
 1436                                 break;
 1437                         if (lblkno < y->b_lblkno) {
 1438                                 /* Rotate right. */
 1439                                 root->b_left = y->b_right;
 1440                                 y->b_right = root;
 1441                                 root = y;
 1442                                 if ((y = root->b_left) == NULL)
 1443                                         break;
 1444                         }
 1445                         /* Link into the new root's right tree. */
 1446                         righttreemin->b_left = root;
 1447                         righttreemin = root;
 1448                 } else if (lblkno > root->b_lblkno ||
 1449                     (lblkno == root->b_lblkno &&
 1450                     (xflags & BX_BKGRDMARKER) > (root->b_xflags & BX_BKGRDMARKER))) {
 1451                         if ((y = root->b_right) == NULL)
 1452                                 break;
 1453                         if (lblkno > y->b_lblkno) {
 1454                                 /* Rotate left. */
 1455                                 root->b_right = y->b_left;
 1456                                 y->b_left = root;
 1457                                 root = y;
 1458                                 if ((y = root->b_right) == NULL)
 1459                                         break;
 1460                         }
 1461                         /* Link into the new root's left tree. */
 1462                         lefttreemax->b_right = root;
 1463                         lefttreemax = root;
 1464                 } else {
 1465                         break;
 1466                 }
 1467                 root = y;
 1468         }
 1469         /* Assemble the new root. */
 1470         lefttreemax->b_right = root->b_left;
 1471         righttreemin->b_left = root->b_right;
 1472         root->b_left = dummy.b_right;
 1473         root->b_right = dummy.b_left;
 1474         return (root);
 1475 }
 1476 
 1477 static void
 1478 buf_vlist_remove(struct buf *bp)
 1479 {
 1480         struct buf *root;
 1481         struct bufv *bv;
 1482 
 1483         KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
 1484         ASSERT_BO_LOCKED(bp->b_bufobj);
 1485         KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) !=
 1486             (BX_VNDIRTY|BX_VNCLEAN),
 1487             ("buf_vlist_remove: Buf %p is on two lists", bp));
 1488         if (bp->b_xflags & BX_VNDIRTY)
 1489                 bv = &bp->b_bufobj->bo_dirty;
 1490         else
 1491                 bv = &bp->b_bufobj->bo_clean;
 1492         if (bp != bv->bv_root) {
 1493                 root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
 1494                 KASSERT(root == bp, ("splay lookup failed in remove"));
 1495         }
 1496         if (bp->b_left == NULL) {
 1497                 root = bp->b_right;
 1498         } else {
 1499                 root = buf_splay(bp->b_lblkno, bp->b_xflags, bp->b_left);
 1500                 root->b_right = bp->b_right;
 1501         }
 1502         bv->bv_root = root;
 1503         TAILQ_REMOVE(&bv->bv_hd, bp, b_bobufs);
 1504         bv->bv_cnt--;
 1505         bp->b_xflags &= ~(BX_VNDIRTY | BX_VNCLEAN);
 1506 }
 1507 
 1508 /*
 1509  * Add the buffer to the sorted clean or dirty block list using a
 1510  * splay tree algorithm.
 1511  *
 1512  * NOTE: xflags is passed as a constant, optimizing this inline function!
 1513  */
 1514 static void
 1515 buf_vlist_add(struct buf *bp, struct bufobj *bo, b_xflags_t xflags)
 1516 {
 1517         struct buf *root;
 1518         struct bufv *bv;
 1519 
 1520         ASSERT_BO_LOCKED(bo);
 1521         KASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0,
 1522             ("buf_vlist_add: Buf %p has existing xflags %d", bp, bp->b_xflags));
 1523         bp->b_xflags |= xflags;
 1524         if (xflags & BX_VNDIRTY)
 1525                 bv = &bo->bo_dirty;
 1526         else
 1527                 bv = &bo->bo_clean;
 1528 
 1529         root = buf_splay(bp->b_lblkno, bp->b_xflags, bv->bv_root);
 1530         if (root == NULL) {
 1531                 bp->b_left = NULL;
 1532                 bp->b_right = NULL;
 1533                 TAILQ_INSERT_TAIL(&bv->bv_hd, bp, b_bobufs);
 1534         } else if (bp->b_lblkno < root->b_lblkno ||
 1535             (bp->b_lblkno == root->b_lblkno &&
 1536             (bp->b_xflags & BX_BKGRDMARKER) < (root->b_xflags & BX_BKGRDMARKER))) {
 1537                 bp->b_left = root->b_left;
 1538                 bp->b_right = root;
 1539                 root->b_left = NULL;
 1540                 TAILQ_INSERT_BEFORE(root, bp, b_bobufs);
 1541         } else {
 1542                 bp->b_right = root->b_right;
 1543                 bp->b_left = root;
 1544                 root->b_right = NULL;
 1545                 TAILQ_INSERT_AFTER(&bv->bv_hd, root, bp, b_bobufs);
 1546         }
 1547         bv->bv_cnt++;
 1548         bv->bv_root = bp;
 1549 }
 1550 
 1551 /*
 1552  * Lookup a buffer using the splay tree.  Note that we specifically avoid
 1553  * shadow buffers used in background bitmap writes.
 1554  *
 1555  * This code isn't quite efficient as it could be because we are maintaining
 1556  * two sorted lists and do not know which list the block resides in.
 1557  *
 1558  * During a "make buildworld" the desired buffer is found at one of
 1559  * the roots more than 60% of the time.  Thus, checking both roots
 1560  * before performing either splay eliminates unnecessary splays on the
 1561  * first tree splayed.
 1562  */
 1563 struct buf *
 1564 gbincore(struct bufobj *bo, daddr_t lblkno)
 1565 {
 1566         struct buf *bp;
 1567 
 1568         ASSERT_BO_LOCKED(bo);
 1569         if ((bp = bo->bo_clean.bv_root) != NULL &&
 1570             bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
 1571                 return (bp);
 1572         if ((bp = bo->bo_dirty.bv_root) != NULL &&
 1573             bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
 1574                 return (bp);
 1575         if ((bp = bo->bo_clean.bv_root) != NULL) {
 1576                 bo->bo_clean.bv_root = bp = buf_splay(lblkno, 0, bp);
 1577                 if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
 1578                         return (bp);
 1579         }
 1580         if ((bp = bo->bo_dirty.bv_root) != NULL) {
 1581                 bo->bo_dirty.bv_root = bp = buf_splay(lblkno, 0, bp);
 1582                 if (bp->b_lblkno == lblkno && !(bp->b_xflags & BX_BKGRDMARKER))
 1583                         return (bp);
 1584         }
 1585         return (NULL);
 1586 }
 1587 
 1588 /*
 1589  * Associate a buffer with a vnode.
 1590  */
 1591 void
 1592 bgetvp(struct vnode *vp, struct buf *bp)
 1593 {
 1594         struct bufobj *bo;
 1595 
 1596         bo = &vp->v_bufobj;
 1597         ASSERT_BO_LOCKED(bo);
 1598         VNASSERT(bp->b_vp == NULL, bp->b_vp, ("bgetvp: not free"));
 1599 
 1600         CTR3(KTR_BUF, "bgetvp(%p) vp %p flags %X", bp, vp, bp->b_flags);
 1601         VNASSERT((bp->b_xflags & (BX_VNDIRTY|BX_VNCLEAN)) == 0, vp,
 1602             ("bgetvp: bp already attached! %p", bp));
 1603 
 1604         vhold(vp);
 1605         if (VFS_NEEDSGIANT(vp->v_mount) || bo->bo_flag & BO_NEEDSGIANT)
 1606                 bp->b_flags |= B_NEEDSGIANT;
 1607         bp->b_vp = vp;
 1608         bp->b_bufobj = bo;
 1609         /*
 1610          * Insert onto list for new vnode.
 1611          */
 1612         buf_vlist_add(bp, bo, BX_VNCLEAN);
 1613 }
 1614 
 1615 /*
 1616  * Disassociate a buffer from a vnode.
 1617  */
 1618 void
 1619 brelvp(struct buf *bp)
 1620 {
 1621         struct bufobj *bo;
 1622         struct vnode *vp;
 1623 
 1624         CTR3(KTR_BUF, "brelvp(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
 1625         KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
 1626 
 1627         /*
 1628          * Delete from old vnode list, if on one.
 1629          */
 1630         vp = bp->b_vp;          /* XXX */
 1631         bo = bp->b_bufobj;
 1632         BO_LOCK(bo);
 1633         if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
 1634                 buf_vlist_remove(bp);
 1635         else
 1636                 panic("brelvp: Buffer %p not on queue.", bp);
 1637         if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
 1638                 bo->bo_flag &= ~BO_ONWORKLST;
 1639                 mtx_lock(&sync_mtx);
 1640                 LIST_REMOVE(bo, bo_synclist);
 1641                 syncer_worklist_len--;
 1642                 mtx_unlock(&sync_mtx);
 1643         }
 1644         bp->b_flags &= ~B_NEEDSGIANT;
 1645         bp->b_vp = NULL;
 1646         bp->b_bufobj = NULL;
 1647         BO_UNLOCK(bo);
 1648         vdrop(vp);
 1649 }
 1650 
 1651 /*
 1652  * Add an item to the syncer work queue.
 1653  */
 1654 static void
 1655 vn_syncer_add_to_worklist(struct bufobj *bo, int delay)
 1656 {
 1657         int queue, slot;
 1658 
 1659         ASSERT_BO_LOCKED(bo);
 1660 
 1661         mtx_lock(&sync_mtx);
 1662         if (bo->bo_flag & BO_ONWORKLST)
 1663                 LIST_REMOVE(bo, bo_synclist);
 1664         else {
 1665                 bo->bo_flag |= BO_ONWORKLST;
 1666                 syncer_worklist_len++;
 1667         }
 1668 
 1669         if (delay > syncer_maxdelay - 2)
 1670                 delay = syncer_maxdelay - 2;
 1671         slot = (syncer_delayno + delay) & syncer_mask;
 1672 
 1673         queue = VFS_NEEDSGIANT(bo->__bo_vnode->v_mount) ? WI_GIANTQ :
 1674             WI_MPSAFEQ;
 1675         LIST_INSERT_HEAD(&syncer_workitem_pending[queue][slot], bo,
 1676             bo_synclist);
 1677         mtx_unlock(&sync_mtx);
 1678 }
 1679 
 1680 static int
 1681 sysctl_vfs_worklist_len(SYSCTL_HANDLER_ARGS)
 1682 {
 1683         int error, len;
 1684 
 1685         mtx_lock(&sync_mtx);
 1686         len = syncer_worklist_len - sync_vnode_count;
 1687         mtx_unlock(&sync_mtx);
 1688         error = SYSCTL_OUT(req, &len, sizeof(len));
 1689         return (error);
 1690 }
 1691 
 1692 SYSCTL_PROC(_vfs, OID_AUTO, worklist_len, CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
 1693     sysctl_vfs_worklist_len, "I", "Syncer thread worklist length");
 1694 
 1695 static struct proc *updateproc;
 1696 static void sched_sync(void);
 1697 static struct kproc_desc up_kp = {
 1698         "syncer",
 1699         sched_sync,
 1700         &updateproc
 1701 };
 1702 SYSINIT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp);
 1703 
 1704 static int
 1705 sync_vnode(struct synclist *slp, struct bufobj **bo, struct thread *td)
 1706 {
 1707         struct vnode *vp;
 1708         struct mount *mp;
 1709 
 1710         *bo = LIST_FIRST(slp);
 1711         if (*bo == NULL)
 1712                 return (0);
 1713         vp = (*bo)->__bo_vnode; /* XXX */
 1714         if (VOP_ISLOCKED(vp) != 0 || VI_TRYLOCK(vp) == 0)
 1715                 return (1);
 1716         /*
 1717          * We use vhold in case the vnode does not
 1718          * successfully sync.  vhold prevents the vnode from
 1719          * going away when we unlock the sync_mtx so that
 1720          * we can acquire the vnode interlock.
 1721          */
 1722         vholdl(vp);
 1723         mtx_unlock(&sync_mtx);
 1724         VI_UNLOCK(vp);
 1725         if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
 1726                 vdrop(vp);
 1727                 mtx_lock(&sync_mtx);
 1728                 return (*bo == LIST_FIRST(slp));
 1729         }
 1730         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 1731         (void) VOP_FSYNC(vp, MNT_LAZY, td);
 1732         VOP_UNLOCK(vp, 0);
 1733         vn_finished_write(mp);
 1734         BO_LOCK(*bo);
 1735         if (((*bo)->bo_flag & BO_ONWORKLST) != 0) {
 1736                 /*
 1737                  * Put us back on the worklist.  The worklist
 1738                  * routine will remove us from our current
 1739                  * position and then add us back in at a later
 1740                  * position.
 1741                  */
 1742                 vn_syncer_add_to_worklist(*bo, syncdelay);
 1743         }
 1744         BO_UNLOCK(*bo);
 1745         vdrop(vp);
 1746         mtx_lock(&sync_mtx);
 1747         return (0);
 1748 }
 1749 
 1750 /*
 1751  * System filesystem synchronizer daemon.
 1752  */
 1753 static void
 1754 sched_sync(void)
 1755 {
 1756         struct synclist *gnext, *next;
 1757         struct synclist *gslp, *slp;
 1758         struct bufobj *bo;
 1759         long starttime;
 1760         struct thread *td = curthread;
 1761         int last_work_seen;
 1762         int net_worklist_len;
 1763         int syncer_final_iter;
 1764         int first_printf;
 1765         int error;
 1766 
 1767         last_work_seen = 0;
 1768         syncer_final_iter = 0;
 1769         first_printf = 1;
 1770         syncer_state = SYNCER_RUNNING;
 1771         starttime = time_uptime;
 1772         td->td_pflags |= TDP_NORUNNINGBUF;
 1773 
 1774         EVENTHANDLER_REGISTER(shutdown_pre_sync, syncer_shutdown, td->td_proc,
 1775             SHUTDOWN_PRI_LAST);
 1776 
 1777         mtx_lock(&sync_mtx);
 1778         for (;;) {
 1779                 if (syncer_state == SYNCER_FINAL_DELAY &&
 1780                     syncer_final_iter == 0) {
 1781                         mtx_unlock(&sync_mtx);
 1782                         kproc_suspend_check(td->td_proc);
 1783                         mtx_lock(&sync_mtx);
 1784                 }
 1785                 net_worklist_len = syncer_worklist_len - sync_vnode_count;
 1786                 if (syncer_state != SYNCER_RUNNING &&
 1787                     starttime != time_uptime) {
 1788                         if (first_printf) {
 1789                                 printf("\nSyncing disks, vnodes remaining...");
 1790                                 first_printf = 0;
 1791                         }
 1792                         printf("%d ", net_worklist_len);
 1793                 }
 1794                 starttime = time_uptime;
 1795 
 1796                 /*
 1797                  * Push files whose dirty time has expired.  Be careful
 1798                  * of interrupt race on slp queue.
 1799                  *
 1800                  * Skip over empty worklist slots when shutting down.
 1801                  */
 1802                 do {
 1803                         slp = &syncer_workitem_pending[WI_MPSAFEQ][syncer_delayno];
 1804                         gslp = &syncer_workitem_pending[WI_GIANTQ][syncer_delayno];
 1805                         syncer_delayno += 1;
 1806                         if (syncer_delayno == syncer_maxdelay)
 1807                                 syncer_delayno = 0;
 1808                         next = &syncer_workitem_pending[WI_MPSAFEQ][syncer_delayno];
 1809                         gnext = &syncer_workitem_pending[WI_GIANTQ][syncer_delayno];
 1810                         /*
 1811                          * If the worklist has wrapped since the
 1812                          * it was emptied of all but syncer vnodes,
 1813                          * switch to the FINAL_DELAY state and run
 1814                          * for one more second.
 1815                          */
 1816                         if (syncer_state == SYNCER_SHUTTING_DOWN &&
 1817                             net_worklist_len == 0 &&
 1818                             last_work_seen == syncer_delayno) {
 1819                                 syncer_state = SYNCER_FINAL_DELAY;
 1820                                 syncer_final_iter = SYNCER_SHUTDOWN_SPEEDUP;
 1821                         }
 1822                 } while (syncer_state != SYNCER_RUNNING && LIST_EMPTY(slp) &&
 1823                     LIST_EMPTY(gslp) && syncer_worklist_len > 0);
 1824 
 1825                 /*
 1826                  * Keep track of the last time there was anything
 1827                  * on the worklist other than syncer vnodes.
 1828                  * Return to the SHUTTING_DOWN state if any
 1829                  * new work appears.
 1830                  */
 1831                 if (net_worklist_len > 0 || syncer_state == SYNCER_RUNNING)
 1832                         last_work_seen = syncer_delayno;
 1833                 if (net_worklist_len > 0 && syncer_state == SYNCER_FINAL_DELAY)
 1834                         syncer_state = SYNCER_SHUTTING_DOWN;
 1835                 while (!LIST_EMPTY(slp)) {
 1836                         error = sync_vnode(slp, &bo, td);
 1837                         if (error == 1) {
 1838                                 LIST_REMOVE(bo, bo_synclist);
 1839                                 LIST_INSERT_HEAD(next, bo, bo_synclist);
 1840                                 continue;
 1841                         }
 1842                 }
 1843                 if (!LIST_EMPTY(gslp)) {
 1844                         mtx_unlock(&sync_mtx);
 1845                         mtx_lock(&Giant);
 1846                         mtx_lock(&sync_mtx);
 1847                         while (!LIST_EMPTY(gslp)) {
 1848                                 error = sync_vnode(gslp, &bo, td);
 1849                                 if (error == 1) {
 1850                                         LIST_REMOVE(bo, bo_synclist);
 1851                                         LIST_INSERT_HEAD(gnext, bo,
 1852                                             bo_synclist);
 1853                                         continue;
 1854                                 }
 1855                         }
 1856                         mtx_unlock(&Giant);
 1857                 }
 1858                 if (syncer_state == SYNCER_FINAL_DELAY && syncer_final_iter > 0)
 1859                         syncer_final_iter--;
 1860                 /*
 1861                  * The variable rushjob allows the kernel to speed up the
 1862                  * processing of the filesystem syncer process. A rushjob
 1863                  * value of N tells the filesystem syncer to process the next
 1864                  * N seconds worth of work on its queue ASAP. Currently rushjob
 1865                  * is used by the soft update code to speed up the filesystem
 1866                  * syncer process when the incore state is getting so far
 1867                  * ahead of the disk that the kernel memory pool is being
 1868                  * threatened with exhaustion.
 1869                  */
 1870                 if (rushjob > 0) {
 1871                         rushjob -= 1;
 1872                         continue;
 1873                 }
 1874                 /*
 1875                  * Just sleep for a short period of time between
 1876                  * iterations when shutting down to allow some I/O
 1877                  * to happen.
 1878                  *
 1879                  * If it has taken us less than a second to process the
 1880                  * current work, then wait. Otherwise start right over
 1881                  * again. We can still lose time if any single round
 1882                  * takes more than two seconds, but it does not really
 1883                  * matter as we are just trying to generally pace the
 1884                  * filesystem activity.
 1885                  */
 1886                 if (syncer_state != SYNCER_RUNNING)
 1887                         cv_timedwait(&sync_wakeup, &sync_mtx,
 1888                             hz / SYNCER_SHUTDOWN_SPEEDUP);
 1889                 else if (time_uptime == starttime)
 1890                         cv_timedwait(&sync_wakeup, &sync_mtx, hz);
 1891         }
 1892 }
 1893 
 1894 /*
 1895  * Request the syncer daemon to speed up its work.
 1896  * We never push it to speed up more than half of its
 1897  * normal turn time, otherwise it could take over the cpu.
 1898  */
 1899 int
 1900 speedup_syncer(void)
 1901 {
 1902         int ret = 0;
 1903 
 1904         mtx_lock(&sync_mtx);
 1905         if (rushjob < syncdelay / 2) {
 1906                 rushjob += 1;
 1907                 stat_rush_requests += 1;
 1908                 ret = 1;
 1909         }
 1910         mtx_unlock(&sync_mtx);
 1911         cv_broadcast(&sync_wakeup);
 1912         return (ret);
 1913 }
 1914 
 1915 /*
 1916  * Tell the syncer to speed up its work and run though its work
 1917  * list several times, then tell it to shut down.
 1918  */
 1919 static void
 1920 syncer_shutdown(void *arg, int howto)
 1921 {
 1922 
 1923         if (howto & RB_NOSYNC)
 1924                 return;
 1925         mtx_lock(&sync_mtx);
 1926         syncer_state = SYNCER_SHUTTING_DOWN;
 1927         rushjob = 0;
 1928         mtx_unlock(&sync_mtx);
 1929         cv_broadcast(&sync_wakeup);
 1930         kproc_shutdown(arg, howto);
 1931 }
 1932 
 1933 /*
 1934  * Reassign a buffer from one vnode to another.
 1935  * Used to assign file specific control information
 1936  * (indirect blocks) to the vnode to which they belong.
 1937  */
 1938 void
 1939 reassignbuf(struct buf *bp)
 1940 {
 1941         struct vnode *vp;
 1942         struct bufobj *bo;
 1943         int delay;
 1944 #ifdef INVARIANTS
 1945         struct bufv *bv;
 1946 #endif
 1947 
 1948         vp = bp->b_vp;
 1949         bo = bp->b_bufobj;
 1950         ++reassignbufcalls;
 1951 
 1952         CTR3(KTR_BUF, "reassignbuf(%p) vp %p flags %X",
 1953             bp, bp->b_vp, bp->b_flags);
 1954         /*
 1955          * B_PAGING flagged buffers cannot be reassigned because their vp
 1956          * is not fully linked in.
 1957          */
 1958         if (bp->b_flags & B_PAGING)
 1959                 panic("cannot reassign paging buffer");
 1960 
 1961         /*
 1962          * Delete from old vnode list, if on one.
 1963          */
 1964         BO_LOCK(bo);
 1965         if (bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN))
 1966                 buf_vlist_remove(bp);
 1967         else
 1968                 panic("reassignbuf: Buffer %p not on queue.", bp);
 1969         /*
 1970          * If dirty, put on list of dirty buffers; otherwise insert onto list
 1971          * of clean buffers.
 1972          */
 1973         if (bp->b_flags & B_DELWRI) {
 1974                 if ((bo->bo_flag & BO_ONWORKLST) == 0) {
 1975                         switch (vp->v_type) {
 1976                         case VDIR:
 1977                                 delay = dirdelay;
 1978                                 break;
 1979                         case VCHR:
 1980                                 delay = metadelay;
 1981                                 break;
 1982                         default:
 1983                                 delay = filedelay;
 1984                         }
 1985                         vn_syncer_add_to_worklist(bo, delay);
 1986                 }
 1987                 buf_vlist_add(bp, bo, BX_VNDIRTY);
 1988         } else {
 1989                 buf_vlist_add(bp, bo, BX_VNCLEAN);
 1990 
 1991                 if ((bo->bo_flag & BO_ONWORKLST) && bo->bo_dirty.bv_cnt == 0) {
 1992                         mtx_lock(&sync_mtx);
 1993                         LIST_REMOVE(bo, bo_synclist);
 1994                         syncer_worklist_len--;
 1995                         mtx_unlock(&sync_mtx);
 1996                         bo->bo_flag &= ~BO_ONWORKLST;
 1997                 }
 1998         }
 1999 #ifdef INVARIANTS
 2000         bv = &bo->bo_clean;
 2001         bp = TAILQ_FIRST(&bv->bv_hd);
 2002         KASSERT(bp == NULL || bp->b_bufobj == bo,
 2003             ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
 2004         bp = TAILQ_LAST(&bv->bv_hd, buflists);
 2005         KASSERT(bp == NULL || bp->b_bufobj == bo,
 2006             ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
 2007         bv = &bo->bo_dirty;
 2008         bp = TAILQ_FIRST(&bv->bv_hd);
 2009         KASSERT(bp == NULL || bp->b_bufobj == bo,
 2010             ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
 2011         bp = TAILQ_LAST(&bv->bv_hd, buflists);
 2012         KASSERT(bp == NULL || bp->b_bufobj == bo,
 2013             ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
 2014 #endif
 2015         BO_UNLOCK(bo);
 2016 }
 2017 
 2018 /*
 2019  * Increment the use and hold counts on the vnode, taking care to reference
 2020  * the driver's usecount if this is a chardev.  The vholdl() will remove
 2021  * the vnode from the free list if it is presently free.  Requires the
 2022  * vnode interlock and returns with it held.
 2023  */
 2024 static void
 2025 v_incr_usecount(struct vnode *vp)
 2026 {
 2027 
 2028         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2029         vp->v_usecount++;
 2030         if (vp->v_type == VCHR && vp->v_rdev != NULL) {
 2031                 dev_lock();
 2032                 vp->v_rdev->si_usecount++;
 2033                 dev_unlock();
 2034         }
 2035         vholdl(vp);
 2036 }
 2037 
 2038 /*
 2039  * Turn a holdcnt into a use+holdcnt such that only one call to
 2040  * v_decr_usecount is needed.
 2041  */
 2042 static void
 2043 v_upgrade_usecount(struct vnode *vp)
 2044 {
 2045 
 2046         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2047         vp->v_usecount++;
 2048         if (vp->v_type == VCHR && vp->v_rdev != NULL) {
 2049                 dev_lock();
 2050                 vp->v_rdev->si_usecount++;
 2051                 dev_unlock();
 2052         }
 2053 }
 2054 
 2055 /*
 2056  * Decrement the vnode use and hold count along with the driver's usecount
 2057  * if this is a chardev.  The vdropl() below releases the vnode interlock
 2058  * as it may free the vnode.
 2059  */
 2060 static void
 2061 v_decr_usecount(struct vnode *vp)
 2062 {
 2063 
 2064         ASSERT_VI_LOCKED(vp, __FUNCTION__);
 2065         VNASSERT(vp->v_usecount > 0, vp,
 2066             ("v_decr_usecount: negative usecount"));
 2067         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2068         vp->v_usecount--;
 2069         if (vp->v_type == VCHR && vp->v_rdev != NULL) {
 2070                 dev_lock();
 2071                 vp->v_rdev->si_usecount--;
 2072                 dev_unlock();
 2073         }
 2074         vdropl(vp);
 2075 }
 2076 
 2077 /*
 2078  * Decrement only the use count and driver use count.  This is intended to
 2079  * be paired with a follow on vdropl() to release the remaining hold count.
 2080  * In this way we may vgone() a vnode with a 0 usecount without risk of
 2081  * having it end up on a free list because the hold count is kept above 0.
 2082  */
 2083 static void
 2084 v_decr_useonly(struct vnode *vp)
 2085 {
 2086 
 2087         ASSERT_VI_LOCKED(vp, __FUNCTION__);
 2088         VNASSERT(vp->v_usecount > 0, vp,
 2089             ("v_decr_useonly: negative usecount"));
 2090         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2091         vp->v_usecount--;
 2092         if (vp->v_type == VCHR && vp->v_rdev != NULL) {
 2093                 dev_lock();
 2094                 vp->v_rdev->si_usecount--;
 2095                 dev_unlock();
 2096         }
 2097 }
 2098 
 2099 /*
 2100  * Grab a particular vnode from the free list, increment its
 2101  * reference count and lock it.  VI_DOOMED is set if the vnode
 2102  * is being destroyed.  Only callers who specify LK_RETRY will
 2103  * see doomed vnodes.  If inactive processing was delayed in
 2104  * vput try to do it here.
 2105  */
 2106 int
 2107 vget(struct vnode *vp, int flags, struct thread *td)
 2108 {
 2109         int error;
 2110 
 2111         error = 0;
 2112         VFS_ASSERT_GIANT(vp->v_mount);
 2113         VNASSERT((flags & LK_TYPE_MASK) != 0, vp,
 2114             ("vget: invalid lock operation"));
 2115         CTR3(KTR_VFS, "%s: vp %p with flags %d", __func__, vp, flags);
 2116 
 2117         if ((flags & LK_INTERLOCK) == 0)
 2118                 VI_LOCK(vp);
 2119         vholdl(vp);
 2120         if ((error = vn_lock(vp, flags | LK_INTERLOCK)) != 0) {
 2121                 vdrop(vp);
 2122                 CTR2(KTR_VFS, "%s: impossible to lock vnode %p", __func__,
 2123                     vp);
 2124                 return (error);
 2125         }
 2126         if (vp->v_iflag & VI_DOOMED && (flags & LK_RETRY) == 0)
 2127                 panic("vget: vn_lock failed to return ENOENT\n");
 2128         VI_LOCK(vp);
 2129         /* Upgrade our holdcnt to a usecount. */
 2130         v_upgrade_usecount(vp);
 2131         /*
 2132          * We don't guarantee that any particular close will
 2133          * trigger inactive processing so just make a best effort
 2134          * here at preventing a reference to a removed file.  If
 2135          * we don't succeed no harm is done.
 2136          */
 2137         if (vp->v_iflag & VI_OWEINACT) {
 2138                 if (VOP_ISLOCKED(vp) == LK_EXCLUSIVE && 
 2139                     (flags & LK_NOWAIT) == 0)
 2140                         vinactive(vp, td);
 2141                 vp->v_iflag &= ~VI_OWEINACT;
 2142         }
 2143         VI_UNLOCK(vp);
 2144         return (0);
 2145 }
 2146 
 2147 /*
 2148  * Increase the reference count of a vnode.
 2149  */
 2150 void
 2151 vref(struct vnode *vp)
 2152 {
 2153 
 2154         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2155         VI_LOCK(vp);
 2156         v_incr_usecount(vp);
 2157         VI_UNLOCK(vp);
 2158 }
 2159 
 2160 /*
 2161  * Return reference count of a vnode.
 2162  *
 2163  * The results of this call are only guaranteed when some mechanism other
 2164  * than the VI lock is used to stop other processes from gaining references
 2165  * to the vnode.  This may be the case if the caller holds the only reference.
 2166  * This is also useful when stale data is acceptable as race conditions may
 2167  * be accounted for by some other means.
 2168  */
 2169 int
 2170 vrefcnt(struct vnode *vp)
 2171 {
 2172         int usecnt;
 2173 
 2174         VI_LOCK(vp);
 2175         usecnt = vp->v_usecount;
 2176         VI_UNLOCK(vp);
 2177 
 2178         return (usecnt);
 2179 }
 2180 
 2181 #define VPUTX_VRELE     1
 2182 #define VPUTX_VPUT      2
 2183 #define VPUTX_VUNREF    3
 2184 
 2185 static void
 2186 vputx(struct vnode *vp, int func)
 2187 {
 2188         int error;
 2189 
 2190         KASSERT(vp != NULL, ("vputx: null vp"));
 2191         if (func == VPUTX_VUNREF)
 2192                 ASSERT_VOP_LOCKED(vp, "vunref");
 2193         else if (func == VPUTX_VPUT)
 2194                 ASSERT_VOP_LOCKED(vp, "vput");
 2195         else
 2196                 KASSERT(func == VPUTX_VRELE, ("vputx: wrong func"));
 2197         VFS_ASSERT_GIANT(vp->v_mount);
 2198         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2199         VI_LOCK(vp);
 2200 
 2201         /* Skip this v_writecount check if we're going to panic below. */
 2202         VNASSERT(vp->v_writecount < vp->v_usecount || vp->v_usecount < 1, vp,
 2203             ("vputx: missed vn_close"));
 2204         error = 0;
 2205 
 2206         if (vp->v_usecount > 1 || ((vp->v_iflag & VI_DOINGINACT) &&
 2207             vp->v_usecount == 1)) {
 2208                 if (func == VPUTX_VPUT)
 2209                         VOP_UNLOCK(vp, 0);
 2210                 v_decr_usecount(vp);
 2211                 return;
 2212         }
 2213 
 2214         if (vp->v_usecount != 1) {
 2215                 vprint("vputx: negative ref count", vp);
 2216                 panic("vputx: negative ref cnt");
 2217         }
 2218         CTR2(KTR_VFS, "%s: return vnode %p to the freelist", __func__, vp);
 2219         /*
 2220          * We want to hold the vnode until the inactive finishes to
 2221          * prevent vgone() races.  We drop the use count here and the
 2222          * hold count below when we're done.
 2223          */
 2224         v_decr_useonly(vp);
 2225         /*
 2226          * We must call VOP_INACTIVE with the node locked. Mark
 2227          * as VI_DOINGINACT to avoid recursion.
 2228          */
 2229         vp->v_iflag |= VI_OWEINACT;
 2230         switch (func) {
 2231         case VPUTX_VRELE:
 2232                 error = vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK);
 2233                 VI_LOCK(vp);
 2234                 break;
 2235         case VPUTX_VPUT:
 2236                 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE) {
 2237                         error = VOP_LOCK(vp, LK_UPGRADE | LK_INTERLOCK |
 2238                             LK_NOWAIT);
 2239                         VI_LOCK(vp);
 2240                 }
 2241                 break;
 2242         case VPUTX_VUNREF:
 2243                 if (VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 2244                         error = EBUSY;
 2245                 break;
 2246         }
 2247         if (vp->v_usecount > 0)
 2248                 vp->v_iflag &= ~VI_OWEINACT;
 2249         if (error == 0) {
 2250                 if (vp->v_iflag & VI_OWEINACT)
 2251                         vinactive(vp, curthread);
 2252                 if (func != VPUTX_VUNREF)
 2253                         VOP_UNLOCK(vp, 0);
 2254         }
 2255         vdropl(vp);
 2256 }
 2257 
 2258 /*
 2259  * Vnode put/release.
 2260  * If count drops to zero, call inactive routine and return to freelist.
 2261  */
 2262 void
 2263 vrele(struct vnode *vp)
 2264 {
 2265 
 2266         vputx(vp, VPUTX_VRELE);
 2267 }
 2268 
 2269 /*
 2270  * Release an already locked vnode.  This give the same effects as
 2271  * unlock+vrele(), but takes less time and avoids releasing and
 2272  * re-aquiring the lock (as vrele() acquires the lock internally.)
 2273  */
 2274 void
 2275 vput(struct vnode *vp)
 2276 {
 2277 
 2278         vputx(vp, VPUTX_VPUT);
 2279 }
 2280 
 2281 /*
 2282  * Release an exclusively locked vnode. Do not unlock the vnode lock.
 2283  */
 2284 void
 2285 vunref(struct vnode *vp)
 2286 {
 2287 
 2288         vputx(vp, VPUTX_VUNREF);
 2289 }
 2290 
 2291 /*
 2292  * Somebody doesn't want the vnode recycled.
 2293  */
 2294 void
 2295 vhold(struct vnode *vp)
 2296 {
 2297 
 2298         VI_LOCK(vp);
 2299         vholdl(vp);
 2300         VI_UNLOCK(vp);
 2301 }
 2302 
 2303 void
 2304 vholdl(struct vnode *vp)
 2305 {
 2306 
 2307         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2308         vp->v_holdcnt++;
 2309         if (VSHOULDBUSY(vp))
 2310                 vbusy(vp);
 2311 }
 2312 
 2313 /*
 2314  * Note that there is one less who cares about this vnode.  vdrop() is the
 2315  * opposite of vhold().
 2316  */
 2317 void
 2318 vdrop(struct vnode *vp)
 2319 {
 2320 
 2321         VI_LOCK(vp);
 2322         vdropl(vp);
 2323 }
 2324 
 2325 /*
 2326  * Drop the hold count of the vnode.  If this is the last reference to
 2327  * the vnode we will free it if it has been vgone'd otherwise it is
 2328  * placed on the free list.
 2329  */
 2330 void
 2331 vdropl(struct vnode *vp)
 2332 {
 2333 
 2334         ASSERT_VI_LOCKED(vp, "vdropl");
 2335         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2336         if (vp->v_holdcnt <= 0)
 2337                 panic("vdrop: holdcnt %d", vp->v_holdcnt);
 2338         vp->v_holdcnt--;
 2339         if (vp->v_holdcnt == 0) {
 2340                 if (vp->v_iflag & VI_DOOMED) {
 2341                         CTR2(KTR_VFS, "%s: destroying the vnode %p", __func__,
 2342                             vp);
 2343                         vdestroy(vp);
 2344                         return;
 2345                 } else
 2346                         vfree(vp);
 2347         }
 2348         VI_UNLOCK(vp);
 2349 }
 2350 
 2351 /*
 2352  * Call VOP_INACTIVE on the vnode and manage the DOINGINACT and OWEINACT
 2353  * flags.  DOINGINACT prevents us from recursing in calls to vinactive.
 2354  * OWEINACT tracks whether a vnode missed a call to inactive due to a
 2355  * failed lock upgrade.
 2356  */
 2357 static void
 2358 vinactive(struct vnode *vp, struct thread *td)
 2359 {
 2360 
 2361         ASSERT_VOP_ELOCKED(vp, "vinactive");
 2362         ASSERT_VI_LOCKED(vp, "vinactive");
 2363         VNASSERT((vp->v_iflag & VI_DOINGINACT) == 0, vp,
 2364             ("vinactive: recursed on VI_DOINGINACT"));
 2365         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2366         vp->v_iflag |= VI_DOINGINACT;
 2367         vp->v_iflag &= ~VI_OWEINACT;
 2368         VI_UNLOCK(vp);
 2369         VOP_INACTIVE(vp, td);
 2370         VI_LOCK(vp);
 2371         VNASSERT(vp->v_iflag & VI_DOINGINACT, vp,
 2372             ("vinactive: lost VI_DOINGINACT"));
 2373         vp->v_iflag &= ~VI_DOINGINACT;
 2374 }
 2375 
 2376 /*
 2377  * Remove any vnodes in the vnode table belonging to mount point mp.
 2378  *
 2379  * If FORCECLOSE is not specified, there should not be any active ones,
 2380  * return error if any are found (nb: this is a user error, not a
 2381  * system error). If FORCECLOSE is specified, detach any active vnodes
 2382  * that are found.
 2383  *
 2384  * If WRITECLOSE is set, only flush out regular file vnodes open for
 2385  * writing.
 2386  *
 2387  * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
 2388  *
 2389  * `rootrefs' specifies the base reference count for the root vnode
 2390  * of this filesystem. The root vnode is considered busy if its
 2391  * v_usecount exceeds this value. On a successful return, vflush(, td)
 2392  * will call vrele() on the root vnode exactly rootrefs times.
 2393  * If the SKIPSYSTEM or WRITECLOSE flags are specified, rootrefs must
 2394  * be zero.
 2395  */
 2396 #ifdef DIAGNOSTIC
 2397 static int busyprt = 0;         /* print out busy vnodes */
 2398 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "Print out busy vnodes");
 2399 #endif
 2400 
 2401 int
 2402 vflush( struct mount *mp, int rootrefs, int flags, struct thread *td)
 2403 {
 2404         struct vnode *vp, *mvp, *rootvp = NULL;
 2405         struct vattr vattr;
 2406         int busy = 0, error;
 2407 
 2408         CTR4(KTR_VFS, "%s: mp %p with rootrefs %d and flags %d", __func__, mp,
 2409             rootrefs, flags);
 2410         if (rootrefs > 0) {
 2411                 KASSERT((flags & (SKIPSYSTEM | WRITECLOSE)) == 0,
 2412                     ("vflush: bad args"));
 2413                 /*
 2414                  * Get the filesystem root vnode. We can vput() it
 2415                  * immediately, since with rootrefs > 0, it won't go away.
 2416                  */
 2417                 if ((error = VFS_ROOT(mp, LK_EXCLUSIVE, &rootvp)) != 0) {
 2418                         CTR2(KTR_VFS, "%s: vfs_root lookup failed with %d",
 2419                             __func__, error);
 2420                         return (error);
 2421                 }
 2422                 vput(rootvp);
 2423 
 2424         }
 2425         MNT_ILOCK(mp);
 2426 loop:
 2427         MNT_VNODE_FOREACH(vp, mp, mvp) {
 2428 
 2429                 VI_LOCK(vp);
 2430                 vholdl(vp);
 2431                 MNT_IUNLOCK(mp);
 2432                 error = vn_lock(vp, LK_INTERLOCK | LK_EXCLUSIVE);
 2433                 if (error) {
 2434                         vdrop(vp);
 2435                         MNT_ILOCK(mp);
 2436                         MNT_VNODE_FOREACH_ABORT_ILOCKED(mp, mvp);
 2437                         goto loop;
 2438                 }
 2439                 /*
 2440                  * Skip over a vnodes marked VV_SYSTEM.
 2441                  */
 2442                 if ((flags & SKIPSYSTEM) && (vp->v_vflag & VV_SYSTEM)) {
 2443                         VOP_UNLOCK(vp, 0);
 2444                         vdrop(vp);
 2445                         MNT_ILOCK(mp);
 2446                         continue;
 2447                 }
 2448                 /*
 2449                  * If WRITECLOSE is set, flush out unlinked but still open
 2450                  * files (even if open only for reading) and regular file
 2451                  * vnodes open for writing.
 2452                  */
 2453                 if (flags & WRITECLOSE) {
 2454                         error = VOP_GETATTR(vp, &vattr, td->td_ucred);
 2455                         VI_LOCK(vp);
 2456 
 2457                         if ((vp->v_type == VNON ||
 2458                             (error == 0 && vattr.va_nlink > 0)) &&
 2459                             (vp->v_writecount == 0 || vp->v_type != VREG)) {
 2460                                 VOP_UNLOCK(vp, 0);
 2461                                 vdropl(vp);
 2462                                 MNT_ILOCK(mp);
 2463                                 continue;
 2464                         }
 2465                 } else
 2466                         VI_LOCK(vp);
 2467                 /*
 2468                  * With v_usecount == 0, all we need to do is clear out the
 2469                  * vnode data structures and we are done.
 2470                  *
 2471                  * If FORCECLOSE is set, forcibly close the vnode.
 2472                  */
 2473                 if (vp->v_usecount == 0 || (flags & FORCECLOSE)) {
 2474                         VNASSERT(vp->v_usecount == 0 ||
 2475                             (vp->v_type != VCHR && vp->v_type != VBLK), vp,
 2476                             ("device VNODE %p is FORCECLOSED", vp));
 2477                         vgonel(vp);
 2478                 } else {
 2479                         busy++;
 2480 #ifdef DIAGNOSTIC
 2481                         if (busyprt)
 2482                                 vprint("vflush: busy vnode", vp);
 2483 #endif
 2484                 }
 2485                 VOP_UNLOCK(vp, 0);
 2486                 vdropl(vp);
 2487                 MNT_ILOCK(mp);
 2488         }
 2489         MNT_IUNLOCK(mp);
 2490         if (rootrefs > 0 && (flags & FORCECLOSE) == 0) {
 2491                 /*
 2492                  * If just the root vnode is busy, and if its refcount
 2493                  * is equal to `rootrefs', then go ahead and kill it.
 2494                  */
 2495                 VI_LOCK(rootvp);
 2496                 KASSERT(busy > 0, ("vflush: not busy"));
 2497                 VNASSERT(rootvp->v_usecount >= rootrefs, rootvp,
 2498                     ("vflush: usecount %d < rootrefs %d",
 2499                      rootvp->v_usecount, rootrefs));
 2500                 if (busy == 1 && rootvp->v_usecount == rootrefs) {
 2501                         VOP_LOCK(rootvp, LK_EXCLUSIVE|LK_INTERLOCK);
 2502                         vgone(rootvp);
 2503                         VOP_UNLOCK(rootvp, 0);
 2504                         busy = 0;
 2505                 } else
 2506                         VI_UNLOCK(rootvp);
 2507         }
 2508         if (busy) {
 2509                 CTR2(KTR_VFS, "%s: failing as %d vnodes are busy", __func__,
 2510                     busy);
 2511                 return (EBUSY);
 2512         }
 2513         for (; rootrefs > 0; rootrefs--)
 2514                 vrele(rootvp);
 2515         return (0);
 2516 }
 2517 
 2518 /*
 2519  * Recycle an unused vnode to the front of the free list.
 2520  */
 2521 int
 2522 vrecycle(struct vnode *vp, struct thread *td)
 2523 {
 2524         int recycled;
 2525 
 2526         ASSERT_VOP_ELOCKED(vp, "vrecycle");
 2527         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2528         recycled = 0;
 2529         VI_LOCK(vp);
 2530         if (vp->v_usecount == 0) {
 2531                 recycled = 1;
 2532                 vgonel(vp);
 2533         }
 2534         VI_UNLOCK(vp);
 2535         return (recycled);
 2536 }
 2537 
 2538 /*
 2539  * Eliminate all activity associated with a vnode
 2540  * in preparation for reuse.
 2541  */
 2542 void
 2543 vgone(struct vnode *vp)
 2544 {
 2545         VI_LOCK(vp);
 2546         vgonel(vp);
 2547         VI_UNLOCK(vp);
 2548 }
 2549 
 2550 /*
 2551  * vgone, with the vp interlock held.
 2552  */
 2553 void
 2554 vgonel(struct vnode *vp)
 2555 {
 2556         struct thread *td;
 2557         int oweinact;
 2558         int active;
 2559         struct mount *mp;
 2560 
 2561         ASSERT_VOP_ELOCKED(vp, "vgonel");
 2562         ASSERT_VI_LOCKED(vp, "vgonel");
 2563         VNASSERT(vp->v_holdcnt, vp,
 2564             ("vgonel: vp %p has no reference.", vp));
 2565         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 2566         td = curthread;
 2567 
 2568         /*
 2569          * Don't vgonel if we're already doomed.
 2570          */
 2571         if (vp->v_iflag & VI_DOOMED)
 2572                 return;
 2573         vp->v_iflag |= VI_DOOMED;
 2574         /*
 2575          * Check to see if the vnode is in use.  If so, we have to call
 2576          * VOP_CLOSE() and VOP_INACTIVE().
 2577          */
 2578         active = vp->v_usecount;
 2579         oweinact = (vp->v_iflag & VI_OWEINACT);
 2580         VI_UNLOCK(vp);
 2581         /*
 2582          * Clean out any buffers associated with the vnode.
 2583          * If the flush fails, just toss the buffers.
 2584          */
 2585         mp = NULL;
 2586         if (!TAILQ_EMPTY(&vp->v_bufobj.bo_dirty.bv_hd))
 2587                 (void) vn_start_secondary_write(vp, &mp, V_WAIT);
 2588         if (vinvalbuf(vp, V_SAVE, 0, 0) != 0)
 2589                 vinvalbuf(vp, 0, 0, 0);
 2590 
 2591         /*
 2592          * If purging an active vnode, it must be closed and
 2593          * deactivated before being reclaimed.
 2594          */
 2595         if (active)
 2596                 VOP_CLOSE(vp, FNONBLOCK, NOCRED, td);
 2597         if (oweinact || active) {
 2598                 VI_LOCK(vp);
 2599                 if ((vp->v_iflag & VI_DOINGINACT) == 0)
 2600                         vinactive(vp, td);
 2601                 VI_UNLOCK(vp);
 2602         }
 2603         /*
 2604          * Reclaim the vnode.
 2605          */
 2606         if (VOP_RECLAIM(vp, td))
 2607                 panic("vgone: cannot reclaim");
 2608         if (mp != NULL)
 2609                 vn_finished_secondary_write(mp);
 2610         VNASSERT(vp->v_object == NULL, vp,
 2611             ("vop_reclaim left v_object vp=%p, tag=%s", vp, vp->v_tag));
 2612         /*
 2613          * Clear the advisory locks and wake up waiting threads.
 2614          */
 2615         lf_purgelocks(vp, &(vp->v_lockf));
 2616         /*
 2617          * Delete from old mount point vnode list.
 2618          */
 2619         delmntque(vp);
 2620         cache_purge(vp);
 2621         /*
 2622          * Done with purge, reset to the standard lock and invalidate
 2623          * the vnode.
 2624          */
 2625         VI_LOCK(vp);
 2626         vp->v_vnlock = &vp->v_lock;
 2627         vp->v_op = &dead_vnodeops;
 2628         vp->v_tag = "none";
 2629         vp->v_type = VBAD;
 2630 }
 2631 
 2632 /*
 2633  * Calculate the total number of references to a special device.
 2634  */
 2635 int
 2636 vcount(struct vnode *vp)
 2637 {
 2638         int count;
 2639 
 2640         dev_lock();
 2641         count = vp->v_rdev->si_usecount;
 2642         dev_unlock();
 2643         return (count);
 2644 }
 2645 
 2646 /*
 2647  * Same as above, but using the struct cdev *as argument
 2648  */
 2649 int
 2650 count_dev(struct cdev *dev)
 2651 {
 2652         int count;
 2653 
 2654         dev_lock();
 2655         count = dev->si_usecount;
 2656         dev_unlock();
 2657         return(count);
 2658 }
 2659 
 2660 /*
 2661  * Print out a description of a vnode.
 2662  */
 2663 static char *typename[] =
 2664 {"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD",
 2665  "VMARKER"};
 2666 
 2667 void
 2668 vn_printf(struct vnode *vp, const char *fmt, ...)
 2669 {
 2670         va_list ap;
 2671         char buf[256], buf2[16];
 2672         u_long flags;
 2673 
 2674         va_start(ap, fmt);
 2675         vprintf(fmt, ap);
 2676         va_end(ap);
 2677         printf("%p: ", (void *)vp);
 2678         printf("tag %s, type %s\n", vp->v_tag, typename[vp->v_type]);
 2679         printf("    usecount %d, writecount %d, refcount %d mountedhere %p\n",
 2680             vp->v_usecount, vp->v_writecount, vp->v_holdcnt, vp->v_mountedhere);
 2681         buf[0] = '\0';
 2682         buf[1] = '\0';
 2683         if (vp->v_vflag & VV_ROOT)
 2684                 strlcat(buf, "|VV_ROOT", sizeof(buf));
 2685         if (vp->v_vflag & VV_ISTTY)
 2686                 strlcat(buf, "|VV_ISTTY", sizeof(buf));
 2687         if (vp->v_vflag & VV_NOSYNC)
 2688                 strlcat(buf, "|VV_NOSYNC", sizeof(buf));
 2689         if (vp->v_vflag & VV_CACHEDLABEL)
 2690                 strlcat(buf, "|VV_CACHEDLABEL", sizeof(buf));
 2691         if (vp->v_vflag & VV_TEXT)
 2692                 strlcat(buf, "|VV_TEXT", sizeof(buf));
 2693         if (vp->v_vflag & VV_COPYONWRITE)
 2694                 strlcat(buf, "|VV_COPYONWRITE", sizeof(buf));
 2695         if (vp->v_vflag & VV_SYSTEM)
 2696                 strlcat(buf, "|VV_SYSTEM", sizeof(buf));
 2697         if (vp->v_vflag & VV_PROCDEP)
 2698                 strlcat(buf, "|VV_PROCDEP", sizeof(buf));
 2699         if (vp->v_vflag & VV_NOKNOTE)
 2700                 strlcat(buf, "|VV_NOKNOTE", sizeof(buf));
 2701         if (vp->v_vflag & VV_DELETED)
 2702                 strlcat(buf, "|VV_DELETED", sizeof(buf));
 2703         if (vp->v_vflag & VV_MD)
 2704                 strlcat(buf, "|VV_MD", sizeof(buf));
 2705         flags = vp->v_vflag & ~(VV_ROOT | VV_ISTTY | VV_NOSYNC |
 2706             VV_CACHEDLABEL | VV_TEXT | VV_COPYONWRITE | VV_SYSTEM | VV_PROCDEP |
 2707             VV_NOKNOTE | VV_DELETED | VV_MD);
 2708         if (flags != 0) {
 2709                 snprintf(buf2, sizeof(buf2), "|VV(0x%lx)", flags);
 2710                 strlcat(buf, buf2, sizeof(buf));
 2711         }
 2712         if (vp->v_iflag & VI_MOUNT)
 2713                 strlcat(buf, "|VI_MOUNT", sizeof(buf));
 2714         if (vp->v_iflag & VI_AGE)
 2715                 strlcat(buf, "|VI_AGE", sizeof(buf));
 2716         if (vp->v_iflag & VI_DOOMED)
 2717                 strlcat(buf, "|VI_DOOMED", sizeof(buf));
 2718         if (vp->v_iflag & VI_FREE)
 2719                 strlcat(buf, "|VI_FREE", sizeof(buf));
 2720         if (vp->v_iflag & VI_DOINGINACT)
 2721                 strlcat(buf, "|VI_DOINGINACT", sizeof(buf));
 2722         if (vp->v_iflag & VI_OWEINACT)
 2723                 strlcat(buf, "|VI_OWEINACT", sizeof(buf));
 2724         flags = vp->v_iflag & ~(VI_MOUNT | VI_AGE | VI_DOOMED | VI_FREE |
 2725             VI_DOINGINACT | VI_OWEINACT);
 2726         if (flags != 0) {
 2727                 snprintf(buf2, sizeof(buf2), "|VI(0x%lx)", flags);
 2728                 strlcat(buf, buf2, sizeof(buf));
 2729         }
 2730         printf("    flags (%s)\n", buf + 1);
 2731         if (mtx_owned(VI_MTX(vp)))
 2732                 printf(" VI_LOCKed");
 2733         if (vp->v_object != NULL)
 2734                 printf("    v_object %p ref %d pages %d\n",
 2735                     vp->v_object, vp->v_object->ref_count,
 2736                     vp->v_object->resident_page_count);
 2737         printf("    ");
 2738         lockmgr_printinfo(vp->v_vnlock);
 2739         if (vp->v_data != NULL)
 2740                 VOP_PRINT(vp);
 2741 }
 2742 
 2743 #ifdef DDB
 2744 /*
 2745  * List all of the locked vnodes in the system.
 2746  * Called when debugging the kernel.
 2747  */
 2748 DB_SHOW_COMMAND(lockedvnods, lockedvnodes)
 2749 {
 2750         struct mount *mp, *nmp;
 2751         struct vnode *vp;
 2752 
 2753         /*
 2754          * Note: because this is DDB, we can't obey the locking semantics
 2755          * for these structures, which means we could catch an inconsistent
 2756          * state and dereference a nasty pointer.  Not much to be done
 2757          * about that.
 2758          */
 2759         db_printf("Locked vnodes\n");
 2760         for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
 2761                 nmp = TAILQ_NEXT(mp, mnt_list);
 2762                 TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
 2763                         if (vp->v_type != VMARKER &&
 2764                             VOP_ISLOCKED(vp))
 2765                                 vprint("", vp);
 2766                 }
 2767                 nmp = TAILQ_NEXT(mp, mnt_list);
 2768         }
 2769 }
 2770 
 2771 /*
 2772  * Show details about the given vnode.
 2773  */
 2774 DB_SHOW_COMMAND(vnode, db_show_vnode)
 2775 {
 2776         struct vnode *vp;
 2777 
 2778         if (!have_addr)
 2779                 return;
 2780         vp = (struct vnode *)addr;
 2781         vn_printf(vp, "vnode ");
 2782 }
 2783 
 2784 /*
 2785  * Show details about the given mount point.
 2786  */
 2787 DB_SHOW_COMMAND(mount, db_show_mount)
 2788 {
 2789         struct mount *mp;
 2790         struct vfsopt *opt;
 2791         struct statfs *sp;
 2792         struct vnode *vp;
 2793         char buf[512];
 2794         u_int flags;
 2795 
 2796         if (!have_addr) {
 2797                 /* No address given, print short info about all mount points. */
 2798                 TAILQ_FOREACH(mp, &mountlist, mnt_list) {
 2799                         db_printf("%p %s on %s (%s)\n", mp,
 2800                             mp->mnt_stat.f_mntfromname,
 2801                             mp->mnt_stat.f_mntonname,
 2802                             mp->mnt_stat.f_fstypename);
 2803                         if (db_pager_quit)
 2804                                 break;
 2805                 }
 2806                 db_printf("\nMore info: show mount <addr>\n");
 2807                 return;
 2808         }
 2809 
 2810         mp = (struct mount *)addr;
 2811         db_printf("%p %s on %s (%s)\n", mp, mp->mnt_stat.f_mntfromname,
 2812             mp->mnt_stat.f_mntonname, mp->mnt_stat.f_fstypename);
 2813 
 2814         buf[0] = '\0';
 2815         flags = mp->mnt_flag;
 2816 #define MNT_FLAG(flag)  do {                                            \
 2817         if (flags & (flag)) {                                           \
 2818                 if (buf[0] != '\0')                                     \
 2819                         strlcat(buf, ", ", sizeof(buf));                \
 2820                 strlcat(buf, (#flag) + 4, sizeof(buf));                 \
 2821                 flags &= ~(flag);                                       \
 2822         }                                                               \
 2823 } while (0)
 2824         MNT_FLAG(MNT_RDONLY);
 2825         MNT_FLAG(MNT_SYNCHRONOUS);
 2826         MNT_FLAG(MNT_NOEXEC);
 2827         MNT_FLAG(MNT_NOSUID);
 2828         MNT_FLAG(MNT_UNION);
 2829         MNT_FLAG(MNT_ASYNC);
 2830         MNT_FLAG(MNT_SUIDDIR);
 2831         MNT_FLAG(MNT_SOFTDEP);
 2832         MNT_FLAG(MNT_NOSYMFOLLOW);
 2833         MNT_FLAG(MNT_GJOURNAL);
 2834         MNT_FLAG(MNT_MULTILABEL);
 2835         MNT_FLAG(MNT_ACLS);
 2836         MNT_FLAG(MNT_NOATIME);
 2837         MNT_FLAG(MNT_NOCLUSTERR);
 2838         MNT_FLAG(MNT_NOCLUSTERW);
 2839         MNT_FLAG(MNT_NFS4ACLS);
 2840         MNT_FLAG(MNT_EXRDONLY);
 2841         MNT_FLAG(MNT_EXPORTED);
 2842         MNT_FLAG(MNT_DEFEXPORTED);
 2843         MNT_FLAG(MNT_EXPORTANON);
 2844         MNT_FLAG(MNT_EXKERB);
 2845         MNT_FLAG(MNT_EXPUBLIC);
 2846         MNT_FLAG(MNT_LOCAL);
 2847         MNT_FLAG(MNT_QUOTA);
 2848         MNT_FLAG(MNT_ROOTFS);
 2849         MNT_FLAG(MNT_USER);
 2850         MNT_FLAG(MNT_IGNORE);
 2851         MNT_FLAG(MNT_UPDATE);
 2852         MNT_FLAG(MNT_DELEXPORT);
 2853         MNT_FLAG(MNT_RELOAD);
 2854         MNT_FLAG(MNT_FORCE);
 2855         MNT_FLAG(MNT_SNAPSHOT);
 2856         MNT_FLAG(MNT_BYFSID);
 2857 #undef MNT_FLAG
 2858         if (flags != 0) {
 2859                 if (buf[0] != '\0')
 2860                         strlcat(buf, ", ", sizeof(buf));
 2861                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 2862                     "0x%08x", flags);
 2863         }
 2864         db_printf("    mnt_flag = %s\n", buf);
 2865 
 2866         buf[0] = '\0';
 2867         flags = mp->mnt_kern_flag;
 2868 #define MNT_KERN_FLAG(flag)     do {                                    \
 2869         if (flags & (flag)) {                                           \
 2870                 if (buf[0] != '\0')                                     \
 2871                         strlcat(buf, ", ", sizeof(buf));                \
 2872                 strlcat(buf, (#flag) + 5, sizeof(buf));                 \
 2873                 flags &= ~(flag);                                       \
 2874         }                                                               \
 2875 } while (0)
 2876         MNT_KERN_FLAG(MNTK_UNMOUNTF);
 2877         MNT_KERN_FLAG(MNTK_ASYNC);
 2878         MNT_KERN_FLAG(MNTK_SOFTDEP);
 2879         MNT_KERN_FLAG(MNTK_NOINSMNTQ);
 2880         MNT_KERN_FLAG(MNTK_UNMOUNT);
 2881         MNT_KERN_FLAG(MNTK_MWAIT);
 2882         MNT_KERN_FLAG(MNTK_SUSPEND);
 2883         MNT_KERN_FLAG(MNTK_SUSPEND2);
 2884         MNT_KERN_FLAG(MNTK_SUSPENDED);
 2885         MNT_KERN_FLAG(MNTK_MPSAFE);
 2886         MNT_KERN_FLAG(MNTK_NOKNOTE);
 2887         MNT_KERN_FLAG(MNTK_LOOKUP_SHARED);
 2888 #undef MNT_KERN_FLAG
 2889         if (flags != 0) {
 2890                 if (buf[0] != '\0')
 2891                         strlcat(buf, ", ", sizeof(buf));
 2892                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 2893                     "0x%08x", flags);
 2894         }
 2895         db_printf("    mnt_kern_flag = %s\n", buf);
 2896 
 2897         db_printf("    mnt_opt = ");
 2898         opt = TAILQ_FIRST(mp->mnt_opt);
 2899         if (opt != NULL) {
 2900                 db_printf("%s", opt->name);
 2901                 opt = TAILQ_NEXT(opt, link);
 2902                 while (opt != NULL) {
 2903                         db_printf(", %s", opt->name);
 2904                         opt = TAILQ_NEXT(opt, link);
 2905                 }
 2906         }
 2907         db_printf("\n");
 2908 
 2909         sp = &mp->mnt_stat;
 2910         db_printf("    mnt_stat = { version=%u type=%u flags=0x%016jx "
 2911             "bsize=%ju iosize=%ju blocks=%ju bfree=%ju bavail=%jd files=%ju "
 2912             "ffree=%jd syncwrites=%ju asyncwrites=%ju syncreads=%ju "
 2913             "asyncreads=%ju namemax=%u owner=%u fsid=[%d, %d] }\n",
 2914             (u_int)sp->f_version, (u_int)sp->f_type, (uintmax_t)sp->f_flags,
 2915             (uintmax_t)sp->f_bsize, (uintmax_t)sp->f_iosize,
 2916             (uintmax_t)sp->f_blocks, (uintmax_t)sp->f_bfree,
 2917             (intmax_t)sp->f_bavail, (uintmax_t)sp->f_files,
 2918             (intmax_t)sp->f_ffree, (uintmax_t)sp->f_syncwrites,
 2919             (uintmax_t)sp->f_asyncwrites, (uintmax_t)sp->f_syncreads,
 2920             (uintmax_t)sp->f_asyncreads, (u_int)sp->f_namemax,
 2921             (u_int)sp->f_owner, (int)sp->f_fsid.val[0], (int)sp->f_fsid.val[1]);
 2922 
 2923         db_printf("    mnt_cred = { uid=%u ruid=%u",
 2924             (u_int)mp->mnt_cred->cr_uid, (u_int)mp->mnt_cred->cr_ruid);
 2925         if (jailed(mp->mnt_cred))
 2926                 db_printf(", jail=%d", mp->mnt_cred->cr_prison->pr_id);
 2927         db_printf(" }\n");
 2928         db_printf("    mnt_ref = %d\n", mp->mnt_ref);
 2929         db_printf("    mnt_gen = %d\n", mp->mnt_gen);
 2930         db_printf("    mnt_nvnodelistsize = %d\n", mp->mnt_nvnodelistsize);
 2931         db_printf("    mnt_writeopcount = %d\n", mp->mnt_writeopcount);
 2932         db_printf("    mnt_noasync = %u\n", mp->mnt_noasync);
 2933         db_printf("    mnt_maxsymlinklen = %d\n", mp->mnt_maxsymlinklen);
 2934         db_printf("    mnt_iosize_max = %d\n", mp->mnt_iosize_max);
 2935         db_printf("    mnt_hashseed = %u\n", mp->mnt_hashseed);
 2936         db_printf("    mnt_secondary_writes = %d\n", mp->mnt_secondary_writes);
 2937         db_printf("    mnt_secondary_accwrites = %d\n",
 2938             mp->mnt_secondary_accwrites);
 2939         db_printf("    mnt_gjprovider = %s\n",
 2940             mp->mnt_gjprovider != NULL ? mp->mnt_gjprovider : "NULL");
 2941         db_printf("\n");
 2942 
 2943         TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
 2944                 if (vp->v_type != VMARKER) {
 2945                         vn_printf(vp, "vnode ");
 2946                         if (db_pager_quit)
 2947                                 break;
 2948                 }
 2949         }
 2950 }
 2951 #endif  /* DDB */
 2952 
 2953 /*
 2954  * Fill in a struct xvfsconf based on a struct vfsconf.
 2955  */
 2956 static void
 2957 vfsconf2x(struct vfsconf *vfsp, struct xvfsconf *xvfsp)
 2958 {
 2959 
 2960         strcpy(xvfsp->vfc_name, vfsp->vfc_name);
 2961         xvfsp->vfc_typenum = vfsp->vfc_typenum;
 2962         xvfsp->vfc_refcount = vfsp->vfc_refcount;
 2963         xvfsp->vfc_flags = vfsp->vfc_flags;
 2964         /*
 2965          * These are unused in userland, we keep them
 2966          * to not break binary compatibility.
 2967          */
 2968         xvfsp->vfc_vfsops = NULL;
 2969         xvfsp->vfc_next = NULL;
 2970 }
 2971 
 2972 /*
 2973  * Top level filesystem related information gathering.
 2974  */
 2975 static int
 2976 sysctl_vfs_conflist(SYSCTL_HANDLER_ARGS)
 2977 {
 2978         struct vfsconf *vfsp;
 2979         struct xvfsconf xvfsp;
 2980         int error;
 2981 
 2982         error = 0;
 2983         TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
 2984                 bzero(&xvfsp, sizeof(xvfsp));
 2985                 vfsconf2x(vfsp, &xvfsp);
 2986                 error = SYSCTL_OUT(req, &xvfsp, sizeof xvfsp);
 2987                 if (error)
 2988                         break;
 2989         }
 2990         return (error);
 2991 }
 2992 
 2993 SYSCTL_PROC(_vfs, OID_AUTO, conflist, CTLFLAG_RD, NULL, 0, sysctl_vfs_conflist,
 2994     "S,xvfsconf", "List of all configured filesystems");
 2995 
 2996 #ifndef BURN_BRIDGES
 2997 static int      sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS);
 2998 
 2999 static int
 3000 vfs_sysctl(SYSCTL_HANDLER_ARGS)
 3001 {
 3002         int *name = (int *)arg1 - 1;    /* XXX */
 3003         u_int namelen = arg2 + 1;       /* XXX */
 3004         struct vfsconf *vfsp;
 3005         struct xvfsconf xvfsp;
 3006 
 3007         printf("WARNING: userland calling deprecated sysctl, "
 3008             "please rebuild world\n");
 3009 
 3010 #if 1 || defined(COMPAT_PRELITE2)
 3011         /* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
 3012         if (namelen == 1)
 3013                 return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
 3014 #endif
 3015 
 3016         switch (name[1]) {
 3017         case VFS_MAXTYPENUM:
 3018                 if (namelen != 2)
 3019                         return (ENOTDIR);
 3020                 return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
 3021         case VFS_CONF:
 3022                 if (namelen != 3)
 3023                         return (ENOTDIR);       /* overloaded */
 3024                 TAILQ_FOREACH(vfsp, &vfsconf, vfc_list)
 3025                         if (vfsp->vfc_typenum == name[2])
 3026                                 break;
 3027                 if (vfsp == NULL)
 3028                         return (EOPNOTSUPP);
 3029                 bzero(&xvfsp, sizeof(xvfsp));
 3030                 vfsconf2x(vfsp, &xvfsp);
 3031                 return (SYSCTL_OUT(req, &xvfsp, sizeof(xvfsp)));
 3032         }
 3033         return (EOPNOTSUPP);
 3034 }
 3035 
 3036 static SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD | CTLFLAG_SKIP,
 3037     vfs_sysctl, "Generic filesystem");
 3038 
 3039 #if 1 || defined(COMPAT_PRELITE2)
 3040 
 3041 static int
 3042 sysctl_ovfs_conf(SYSCTL_HANDLER_ARGS)
 3043 {
 3044         int error;
 3045         struct vfsconf *vfsp;
 3046         struct ovfsconf ovfs;
 3047 
 3048         TAILQ_FOREACH(vfsp, &vfsconf, vfc_list) {
 3049                 bzero(&ovfs, sizeof(ovfs));
 3050                 ovfs.vfc_vfsops = vfsp->vfc_vfsops;     /* XXX used as flag */
 3051                 strcpy(ovfs.vfc_name, vfsp->vfc_name);
 3052                 ovfs.vfc_index = vfsp->vfc_typenum;
 3053                 ovfs.vfc_refcount = vfsp->vfc_refcount;
 3054                 ovfs.vfc_flags = vfsp->vfc_flags;
 3055                 error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
 3056                 if (error)
 3057                         return error;
 3058         }
 3059         return 0;
 3060 }
 3061 
 3062 #endif /* 1 || COMPAT_PRELITE2 */
 3063 #endif /* !BURN_BRIDGES */
 3064 
 3065 #define KINFO_VNODESLOP         10
 3066 #ifdef notyet
 3067 /*
 3068  * Dump vnode list (via sysctl).
 3069  */
 3070 /* ARGSUSED */
 3071 static int
 3072 sysctl_vnode(SYSCTL_HANDLER_ARGS)
 3073 {
 3074         struct xvnode *xvn;
 3075         struct mount *mp;
 3076         struct vnode *vp;
 3077         int error, len, n;
 3078 
 3079         /*
 3080          * Stale numvnodes access is not fatal here.
 3081          */
 3082         req->lock = 0;
 3083         len = (numvnodes + KINFO_VNODESLOP) * sizeof *xvn;
 3084         if (!req->oldptr)
 3085                 /* Make an estimate */
 3086                 return (SYSCTL_OUT(req, 0, len));
 3087 
 3088         error = sysctl_wire_old_buffer(req, 0);
 3089         if (error != 0)
 3090                 return (error);
 3091         xvn = malloc(len, M_TEMP, M_ZERO | M_WAITOK);
 3092         n = 0;
 3093         mtx_lock(&mountlist_mtx);
 3094         TAILQ_FOREACH(mp, &mountlist, mnt_list) {
 3095                 if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK))
 3096                         continue;
 3097                 MNT_ILOCK(mp);
 3098                 TAILQ_FOREACH(vp, &mp->mnt_nvnodelist, v_nmntvnodes) {
 3099                         if (n == len)
 3100                                 break;
 3101                         vref(vp);
 3102                         xvn[n].xv_size = sizeof *xvn;
 3103                         xvn[n].xv_vnode = vp;
 3104                         xvn[n].xv_id = 0;       /* XXX compat */
 3105 #define XV_COPY(field) xvn[n].xv_##field = vp->v_##field
 3106                         XV_COPY(usecount);
 3107                         XV_COPY(writecount);
 3108                         XV_COPY(holdcnt);
 3109                         XV_COPY(mount);
 3110                         XV_COPY(numoutput);
 3111                         XV_COPY(type);
 3112 #undef XV_COPY
 3113                         xvn[n].xv_flag = vp->v_vflag;
 3114 
 3115                         switch (vp->v_type) {
 3116                         case VREG:
 3117                         case VDIR:
 3118                         case VLNK:
 3119                                 break;
 3120                         case VBLK:
 3121                         case VCHR:
 3122                                 if (vp->v_rdev == NULL) {
 3123                                         vrele(vp);
 3124                                         continue;
 3125                                 }
 3126                                 xvn[n].xv_dev = dev2udev(vp->v_rdev);
 3127                                 break;
 3128                         case VSOCK:
 3129                                 xvn[n].xv_socket = vp->v_socket;
 3130                                 break;
 3131                         case VFIFO:
 3132                                 xvn[n].xv_fifo = vp->v_fifoinfo;
 3133                                 break;
 3134                         case VNON:
 3135                         case VBAD:
 3136                         default:
 3137                                 /* shouldn't happen? */
 3138                                 vrele(vp);
 3139                                 continue;
 3140                         }
 3141                         vrele(vp);
 3142                         ++n;
 3143                 }
 3144                 MNT_IUNLOCK(mp);
 3145                 mtx_lock(&mountlist_mtx);
 3146                 vfs_unbusy(mp);
 3147                 if (n == len)
 3148                         break;
 3149         }
 3150         mtx_unlock(&mountlist_mtx);
 3151 
 3152         error = SYSCTL_OUT(req, xvn, n * sizeof *xvn);
 3153         free(xvn, M_TEMP);
 3154         return (error);
 3155 }
 3156 
 3157 SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
 3158     0, 0, sysctl_vnode, "S,xvnode", "");
 3159 #endif
 3160 
 3161 /*
 3162  * Unmount all filesystems. The list is traversed in reverse order
 3163  * of mounting to avoid dependencies.
 3164  */
 3165 void
 3166 vfs_unmountall(void)
 3167 {
 3168         struct mount *mp;
 3169         struct thread *td;
 3170         int error;
 3171 
 3172         KASSERT(curthread != NULL, ("vfs_unmountall: NULL curthread"));
 3173         CTR1(KTR_VFS, "%s: unmounting all filesystems", __func__);
 3174         td = curthread;
 3175 
 3176         /*
 3177          * Since this only runs when rebooting, it is not interlocked.
 3178          */
 3179         while(!TAILQ_EMPTY(&mountlist)) {
 3180                 mp = TAILQ_LAST(&mountlist, mntlist);
 3181                 error = dounmount(mp, MNT_FORCE, td);
 3182                 if (error) {
 3183                         TAILQ_REMOVE(&mountlist, mp, mnt_list);
 3184                         /*
 3185                          * XXX: Due to the way in which we mount the root
 3186                          * file system off of devfs, devfs will generate a
 3187                          * "busy" warning when we try to unmount it before
 3188                          * the root.  Don't print a warning as a result in
 3189                          * order to avoid false positive errors that may
 3190                          * cause needless upset.
 3191                          */
 3192                         if (strcmp(mp->mnt_vfc->vfc_name, "devfs") != 0) {
 3193                                 printf("unmount of %s failed (",
 3194                                     mp->mnt_stat.f_mntonname);
 3195                                 if (error == EBUSY)
 3196                                         printf("BUSY)\n");
 3197                                 else
 3198                                         printf("%d)\n", error);
 3199                         }
 3200                 } else {
 3201                         /* The unmount has removed mp from the mountlist */
 3202                 }
 3203         }
 3204 }
 3205 
 3206 /*
 3207  * perform msync on all vnodes under a mount point
 3208  * the mount point must be locked.
 3209  */
 3210 void
 3211 vfs_msync(struct mount *mp, int flags)
 3212 {
 3213         struct vnode *vp, *mvp;
 3214         struct vm_object *obj;
 3215 
 3216         CTR2(KTR_VFS, "%s: mp %p", __func__, mp);
 3217         MNT_ILOCK(mp);
 3218         MNT_VNODE_FOREACH(vp, mp, mvp) {
 3219                 VI_LOCK(vp);
 3220                 obj = vp->v_object;
 3221                 if (obj != NULL && (obj->flags & OBJ_MIGHTBEDIRTY) != 0 &&
 3222                     (flags == MNT_WAIT || VOP_ISLOCKED(vp) == 0)) {
 3223                         MNT_IUNLOCK(mp);
 3224                         if (!vget(vp,
 3225                             LK_EXCLUSIVE | LK_RETRY | LK_INTERLOCK,
 3226                             curthread)) {
 3227                                 if (vp->v_vflag & VV_NOSYNC) {  /* unlinked */
 3228                                         vput(vp);
 3229                                         MNT_ILOCK(mp);
 3230                                         continue;
 3231                                 }
 3232 
 3233                                 obj = vp->v_object;
 3234                                 if (obj != NULL) {
 3235                                         VM_OBJECT_LOCK(obj);
 3236                                         vm_object_page_clean(obj, 0, 0,
 3237                                             flags == MNT_WAIT ?
 3238                                             OBJPC_SYNC : OBJPC_NOSYNC);
 3239                                         VM_OBJECT_UNLOCK(obj);
 3240                                 }
 3241                                 vput(vp);
 3242                         }
 3243                         MNT_ILOCK(mp);
 3244                 } else
 3245                         VI_UNLOCK(vp);
 3246         }
 3247         MNT_IUNLOCK(mp);
 3248 }
 3249 
 3250 /*
 3251  * Mark a vnode as free, putting it up for recycling.
 3252  */
 3253 static void
 3254 vfree(struct vnode *vp)
 3255 {
 3256 
 3257         ASSERT_VI_LOCKED(vp, "vfree");
 3258         mtx_lock(&vnode_free_list_mtx);
 3259         VNASSERT(vp->v_op != NULL, vp, ("vfree: vnode already reclaimed."));
 3260         VNASSERT((vp->v_iflag & VI_FREE) == 0, vp, ("vnode already free"));
 3261         VNASSERT(VSHOULDFREE(vp), vp, ("vfree: freeing when we shouldn't"));
 3262         VNASSERT((vp->v_iflag & VI_DOOMED) == 0, vp,
 3263             ("vfree: Freeing doomed vnode"));
 3264         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 3265         if (vp->v_iflag & VI_AGE) {
 3266                 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
 3267         } else {
 3268                 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
 3269         }
 3270         freevnodes++;
 3271         vp->v_iflag &= ~VI_AGE;
 3272         vp->v_iflag |= VI_FREE;
 3273         mtx_unlock(&vnode_free_list_mtx);
 3274 }
 3275 
 3276 /*
 3277  * Opposite of vfree() - mark a vnode as in use.
 3278  */
 3279 static void
 3280 vbusy(struct vnode *vp)
 3281 {
 3282         ASSERT_VI_LOCKED(vp, "vbusy");
 3283         VNASSERT((vp->v_iflag & VI_FREE) != 0, vp, ("vnode not free"));
 3284         VNASSERT(vp->v_op != NULL, vp, ("vbusy: vnode already reclaimed."));
 3285         CTR2(KTR_VFS, "%s: vp %p", __func__, vp);
 3286 
 3287         mtx_lock(&vnode_free_list_mtx);
 3288         TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
 3289         freevnodes--;
 3290         vp->v_iflag &= ~(VI_FREE|VI_AGE);
 3291         mtx_unlock(&vnode_free_list_mtx);
 3292 }
 3293 
 3294 static void
 3295 destroy_vpollinfo(struct vpollinfo *vi)
 3296 {
 3297         knlist_destroy(&vi->vpi_selinfo.si_note);
 3298         mtx_destroy(&vi->vpi_lock);
 3299         uma_zfree(vnodepoll_zone, vi);
 3300 }
 3301 
 3302 /*
 3303  * Initalize per-vnode helper structure to hold poll-related state.
 3304  */
 3305 void
 3306 v_addpollinfo(struct vnode *vp)
 3307 {
 3308         struct vpollinfo *vi;
 3309 
 3310         if (vp->v_pollinfo != NULL)
 3311                 return;
 3312         vi = uma_zalloc(vnodepoll_zone, M_WAITOK);
 3313         mtx_init(&vi->vpi_lock, "vnode pollinfo", NULL, MTX_DEF);
 3314         knlist_init(&vi->vpi_selinfo.si_note, vp, vfs_knllock,
 3315             vfs_knlunlock, vfs_knl_assert_locked, vfs_knl_assert_unlocked);
 3316         VI_LOCK(vp);
 3317         if (vp->v_pollinfo != NULL) {
 3318                 VI_UNLOCK(vp);
 3319                 destroy_vpollinfo(vi);
 3320                 return;
 3321         }
 3322         vp->v_pollinfo = vi;
 3323         VI_UNLOCK(vp);
 3324 }
 3325 
 3326 /*
 3327  * Record a process's interest in events which might happen to
 3328  * a vnode.  Because poll uses the historic select-style interface
 3329  * internally, this routine serves as both the ``check for any
 3330  * pending events'' and the ``record my interest in future events''
 3331  * functions.  (These are done together, while the lock is held,
 3332  * to avoid race conditions.)
 3333  */
 3334 int
 3335 vn_pollrecord(struct vnode *vp, struct thread *td, int events)
 3336 {
 3337 
 3338         v_addpollinfo(vp);
 3339         mtx_lock(&vp->v_pollinfo->vpi_lock);
 3340         if (vp->v_pollinfo->vpi_revents & events) {
 3341                 /*
 3342                  * This leaves events we are not interested
 3343                  * in available for the other process which
 3344                  * which presumably had requested them
 3345                  * (otherwise they would never have been
 3346                  * recorded).
 3347                  */
 3348                 events &= vp->v_pollinfo->vpi_revents;
 3349                 vp->v_pollinfo->vpi_revents &= ~events;
 3350 
 3351                 mtx_unlock(&vp->v_pollinfo->vpi_lock);
 3352                 return (events);
 3353         }
 3354         vp->v_pollinfo->vpi_events |= events;
 3355         selrecord(td, &vp->v_pollinfo->vpi_selinfo);
 3356         mtx_unlock(&vp->v_pollinfo->vpi_lock);
 3357         return (0);
 3358 }
 3359 
 3360 /*
 3361  * Routine to create and manage a filesystem syncer vnode.
 3362  */
 3363 #define sync_close ((int (*)(struct  vop_close_args *))nullop)
 3364 static int      sync_fsync(struct  vop_fsync_args *);
 3365 static int      sync_inactive(struct  vop_inactive_args *);
 3366 static int      sync_reclaim(struct  vop_reclaim_args *);
 3367 
 3368 static struct vop_vector sync_vnodeops = {
 3369         .vop_bypass =   VOP_EOPNOTSUPP,
 3370         .vop_close =    sync_close,             /* close */
 3371         .vop_fsync =    sync_fsync,             /* fsync */
 3372         .vop_inactive = sync_inactive,  /* inactive */
 3373         .vop_reclaim =  sync_reclaim,   /* reclaim */
 3374         .vop_lock1 =    vop_stdlock,    /* lock */
 3375         .vop_unlock =   vop_stdunlock,  /* unlock */
 3376         .vop_islocked = vop_stdislocked,        /* islocked */
 3377 };
 3378 
 3379 /*
 3380  * Create a new filesystem syncer vnode for the specified mount point.
 3381  */
 3382 int
 3383 vfs_allocate_syncvnode(struct mount *mp)
 3384 {
 3385         struct vnode *vp;
 3386         struct bufobj *bo;
 3387         static long start, incr, next;
 3388         int error;
 3389 
 3390         /* Allocate a new vnode */
 3391         if ((error = getnewvnode("syncer", mp, &sync_vnodeops, &vp)) != 0) {
 3392                 mp->mnt_syncer = NULL;
 3393                 return (error);
 3394         }
 3395         vp->v_type = VNON;
 3396         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 3397         vp->v_vflag |= VV_FORCEINSMQ;
 3398         error = insmntque(vp, mp);
 3399         if (error != 0)
 3400                 panic("vfs_allocate_syncvnode: insmntque failed");
 3401         vp->v_vflag &= ~VV_FORCEINSMQ;
 3402         VOP_UNLOCK(vp, 0);
 3403         /*
 3404          * Place the vnode onto the syncer worklist. We attempt to
 3405          * scatter them about on the list so that they will go off
 3406          * at evenly distributed times even if all the filesystems
 3407          * are mounted at once.
 3408          */
 3409         next += incr;
 3410         if (next == 0 || next > syncer_maxdelay) {
 3411                 start /= 2;
 3412                 incr /= 2;
 3413                 if (start == 0) {
 3414                         start = syncer_maxdelay / 2;
 3415                         incr = syncer_maxdelay;
 3416                 }
 3417                 next = start;
 3418         }
 3419         bo = &vp->v_bufobj;
 3420         BO_LOCK(bo);
 3421         vn_syncer_add_to_worklist(bo, syncdelay > 0 ? next % syncdelay : 0);
 3422         /* XXX - vn_syncer_add_to_worklist() also grabs and drops sync_mtx. */
 3423         mtx_lock(&sync_mtx);
 3424         sync_vnode_count++;
 3425         mtx_unlock(&sync_mtx);
 3426         BO_UNLOCK(bo);
 3427         mp->mnt_syncer = vp;
 3428         return (0);
 3429 }
 3430 
 3431 /*
 3432  * Do a lazy sync of the filesystem.
 3433  */
 3434 static int
 3435 sync_fsync(struct vop_fsync_args *ap)
 3436 {
 3437         struct vnode *syncvp = ap->a_vp;
 3438         struct mount *mp = syncvp->v_mount;
 3439         int error;
 3440         struct bufobj *bo;
 3441 
 3442         /*
 3443          * We only need to do something if this is a lazy evaluation.
 3444          */
 3445         if (ap->a_waitfor != MNT_LAZY)
 3446                 return (0);
 3447 
 3448         /*
 3449          * Move ourselves to the back of the sync list.
 3450          */
 3451         bo = &syncvp->v_bufobj;
 3452         BO_LOCK(bo);
 3453         vn_syncer_add_to_worklist(bo, syncdelay);
 3454         BO_UNLOCK(bo);
 3455 
 3456         /*
 3457          * Walk the list of vnodes pushing all that are dirty and
 3458          * not already on the sync list.
 3459          */
 3460         mtx_lock(&mountlist_mtx);
 3461         if (vfs_busy(mp, MBF_NOWAIT | MBF_MNTLSTLOCK) != 0) {
 3462                 mtx_unlock(&mountlist_mtx);
 3463                 return (0);
 3464         }
 3465         if (vn_start_write(NULL, &mp, V_NOWAIT) != 0) {
 3466                 vfs_unbusy(mp);
 3467                 return (0);
 3468         }
 3469         MNT_ILOCK(mp);
 3470         mp->mnt_noasync++;
 3471         mp->mnt_kern_flag &= ~MNTK_ASYNC;
 3472         MNT_IUNLOCK(mp);
 3473         vfs_msync(mp, MNT_NOWAIT);
 3474         error = VFS_SYNC(mp, MNT_LAZY);
 3475         MNT_ILOCK(mp);
 3476         mp->mnt_noasync--;
 3477         if ((mp->mnt_flag & MNT_ASYNC) != 0 && mp->mnt_noasync == 0)
 3478                 mp->mnt_kern_flag |= MNTK_ASYNC;
 3479         MNT_IUNLOCK(mp);
 3480         vn_finished_write(mp);
 3481         vfs_unbusy(mp);
 3482         return (error);
 3483 }
 3484 
 3485 /*
 3486  * The syncer vnode is no referenced.
 3487  */
 3488 static int
 3489 sync_inactive(struct vop_inactive_args *ap)
 3490 {
 3491 
 3492         vgone(ap->a_vp);
 3493         return (0);
 3494 }
 3495 
 3496 /*
 3497  * The syncer vnode is no longer needed and is being decommissioned.
 3498  *
 3499  * Modifications to the worklist must be protected by sync_mtx.
 3500  */
 3501 static int
 3502 sync_reclaim(struct vop_reclaim_args *ap)
 3503 {
 3504         struct vnode *vp = ap->a_vp;
 3505         struct bufobj *bo;
 3506 
 3507         bo = &vp->v_bufobj;
 3508         BO_LOCK(bo);
 3509         vp->v_mount->mnt_syncer = NULL;
 3510         if (bo->bo_flag & BO_ONWORKLST) {
 3511                 mtx_lock(&sync_mtx);
 3512                 LIST_REMOVE(bo, bo_synclist);
 3513                 syncer_worklist_len--;
 3514                 sync_vnode_count--;
 3515                 mtx_unlock(&sync_mtx);
 3516                 bo->bo_flag &= ~BO_ONWORKLST;
 3517         }
 3518         BO_UNLOCK(bo);
 3519 
 3520         return (0);
 3521 }
 3522 
 3523 /*
 3524  * Check if vnode represents a disk device
 3525  */
 3526 int
 3527 vn_isdisk(struct vnode *vp, int *errp)
 3528 {
 3529         int error;
 3530 
 3531         error = 0;
 3532         dev_lock();
 3533         if (vp->v_type != VCHR)
 3534                 error = ENOTBLK;
 3535         else if (vp->v_rdev == NULL)
 3536                 error = ENXIO;
 3537         else if (vp->v_rdev->si_devsw == NULL)
 3538                 error = ENXIO;
 3539         else if (!(vp->v_rdev->si_devsw->d_flags & D_DISK))
 3540                 error = ENOTBLK;
 3541         dev_unlock();
 3542         if (errp != NULL)
 3543                 *errp = error;
 3544         return (error == 0);
 3545 }
 3546 
 3547 /*
 3548  * Common filesystem object access control check routine.  Accepts a
 3549  * vnode's type, "mode", uid and gid, requested access mode, credentials,
 3550  * and optional call-by-reference privused argument allowing vaccess()
 3551  * to indicate to the caller whether privilege was used to satisfy the
 3552  * request (obsoleted).  Returns 0 on success, or an errno on failure.
 3553  *
 3554  * The ifdef'd CAPABILITIES version is here for reference, but is not
 3555  * actually used.
 3556  */
 3557 int
 3558 vaccess(enum vtype type, mode_t file_mode, uid_t file_uid, gid_t file_gid,
 3559     accmode_t accmode, struct ucred *cred, int *privused)
 3560 {
 3561         accmode_t dac_granted;
 3562         accmode_t priv_granted;
 3563 
 3564         KASSERT((accmode & ~(VEXEC | VWRITE | VREAD | VADMIN | VAPPEND)) == 0,
 3565             ("invalid bit in accmode"));
 3566 
 3567         /*
 3568          * Look for a normal, non-privileged way to access the file/directory
 3569          * as requested.  If it exists, go with that.
 3570          */
 3571 
 3572         if (privused != NULL)
 3573                 *privused = 0;
 3574 
 3575         dac_granted = 0;
 3576 
 3577         /* Check the owner. */
 3578         if (cred->cr_uid == file_uid) {
 3579                 dac_granted |= VADMIN;
 3580                 if (file_mode & S_IXUSR)
 3581                         dac_granted |= VEXEC;
 3582                 if (file_mode & S_IRUSR)
 3583                         dac_granted |= VREAD;
 3584                 if (file_mode & S_IWUSR)
 3585                         dac_granted |= (VWRITE | VAPPEND);
 3586 
 3587                 if ((accmode & dac_granted) == accmode)
 3588                         return (0);
 3589 
 3590                 goto privcheck;
 3591         }
 3592 
 3593         /* Otherwise, check the groups (first match) */
 3594         if (groupmember(file_gid, cred)) {
 3595                 if (file_mode & S_IXGRP)
 3596                         dac_granted |= VEXEC;
 3597                 if (file_mode & S_IRGRP)
 3598                         dac_granted |= VREAD;
 3599                 if (file_mode & S_IWGRP)
 3600                         dac_granted |= (VWRITE | VAPPEND);
 3601 
 3602                 if ((accmode & dac_granted) == accmode)
 3603                         return (0);
 3604 
 3605                 goto privcheck;
 3606         }
 3607 
 3608         /* Otherwise, check everyone else. */
 3609         if (file_mode & S_IXOTH)
 3610                 dac_granted |= VEXEC;
 3611         if (file_mode & S_IROTH)
 3612                 dac_granted |= VREAD;
 3613         if (file_mode & S_IWOTH)
 3614                 dac_granted |= (VWRITE | VAPPEND);
 3615         if ((accmode & dac_granted) == accmode)
 3616                 return (0);
 3617 
 3618 privcheck:
 3619         /*
 3620          * Build a privilege mask to determine if the set of privileges
 3621          * satisfies the requirements when combined with the granted mask
 3622          * from above.  For each privilege, if the privilege is required,
 3623          * bitwise or the request type onto the priv_granted mask.
 3624          */
 3625         priv_granted = 0;
 3626 
 3627         if (type == VDIR) {
 3628                 /*
 3629                  * For directories, use PRIV_VFS_LOOKUP to satisfy VEXEC
 3630                  * requests, instead of PRIV_VFS_EXEC.
 3631                  */
 3632                 if ((accmode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
 3633                     !priv_check_cred(cred, PRIV_VFS_LOOKUP, 0))
 3634                         priv_granted |= VEXEC;
 3635         } else {
 3636                 if ((accmode & VEXEC) && ((dac_granted & VEXEC) == 0) &&
 3637                     !priv_check_cred(cred, PRIV_VFS_EXEC, 0))
 3638                         priv_granted |= VEXEC;
 3639         }
 3640 
 3641         if ((accmode & VREAD) && ((dac_granted & VREAD) == 0) &&
 3642             !priv_check_cred(cred, PRIV_VFS_READ, 0))
 3643                 priv_granted |= VREAD;
 3644 
 3645         if ((accmode & VWRITE) && ((dac_granted & VWRITE) == 0) &&
 3646             !priv_check_cred(cred, PRIV_VFS_WRITE, 0))
 3647                 priv_granted |= (VWRITE | VAPPEND);
 3648 
 3649         if ((accmode & VADMIN) && ((dac_granted & VADMIN) == 0) &&
 3650             !priv_check_cred(cred, PRIV_VFS_ADMIN, 0))
 3651                 priv_granted |= VADMIN;
 3652 
 3653         if ((accmode & (priv_granted | dac_granted)) == accmode) {
 3654                 /* XXX audit: privilege used */
 3655                 if (privused != NULL)
 3656                         *privused = 1;
 3657                 return (0);
 3658         }
 3659 
 3660         return ((accmode & VADMIN) ? EPERM : EACCES);
 3661 }
 3662 
 3663 /*
 3664  * Credential check based on process requesting service, and per-attribute
 3665  * permissions.
 3666  */
 3667 int
 3668 extattr_check_cred(struct vnode *vp, int attrnamespace, struct ucred *cred,
 3669     struct thread *td, accmode_t accmode)
 3670 {
 3671 
 3672         /*
 3673          * Kernel-invoked always succeeds.
 3674          */
 3675         if (cred == NOCRED)
 3676                 return (0);
 3677 
 3678         /*
 3679          * Do not allow privileged processes in jail to directly manipulate
 3680          * system attributes.
 3681          */
 3682         switch (attrnamespace) {
 3683         case EXTATTR_NAMESPACE_SYSTEM:
 3684                 /* Potentially should be: return (EPERM); */
 3685                 return (priv_check_cred(cred, PRIV_VFS_EXTATTR_SYSTEM, 0));
 3686         case EXTATTR_NAMESPACE_USER:
 3687                 return (VOP_ACCESS(vp, accmode, cred, td));
 3688         default:
 3689                 return (EPERM);
 3690         }
 3691 }
 3692 
 3693 #ifdef DEBUG_VFS_LOCKS
 3694 /*
 3695  * This only exists to supress warnings from unlocked specfs accesses.  It is
 3696  * no longer ok to have an unlocked VFS.
 3697  */
 3698 #define IGNORE_LOCK(vp) (panicstr != NULL || (vp) == NULL ||            \
 3699         (vp)->v_type == VCHR || (vp)->v_type == VBAD)
 3700 
 3701 int vfs_badlock_ddb = 1;        /* Drop into debugger on violation. */
 3702 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_ddb, CTLFLAG_RW, &vfs_badlock_ddb, 0,
 3703     "Drop into debugger on lock violation");
 3704 
 3705 int vfs_badlock_mutex = 1;      /* Check for interlock across VOPs. */
 3706 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_mutex, CTLFLAG_RW, &vfs_badlock_mutex,
 3707     0, "Check for interlock across VOPs");
 3708 
 3709 int vfs_badlock_print = 1;      /* Print lock violations. */
 3710 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_print, CTLFLAG_RW, &vfs_badlock_print,
 3711     0, "Print lock violations");
 3712 
 3713 #ifdef KDB
 3714 int vfs_badlock_backtrace = 1;  /* Print backtrace at lock violations. */
 3715 SYSCTL_INT(_debug, OID_AUTO, vfs_badlock_backtrace, CTLFLAG_RW,
 3716     &vfs_badlock_backtrace, 0, "Print backtrace at lock violations");
 3717 #endif
 3718 
 3719 static void
 3720 vfs_badlock(const char *msg, const char *str, struct vnode *vp)
 3721 {
 3722 
 3723 #ifdef KDB
 3724         if (vfs_badlock_backtrace)
 3725                 kdb_backtrace();
 3726 #endif
 3727         if (vfs_badlock_print)
 3728                 printf("%s: %p %s\n", str, (void *)vp, msg);
 3729         if (vfs_badlock_ddb)
 3730                 kdb_enter(KDB_WHY_VFSLOCK, "lock violation");
 3731 }
 3732 
 3733 void
 3734 assert_vi_locked(struct vnode *vp, const char *str)
 3735 {
 3736 
 3737         if (vfs_badlock_mutex && !mtx_owned(VI_MTX(vp)))
 3738                 vfs_badlock("interlock is not locked but should be", str, vp);
 3739 }
 3740 
 3741 void
 3742 assert_vi_unlocked(struct vnode *vp, const char *str)
 3743 {
 3744 
 3745         if (vfs_badlock_mutex && mtx_owned(VI_MTX(vp)))
 3746                 vfs_badlock("interlock is locked but should not be", str, vp);
 3747 }
 3748 
 3749 void
 3750 assert_vop_locked(struct vnode *vp, const char *str)
 3751 {
 3752 
 3753         if (!IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) == 0)
 3754                 vfs_badlock("is not locked but should be", str, vp);
 3755 }
 3756 
 3757 void
 3758 assert_vop_unlocked(struct vnode *vp, const char *str)
 3759 {
 3760 
 3761         if (!IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) == LK_EXCLUSIVE)
 3762                 vfs_badlock("is locked but should not be", str, vp);
 3763 }
 3764 
 3765 void
 3766 assert_vop_elocked(struct vnode *vp, const char *str)
 3767 {
 3768 
 3769         if (!IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) != LK_EXCLUSIVE)
 3770                 vfs_badlock("is not exclusive locked but should be", str, vp);
 3771 }
 3772 
 3773 #if 0
 3774 void
 3775 assert_vop_elocked_other(struct vnode *vp, const char *str)
 3776 {
 3777 
 3778         if (!IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) != LK_EXCLOTHER)
 3779                 vfs_badlock("is not exclusive locked by another thread",
 3780                     str, vp);
 3781 }
 3782 
 3783 void
 3784 assert_vop_slocked(struct vnode *vp, const char *str)
 3785 {
 3786 
 3787         if (!IGNORE_LOCK(vp) && VOP_ISLOCKED(vp) != LK_SHARED)
 3788                 vfs_badlock("is not locked shared but should be", str, vp);
 3789 }
 3790 #endif /* 0 */
 3791 #endif /* DEBUG_VFS_LOCKS */
 3792 
 3793 void
 3794 vop_rename_fail(struct vop_rename_args *ap)
 3795 {
 3796 
 3797         if (ap->a_tvp != NULL)
 3798                 vput(ap->a_tvp);
 3799         if (ap->a_tdvp == ap->a_tvp)
 3800                 vrele(ap->a_tdvp);
 3801         else
 3802                 vput(ap->a_tdvp);
 3803         vrele(ap->a_fdvp);
 3804         vrele(ap->a_fvp);
 3805 }
 3806 
 3807 void
 3808 vop_rename_pre(void *ap)
 3809 {
 3810         struct vop_rename_args *a = ap;
 3811 
 3812 #ifdef DEBUG_VFS_LOCKS
 3813         if (a->a_tvp)
 3814                 ASSERT_VI_UNLOCKED(a->a_tvp, "VOP_RENAME");
 3815         ASSERT_VI_UNLOCKED(a->a_tdvp, "VOP_RENAME");
 3816         ASSERT_VI_UNLOCKED(a->a_fvp, "VOP_RENAME");
 3817         ASSERT_VI_UNLOCKED(a->a_fdvp, "VOP_RENAME");
 3818 
 3819         /* Check the source (from). */
 3820         if (a->a_tdvp->v_vnlock != a->a_fdvp->v_vnlock &&
 3821             (a->a_tvp == NULL || a->a_tvp->v_vnlock != a->a_fdvp->v_vnlock))
 3822                 ASSERT_VOP_UNLOCKED(a->a_fdvp, "vop_rename: fdvp locked");
 3823         if (a->a_tvp == NULL || a->a_tvp->v_vnlock != a->a_fvp->v_vnlock)
 3824                 ASSERT_VOP_UNLOCKED(a->a_fvp, "vop_rename: fvp locked");
 3825 
 3826         /* Check the target. */
 3827         if (a->a_tvp)
 3828                 ASSERT_VOP_LOCKED(a->a_tvp, "vop_rename: tvp not locked");
 3829         ASSERT_VOP_LOCKED(a->a_tdvp, "vop_rename: tdvp not locked");
 3830 #endif
 3831         if (a->a_tdvp != a->a_fdvp)
 3832                 vhold(a->a_fdvp);
 3833         if (a->a_tvp != a->a_fvp)
 3834                 vhold(a->a_fvp);
 3835         vhold(a->a_tdvp);
 3836         if (a->a_tvp)
 3837                 vhold(a->a_tvp);
 3838 }
 3839 
 3840 void
 3841 vop_strategy_pre(void *ap)
 3842 {
 3843 #ifdef DEBUG_VFS_LOCKS
 3844         struct vop_strategy_args *a;
 3845         struct buf *bp;
 3846 
 3847         a = ap;
 3848         bp = a->a_bp;
 3849 
 3850         /*
 3851          * Cluster ops lock their component buffers but not the IO container.
 3852          */
 3853         if ((bp->b_flags & B_CLUSTER) != 0)
 3854                 return;
 3855 
 3856         if (!BUF_ISLOCKED(bp)) {
 3857                 if (vfs_badlock_print)
 3858                         printf(
 3859                             "VOP_STRATEGY: bp is not locked but should be\n");
 3860                 if (vfs_badlock_ddb)
 3861                         kdb_enter(KDB_WHY_VFSLOCK, "lock violation");
 3862         }
 3863 #endif
 3864 }
 3865 
 3866 void
 3867 vop_lookup_pre(void *ap)
 3868 {
 3869 #ifdef DEBUG_VFS_LOCKS
 3870         struct vop_lookup_args *a;
 3871         struct vnode *dvp;
 3872 
 3873         a = ap;
 3874         dvp = a->a_dvp;
 3875         ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
 3876         ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
 3877 #endif
 3878 }
 3879 
 3880 void
 3881 vop_lookup_post(void *ap, int rc)
 3882 {
 3883 #ifdef DEBUG_VFS_LOCKS
 3884         struct vop_lookup_args *a;
 3885         struct vnode *dvp;
 3886         struct vnode *vp;
 3887 
 3888         a = ap;
 3889         dvp = a->a_dvp;
 3890         vp = *(a->a_vpp);
 3891 
 3892         ASSERT_VI_UNLOCKED(dvp, "VOP_LOOKUP");
 3893         ASSERT_VOP_LOCKED(dvp, "VOP_LOOKUP");
 3894 
 3895         if (!rc)
 3896                 ASSERT_VOP_LOCKED(vp, "VOP_LOOKUP (child)");
 3897 #endif
 3898 }
 3899 
 3900 void
 3901 vop_lock_pre(void *ap)
 3902 {
 3903 #ifdef DEBUG_VFS_LOCKS
 3904         struct vop_lock1_args *a = ap;
 3905 
 3906         if ((a->a_flags & LK_INTERLOCK) == 0)
 3907                 ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
 3908         else
 3909                 ASSERT_VI_LOCKED(a->a_vp, "VOP_LOCK");
 3910 #endif
 3911 }
 3912 
 3913 void
 3914 vop_lock_post(void *ap, int rc)
 3915 {
 3916 #ifdef DEBUG_VFS_LOCKS
 3917         struct vop_lock1_args *a = ap;
 3918 
 3919         ASSERT_VI_UNLOCKED(a->a_vp, "VOP_LOCK");
 3920         if (rc == 0)
 3921                 ASSERT_VOP_LOCKED(a->a_vp, "VOP_LOCK");
 3922 #endif
 3923 }
 3924 
 3925 void
 3926 vop_unlock_pre(void *ap)
 3927 {
 3928 #ifdef DEBUG_VFS_LOCKS
 3929         struct vop_unlock_args *a = ap;
 3930 
 3931         if (a->a_flags & LK_INTERLOCK)
 3932                 ASSERT_VI_LOCKED(a->a_vp, "VOP_UNLOCK");
 3933         ASSERT_VOP_LOCKED(a->a_vp, "VOP_UNLOCK");
 3934 #endif
 3935 }
 3936 
 3937 void
 3938 vop_unlock_post(void *ap, int rc)
 3939 {
 3940 #ifdef DEBUG_VFS_LOCKS
 3941         struct vop_unlock_args *a = ap;
 3942 
 3943         if (a->a_flags & LK_INTERLOCK)
 3944                 ASSERT_VI_UNLOCKED(a->a_vp, "VOP_UNLOCK");
 3945 #endif
 3946 }
 3947 
 3948 void
 3949 vop_create_post(void *ap, int rc)
 3950 {
 3951         struct vop_create_args *a = ap;
 3952 
 3953         if (!rc)
 3954                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
 3955 }
 3956 
 3957 void
 3958 vop_link_post(void *ap, int rc)
 3959 {
 3960         struct vop_link_args *a = ap;
 3961 
 3962         if (!rc) {
 3963                 VFS_KNOTE_LOCKED(a->a_vp, NOTE_LINK);
 3964                 VFS_KNOTE_LOCKED(a->a_tdvp, NOTE_WRITE);
 3965         }
 3966 }
 3967 
 3968 void
 3969 vop_mkdir_post(void *ap, int rc)
 3970 {
 3971         struct vop_mkdir_args *a = ap;
 3972 
 3973         if (!rc)
 3974                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
 3975 }
 3976 
 3977 void
 3978 vop_mknod_post(void *ap, int rc)
 3979 {
 3980         struct vop_mknod_args *a = ap;
 3981 
 3982         if (!rc)
 3983                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
 3984 }
 3985 
 3986 void
 3987 vop_remove_post(void *ap, int rc)
 3988 {
 3989         struct vop_remove_args *a = ap;
 3990 
 3991         if (!rc) {
 3992                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
 3993                 VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
 3994         }
 3995 }
 3996 
 3997 void
 3998 vop_rename_post(void *ap, int rc)
 3999 {
 4000         struct vop_rename_args *a = ap;
 4001 
 4002         if (!rc) {
 4003                 VFS_KNOTE_UNLOCKED(a->a_fdvp, NOTE_WRITE);
 4004                 VFS_KNOTE_UNLOCKED(a->a_tdvp, NOTE_WRITE);
 4005                 VFS_KNOTE_UNLOCKED(a->a_fvp, NOTE_RENAME);
 4006                 if (a->a_tvp)
 4007                         VFS_KNOTE_UNLOCKED(a->a_tvp, NOTE_DELETE);
 4008         }
 4009         if (a->a_tdvp != a->a_fdvp)
 4010                 vdrop(a->a_fdvp);
 4011         if (a->a_tvp != a->a_fvp)
 4012                 vdrop(a->a_fvp);
 4013         vdrop(a->a_tdvp);
 4014         if (a->a_tvp)
 4015                 vdrop(a->a_tvp);
 4016 }
 4017 
 4018 void
 4019 vop_rmdir_post(void *ap, int rc)
 4020 {
 4021         struct vop_rmdir_args *a = ap;
 4022 
 4023         if (!rc) {
 4024                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE | NOTE_LINK);
 4025                 VFS_KNOTE_LOCKED(a->a_vp, NOTE_DELETE);
 4026         }
 4027 }
 4028 
 4029 void
 4030 vop_setattr_post(void *ap, int rc)
 4031 {
 4032         struct vop_setattr_args *a = ap;
 4033 
 4034         if (!rc)
 4035                 VFS_KNOTE_LOCKED(a->a_vp, NOTE_ATTRIB);
 4036 }
 4037 
 4038 void
 4039 vop_symlink_post(void *ap, int rc)
 4040 {
 4041         struct vop_symlink_args *a = ap;
 4042 
 4043         if (!rc)
 4044                 VFS_KNOTE_LOCKED(a->a_dvp, NOTE_WRITE);
 4045 }
 4046 
 4047 static struct knlist fs_knlist;
 4048 
 4049 static void
 4050 vfs_event_init(void *arg)
 4051 {
 4052         knlist_init_mtx(&fs_knlist, NULL);
 4053 }
 4054 /* XXX - correct order? */
 4055 SYSINIT(vfs_knlist, SI_SUB_VFS, SI_ORDER_ANY, vfs_event_init, NULL);
 4056 
 4057 void
 4058 vfs_event_signal(fsid_t *fsid, u_int32_t event, intptr_t data __unused)
 4059 {
 4060 
 4061         KNOTE_UNLOCKED(&fs_knlist, event);
 4062 }
 4063 
 4064 static int      filt_fsattach(struct knote *kn);
 4065 static void     filt_fsdetach(struct knote *kn);
 4066 static int      filt_fsevent(struct knote *kn, long hint);
 4067 
 4068 struct filterops fs_filtops =
 4069         { 0, filt_fsattach, filt_fsdetach, filt_fsevent };
 4070 
 4071 static int
 4072 filt_fsattach(struct knote *kn)
 4073 {
 4074 
 4075         kn->kn_flags |= EV_CLEAR;
 4076         knlist_add(&fs_knlist, kn, 0);
 4077         return (0);
 4078 }
 4079 
 4080 static void
 4081 filt_fsdetach(struct knote *kn)
 4082 {
 4083 
 4084         knlist_remove(&fs_knlist, kn, 0);
 4085 }
 4086 
 4087 static int
 4088 filt_fsevent(struct knote *kn, long hint)
 4089 {
 4090 
 4091         kn->kn_fflags |= hint;
 4092         return (kn->kn_fflags != 0);
 4093 }
 4094 
 4095 static int
 4096 sysctl_vfs_ctl(SYSCTL_HANDLER_ARGS)
 4097 {
 4098         struct vfsidctl vc;
 4099         int error;
 4100         struct mount *mp;
 4101 
 4102         error = SYSCTL_IN(req, &vc, sizeof(vc));
 4103         if (error)
 4104                 return (error);
 4105         if (vc.vc_vers != VFS_CTL_VERS1)
 4106                 return (EINVAL);
 4107         mp = vfs_getvfs(&vc.vc_fsid);
 4108         if (mp == NULL)
 4109                 return (ENOENT);
 4110         /* ensure that a specific sysctl goes to the right filesystem. */
 4111         if (strcmp(vc.vc_fstypename, "*") != 0 &&
 4112             strcmp(vc.vc_fstypename, mp->mnt_vfc->vfc_name) != 0) {
 4113                 vfs_rel(mp);
 4114                 return (EINVAL);
 4115         }
 4116         VCTLTOREQ(&vc, req);
 4117         error = VFS_SYSCTL(mp, vc.vc_op, req);
 4118         vfs_rel(mp);
 4119         return (error);
 4120 }
 4121 
 4122 SYSCTL_PROC(_vfs, OID_AUTO, ctl, CTLFLAG_WR, NULL, 0, sysctl_vfs_ctl, "",
 4123     "Sysctl by fsid");
 4124 
 4125 /*
 4126  * Function to initialize a va_filerev field sensibly.
 4127  * XXX: Wouldn't a random number make a lot more sense ??
 4128  */
 4129 u_quad_t
 4130 init_va_filerev(void)
 4131 {
 4132         struct bintime bt;
 4133 
 4134         getbinuptime(&bt);
 4135         return (((u_quad_t)bt.sec << 32LL) | (bt.frac >> 32LL));
 4136 }
 4137 
 4138 static int      filt_vfsread(struct knote *kn, long hint);
 4139 static int      filt_vfswrite(struct knote *kn, long hint);
 4140 static int      filt_vfsvnode(struct knote *kn, long hint);
 4141 static void     filt_vfsdetach(struct knote *kn);
 4142 static struct filterops vfsread_filtops =
 4143         { 1, NULL, filt_vfsdetach, filt_vfsread };
 4144 static struct filterops vfswrite_filtops =
 4145         { 1, NULL, filt_vfsdetach, filt_vfswrite };
 4146 static struct filterops vfsvnode_filtops =
 4147         { 1, NULL, filt_vfsdetach, filt_vfsvnode };
 4148 
 4149 static void
 4150 vfs_knllock(void *arg)
 4151 {
 4152         struct vnode *vp = arg;
 4153 
 4154         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 4155 }
 4156 
 4157 static void
 4158 vfs_knlunlock(void *arg)
 4159 {
 4160         struct vnode *vp = arg;
 4161 
 4162         VOP_UNLOCK(vp, 0);
 4163 }
 4164 
 4165 static void
 4166 vfs_knl_assert_locked(void *arg)
 4167 {
 4168 #ifdef DEBUG_VFS_LOCKS
 4169         struct vnode *vp = arg;
 4170 
 4171         ASSERT_VOP_LOCKED(vp, "vfs_knl_assert_locked");
 4172 #endif
 4173 }
 4174 
 4175 static void
 4176 vfs_knl_assert_unlocked(void *arg)
 4177 {
 4178 #ifdef DEBUG_VFS_LOCKS
 4179         struct vnode *vp = arg;
 4180 
 4181         ASSERT_VOP_UNLOCKED(vp, "vfs_knl_assert_unlocked");
 4182 #endif
 4183 }
 4184 
 4185 int
 4186 vfs_kqfilter(struct vop_kqfilter_args *ap)
 4187 {
 4188         struct vnode *vp = ap->a_vp;
 4189         struct knote *kn = ap->a_kn;
 4190         struct knlist *knl;
 4191 
 4192         switch (kn->kn_filter) {
 4193         case EVFILT_READ:
 4194                 kn->kn_fop = &vfsread_filtops;
 4195                 break;
 4196         case EVFILT_WRITE:
 4197                 kn->kn_fop = &vfswrite_filtops;
 4198                 break;
 4199         case EVFILT_VNODE:
 4200                 kn->kn_fop = &vfsvnode_filtops;
 4201                 break;
 4202         default:
 4203                 return (EINVAL);
 4204         }
 4205 
 4206         kn->kn_hook = (caddr_t)vp;
 4207 
 4208         v_addpollinfo(vp);
 4209         if (vp->v_pollinfo == NULL)
 4210                 return (ENOMEM);
 4211         knl = &vp->v_pollinfo->vpi_selinfo.si_note;
 4212         knlist_add(knl, kn, 0);
 4213 
 4214         return (0);
 4215 }
 4216 
 4217 /*
 4218  * Detach knote from vnode
 4219  */
 4220 static void
 4221 filt_vfsdetach(struct knote *kn)
 4222 {
 4223         struct vnode *vp = (struct vnode *)kn->kn_hook;
 4224 
 4225         KASSERT(vp->v_pollinfo != NULL, ("Missing v_pollinfo"));
 4226         knlist_remove(&vp->v_pollinfo->vpi_selinfo.si_note, kn, 0);
 4227 }
 4228 
 4229 /*ARGSUSED*/
 4230 static int
 4231 filt_vfsread(struct knote *kn, long hint)
 4232 {
 4233         struct vnode *vp = (struct vnode *)kn->kn_hook;
 4234         struct vattr va;
 4235         int res;
 4236 
 4237         /*
 4238          * filesystem is gone, so set the EOF flag and schedule
 4239          * the knote for deletion.
 4240          */
 4241         if (hint == NOTE_REVOKE) {
 4242                 VI_LOCK(vp);
 4243                 kn->kn_flags |= (EV_EOF | EV_ONESHOT);
 4244                 VI_UNLOCK(vp);
 4245                 return (1);
 4246         }
 4247 
 4248         if (VOP_GETATTR(vp, &va, curthread->td_ucred))
 4249                 return (0);
 4250 
 4251         VI_LOCK(vp);
 4252         kn->kn_data = va.va_size - kn->kn_fp->f_offset;
 4253         res = (kn->kn_data != 0);
 4254         VI_UNLOCK(vp);
 4255         return (res);
 4256 }
 4257 
 4258 /*ARGSUSED*/
 4259 static int
 4260 filt_vfswrite(struct knote *kn, long hint)
 4261 {
 4262         struct vnode *vp = (struct vnode *)kn->kn_hook;
 4263 
 4264         VI_LOCK(vp);
 4265 
 4266         /*
 4267          * filesystem is gone, so set the EOF flag and schedule
 4268          * the knote for deletion.
 4269          */
 4270         if (hint == NOTE_REVOKE)
 4271                 kn->kn_flags |= (EV_EOF | EV_ONESHOT);
 4272 
 4273         kn->kn_data = 0;
 4274         VI_UNLOCK(vp);
 4275         return (1);
 4276 }
 4277 
 4278 static int
 4279 filt_vfsvnode(struct knote *kn, long hint)
 4280 {
 4281         struct vnode *vp = (struct vnode *)kn->kn_hook;
 4282         int res;
 4283 
 4284         VI_LOCK(vp);
 4285         if (kn->kn_sfflags & hint)
 4286                 kn->kn_fflags |= hint;
 4287         if (hint == NOTE_REVOKE) {
 4288                 kn->kn_flags |= EV_EOF;
 4289                 VI_UNLOCK(vp);
 4290                 return (1);
 4291         }
 4292         res = (kn->kn_fflags != 0);
 4293         VI_UNLOCK(vp);
 4294         return (res);
 4295 }
 4296 
 4297 int
 4298 vfs_read_dirent(struct vop_readdir_args *ap, struct dirent *dp, off_t off)
 4299 {
 4300         int error;
 4301 
 4302         if (dp->d_reclen > ap->a_uio->uio_resid)
 4303                 return (ENAMETOOLONG);
 4304         error = uiomove(dp, dp->d_reclen, ap->a_uio);
 4305         if (error) {
 4306                 if (ap->a_ncookies != NULL) {
 4307                         if (ap->a_cookies != NULL)
 4308                                 free(ap->a_cookies, M_TEMP);
 4309                         ap->a_cookies = NULL;
 4310                         *ap->a_ncookies = 0;
 4311                 }
 4312                 return (error);
 4313         }
 4314         if (ap->a_ncookies == NULL)
 4315                 return (0);
 4316 
 4317         KASSERT(ap->a_cookies,
 4318             ("NULL ap->a_cookies value with non-NULL ap->a_ncookies!"));
 4319 
 4320         *ap->a_cookies = realloc(*ap->a_cookies,
 4321             (*ap->a_ncookies + 1) * sizeof(u_long), M_TEMP, M_WAITOK | M_ZERO);
 4322         (*ap->a_cookies)[*ap->a_ncookies] = off;
 4323         return (0);
 4324 }
 4325 
 4326 /*
 4327  * Mark for update the access time of the file if the filesystem
 4328  * supports VOP_MARKATIME.  This functionality is used by execve and
 4329  * mmap, so we want to avoid the I/O implied by directly setting
 4330  * va_atime for the sake of efficiency.
 4331  */
 4332 void
 4333 vfs_mark_atime(struct vnode *vp, struct ucred *cred)
 4334 {
 4335         struct mount *mp;
 4336 
 4337         mp = vp->v_mount;
 4338         VFS_ASSERT_GIANT(mp);
 4339         ASSERT_VOP_LOCKED(vp, "vfs_mark_atime");
 4340         if (mp != NULL && (mp->mnt_flag & (MNT_NOATIME | MNT_RDONLY)) == 0)
 4341                 (void)VOP_MARKATIME(vp);
 4342 }
 4343 
 4344 /*
 4345  * The purpose of this routine is to remove granularity from accmode_t,
 4346  * reducing it into standard unix access bits - VEXEC, VREAD, VWRITE,
 4347  * VADMIN and VAPPEND.
 4348  *
 4349  * If it returns 0, the caller is supposed to continue with the usual
 4350  * access checks using 'accmode' as modified by this routine.  If it
 4351  * returns nonzero value, the caller is supposed to return that value
 4352  * as errno.
 4353  *
 4354  * Note that after this routine runs, accmode may be zero.
 4355  */
 4356 int
 4357 vfs_unixify_accmode(accmode_t *accmode)
 4358 {
 4359         /*
 4360          * There is no way to specify explicit "deny" rule using
 4361          * file mode or POSIX.1e ACLs.
 4362          */
 4363         if (*accmode & VEXPLICIT_DENY) {
 4364                 *accmode = 0;
 4365                 return (0);
 4366         }
 4367 
 4368         /*
 4369          * None of these can be translated into usual access bits.
 4370          * Also, the common case for NFSv4 ACLs is to not contain
 4371          * either of these bits. Caller should check for VWRITE
 4372          * on the containing directory instead.
 4373          */
 4374         if (*accmode & (VDELETE_CHILD | VDELETE))
 4375                 return (EPERM);
 4376 
 4377         if (*accmode & VADMIN_PERMS) {
 4378                 *accmode &= ~VADMIN_PERMS;
 4379                 *accmode |= VADMIN;
 4380         }
 4381 
 4382         /*
 4383          * There is no way to deny VREAD_ATTRIBUTES, VREAD_ACL
 4384          * or VSYNCHRONIZE using file mode or POSIX.1e ACL.
 4385          */
 4386         *accmode &= ~(VSTAT_PERMS | VSYNCHRONIZE);
 4387 
 4388         return (0);
 4389 }

Cache object: 7bd64fec976aee188779d18ad6d5e9fb


[ 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.