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  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *      This product includes software developed by the University of
   21  *      California, Berkeley and its contributors.
   22  * 4. Neither the name of the University nor the names of its contributors
   23  *    may be used to endorse or promote products derived from this software
   24  *    without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   36  * SUCH DAMAGE.
   37  *
   38  *      @(#)vfs_subr.c  8.31 (Berkeley) 5/26/95
   39  * $FreeBSD: stable/3/sys/kern/vfs_subr.c 51323 1999-09-16 02:02:16Z alfred $
   40  */
   41 
   42 /*
   43  * External virtual filesystem routines
   44  */
   45 #include "opt_ddb.h"
   46 
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/conf.h>
   50 #include <sys/fcntl.h>
   51 #include <sys/kernel.h>
   52 #include <sys/proc.h>
   53 #include <sys/malloc.h>
   54 #include <sys/mount.h>
   55 #include <sys/socket.h>
   56 #include <sys/vnode.h>
   57 #include <sys/stat.h>
   58 #include <sys/buf.h>
   59 #include <sys/domain.h>
   60 #include <sys/dirent.h>
   61 #include <sys/vmmeter.h>
   62 
   63 #include <machine/limits.h>
   64 
   65 #include <vm/vm.h>
   66 #include <vm/vm_object.h>
   67 #include <vm/vm_extern.h>
   68 #include <vm/pmap.h>
   69 #include <vm/vm_map.h>
   70 #include <vm/vm_pager.h>
   71 #include <vm/vnode_pager.h>
   72 #include <vm/vm_zone.h>
   73 #include <sys/sysctl.h>
   74 
   75 #include <miscfs/specfs/specdev.h>
   76 
   77 static MALLOC_DEFINE(M_NETADDR, "Export Host", "Export host address structure");
   78 
   79 static void     insmntque __P((struct vnode *vp, struct mount *mp));
   80 static void     vclean __P((struct vnode *vp, int flags, struct proc *p));
   81 static void     vfree __P((struct vnode *));
   82 static void     vgonel __P((struct vnode *vp, struct proc *p));
   83 static unsigned long    numvnodes;
   84 SYSCTL_INT(_debug, OID_AUTO, numvnodes, CTLFLAG_RD, &numvnodes, 0, "");
   85 
   86 enum vtype iftovt_tab[16] = {
   87         VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
   88         VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
   89 };
   90 int vttoif_tab[9] = {
   91         0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK,
   92         S_IFSOCK, S_IFIFO, S_IFMT,
   93 };
   94 
   95 static TAILQ_HEAD(freelst, vnode) vnode_free_list;      /* vnode free list */
   96 struct tobefreelist vnode_tobefree_list;        /* vnode free list */
   97 
   98 static u_long wantfreevnodes = 25;
   99 SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW, &wantfreevnodes, 0, "");
  100 static u_long freevnodes = 0;
  101 SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD, &freevnodes, 0, "");
  102 
  103 int vfs_ioopt = 0;
  104 #ifdef ENABLE_VFS_IOOPT
  105 SYSCTL_INT(_vfs, OID_AUTO, ioopt, CTLFLAG_RW, &vfs_ioopt, 0, "");
  106 #endif
  107 
  108 struct mntlist mountlist;       /* mounted filesystem list */
  109 struct simplelock mountlist_slock;
  110 struct simplelock mntvnode_slock;
  111 int     nfs_mount_type = -1;
  112 #ifndef NULL_SIMPLELOCKS
  113 static struct simplelock mntid_slock;
  114 static struct simplelock vnode_free_list_slock;
  115 static struct simplelock spechash_slock;
  116 #endif
  117 struct nfs_public nfs_pub;      /* publicly exported FS */
  118 static vm_zone_t vnode_zone;
  119 
  120 /*
  121  * The workitem queue.
  122  */
  123 #define SYNCER_MAXDELAY         32
  124 static int syncer_maxdelay = SYNCER_MAXDELAY;   /* maximum delay time */
  125 time_t syncdelay =              30;
  126 int rushjob;                            /* number of slots to run ASAP */
  127 
  128 static int syncer_delayno = 0;
  129 static long syncer_mask; 
  130 LIST_HEAD(synclist, vnode);
  131 static struct synclist *syncer_workitem_pending;
  132 
  133 int desiredvnodes;
  134 SYSCTL_INT(_kern, KERN_MAXVNODES, maxvnodes, CTLFLAG_RW, &desiredvnodes, 0, "");
  135 
  136 static void     vfs_free_addrlist __P((struct netexport *nep));
  137 static int      vfs_free_netcred __P((struct radix_node *rn, void *w));
  138 static int      vfs_hang_addrlist __P((struct mount *mp, struct netexport *nep,
  139                                        struct export_args *argp));
  140 
  141 /*
  142  * Initialize the vnode management data structures.
  143  */
  144 void
  145 vntblinit()
  146 {
  147 
  148         desiredvnodes = maxproc + cnt.v_page_count / 4;
  149         simple_lock_init(&mntvnode_slock);
  150         simple_lock_init(&mntid_slock);
  151         simple_lock_init(&spechash_slock);
  152         TAILQ_INIT(&vnode_free_list);
  153         TAILQ_INIT(&vnode_tobefree_list);
  154         simple_lock_init(&vnode_free_list_slock);
  155         CIRCLEQ_INIT(&mountlist);
  156         vnode_zone = zinit("VNODE", sizeof (struct vnode), 0, 0, 5);
  157         /*
  158          * Initialize the filesystem syncer.
  159          */     
  160         syncer_workitem_pending = hashinit(syncer_maxdelay, M_VNODE, 
  161                 &syncer_mask);
  162         syncer_maxdelay = syncer_mask + 1;
  163 }
  164 
  165 /*
  166  * Mark a mount point as busy. Used to synchronize access and to delay
  167  * unmounting. Interlock is not released on failure.
  168  */
  169 int
  170 vfs_busy(mp, flags, interlkp, p)
  171         struct mount *mp;
  172         int flags;
  173         struct simplelock *interlkp;
  174         struct proc *p;
  175 {
  176         int lkflags;
  177 
  178         if (mp->mnt_kern_flag & MNTK_UNMOUNT) {
  179                 if (flags & LK_NOWAIT)
  180                         return (ENOENT);
  181                 mp->mnt_kern_flag |= MNTK_MWAIT;
  182                 if (interlkp) {
  183                         simple_unlock(interlkp);
  184                 }
  185                 /*
  186                  * Since all busy locks are shared except the exclusive
  187                  * lock granted when unmounting, the only place that a
  188                  * wakeup needs to be done is at the release of the
  189                  * exclusive lock at the end of dounmount.
  190                  */
  191                 tsleep((caddr_t)mp, PVFS, "vfs_busy", 0);
  192                 if (interlkp) {
  193                         simple_lock(interlkp);
  194                 }
  195                 return (ENOENT);
  196         }
  197         lkflags = LK_SHARED | LK_NOPAUSE;
  198         if (interlkp)
  199                 lkflags |= LK_INTERLOCK;
  200         if (lockmgr(&mp->mnt_lock, lkflags, interlkp, p))
  201                 panic("vfs_busy: unexpected lock failure");
  202         return (0);
  203 }
  204 
  205 /*
  206  * Free a busy filesystem.
  207  */
  208 void
  209 vfs_unbusy(mp, p)
  210         struct mount *mp;
  211         struct proc *p;
  212 {
  213 
  214         lockmgr(&mp->mnt_lock, LK_RELEASE, NULL, p);
  215 }
  216 
  217 /*
  218  * Lookup a filesystem type, and if found allocate and initialize
  219  * a mount structure for it.
  220  *
  221  * Devname is usually updated by mount(8) after booting.
  222  */
  223 int
  224 vfs_rootmountalloc(fstypename, devname, mpp)
  225         char *fstypename;
  226         char *devname;
  227         struct mount **mpp;
  228 {
  229         struct proc *p = curproc;       /* XXX */
  230         struct vfsconf *vfsp;
  231         struct mount *mp;
  232 
  233         if (fstypename == NULL)
  234                 return (ENODEV);
  235         for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
  236                 if (!strcmp(vfsp->vfc_name, fstypename))
  237                         break;
  238         if (vfsp == NULL)
  239                 return (ENODEV);
  240         mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK);
  241         bzero((char *)mp, (u_long)sizeof(struct mount));
  242         lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
  243         (void)vfs_busy(mp, LK_NOWAIT, 0, p);
  244         LIST_INIT(&mp->mnt_vnodelist);
  245         mp->mnt_vfc = vfsp;
  246         mp->mnt_op = vfsp->vfc_vfsops;
  247         mp->mnt_flag = MNT_RDONLY;
  248         mp->mnt_vnodecovered = NULLVP;
  249         vfsp->vfc_refcount++;
  250         mp->mnt_stat.f_type = vfsp->vfc_typenum;
  251         mp->mnt_flag |= vfsp->vfc_flags & MNT_VISFLAGMASK;
  252         strncpy(mp->mnt_stat.f_fstypename, vfsp->vfc_name, MFSNAMELEN);
  253         mp->mnt_stat.f_mntonname[0] = '/';
  254         mp->mnt_stat.f_mntonname[1] = 0;
  255         (void) copystr(devname, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, 0);
  256         *mpp = mp;
  257         return (0);
  258 }
  259 
  260 /*
  261  * Find an appropriate filesystem to use for the root. If a filesystem
  262  * has not been preselected, walk through the list of known filesystems
  263  * trying those that have mountroot routines, and try them until one
  264  * works or we have tried them all.
  265  */
  266 #ifdef notdef   /* XXX JH */
  267 int
  268 lite2_vfs_mountroot()
  269 {
  270         struct vfsconf *vfsp;
  271         extern int (*lite2_mountroot) __P((void));
  272         int error;
  273 
  274         if (lite2_mountroot != NULL)
  275                 return ((*lite2_mountroot)());
  276         for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
  277                 if (vfsp->vfc_mountroot == NULL)
  278                         continue;
  279                 if ((error = (*vfsp->vfc_mountroot)()) == 0)
  280                         return (0);
  281                 printf("%s_mountroot failed: %d\n", vfsp->vfc_name, error);
  282         }
  283         return (ENODEV);
  284 }
  285 #endif
  286 
  287 /*
  288  * Lookup a mount point by filesystem identifier.
  289  */
  290 struct mount *
  291 vfs_getvfs(fsid)
  292         fsid_t *fsid;
  293 {
  294         register struct mount *mp;
  295 
  296         simple_lock(&mountlist_slock);
  297         for (mp = mountlist.cqh_first; mp != (void *)&mountlist;
  298             mp = mp->mnt_list.cqe_next) {
  299                 if (mp->mnt_stat.f_fsid.val[0] == fsid->val[0] &&
  300                     mp->mnt_stat.f_fsid.val[1] == fsid->val[1]) {
  301                         simple_unlock(&mountlist_slock);
  302                         return (mp);
  303             }
  304         }
  305         simple_unlock(&mountlist_slock);
  306         return ((struct mount *) 0);
  307 }
  308 
  309 /*
  310  * Get a new unique fsid
  311  */
  312 void
  313 vfs_getnewfsid(mp)
  314         struct mount *mp;
  315 {
  316         static u_short xxxfs_mntid;
  317 
  318         fsid_t tfsid;
  319         int mtype;
  320 
  321         simple_lock(&mntid_slock); 
  322         mtype = mp->mnt_vfc->vfc_typenum;
  323         mp->mnt_stat.f_fsid.val[0] = makedev(nblkdev + mtype, 0);
  324         mp->mnt_stat.f_fsid.val[1] = mtype;
  325         if (xxxfs_mntid == 0)
  326                 ++xxxfs_mntid;
  327         tfsid.val[0] = makedev(nblkdev + mtype, xxxfs_mntid);
  328         tfsid.val[1] = mtype;
  329         if (mountlist.cqh_first != (void *)&mountlist) {
  330                 while (vfs_getvfs(&tfsid)) {
  331                         tfsid.val[0]++;
  332                         xxxfs_mntid++;
  333                 }
  334         }
  335         mp->mnt_stat.f_fsid.val[0] = tfsid.val[0];
  336         simple_unlock(&mntid_slock);
  337 }
  338 
  339 /*
  340  * Set vnode attributes to VNOVAL
  341  */
  342 void
  343 vattr_null(vap)
  344         register struct vattr *vap;
  345 {
  346 
  347         vap->va_type = VNON;
  348         vap->va_size = VNOVAL;
  349         vap->va_bytes = VNOVAL;
  350         vap->va_mode = VNOVAL;
  351         vap->va_nlink = VNOVAL;
  352         vap->va_uid = VNOVAL;
  353         vap->va_gid = VNOVAL;
  354         vap->va_fsid = VNOVAL;
  355         vap->va_fileid = VNOVAL;
  356         vap->va_blocksize = VNOVAL;
  357         vap->va_rdev = VNOVAL;
  358         vap->va_atime.tv_sec = VNOVAL;
  359         vap->va_atime.tv_nsec = VNOVAL;
  360         vap->va_mtime.tv_sec = VNOVAL;
  361         vap->va_mtime.tv_nsec = VNOVAL;
  362         vap->va_ctime.tv_sec = VNOVAL;
  363         vap->va_ctime.tv_nsec = VNOVAL;
  364         vap->va_flags = VNOVAL;
  365         vap->va_gen = VNOVAL;
  366         vap->va_vaflags = 0;
  367 }
  368 
  369 /*
  370  * Routines having to do with the management of the vnode table.
  371  */
  372 extern vop_t **dead_vnodeop_p;
  373 
  374 /*
  375  * Return the next vnode from the free list.
  376  */
  377 int
  378 getnewvnode(tag, mp, vops, vpp)
  379         enum vtagtype tag;
  380         struct mount *mp;
  381         vop_t **vops;
  382         struct vnode **vpp;
  383 {
  384         int s;
  385         struct proc *p = curproc;       /* XXX */
  386         struct vnode *vp, *tvp, *nvp;
  387         vm_object_t object;
  388         TAILQ_HEAD(freelst, vnode) vnode_tmp_list;
  389 
  390         /*
  391          * We take the least recently used vnode from the freelist
  392          * if we can get it and it has no cached pages, and no
  393          * namecache entries are relative to it.
  394          * Otherwise we allocate a new vnode
  395          */
  396 
  397         s = splbio();
  398         simple_lock(&vnode_free_list_slock);
  399         TAILQ_INIT(&vnode_tmp_list);
  400 
  401         for (vp = TAILQ_FIRST(&vnode_tobefree_list); vp; vp = nvp) {
  402                 nvp = TAILQ_NEXT(vp, v_freelist);
  403                 TAILQ_REMOVE(&vnode_tobefree_list, vp, v_freelist);
  404                 if (vp->v_flag & VAGE) {
  405                         TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
  406                 } else {
  407                         TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
  408                 }
  409                 vp->v_flag &= ~(VTBFREE|VAGE);
  410                 vp->v_flag |= VFREE;
  411                 if (vp->v_usecount)
  412                         panic("tobe free vnode isn't");
  413                 freevnodes++;
  414         }
  415 
  416         if (wantfreevnodes && freevnodes < wantfreevnodes) {
  417                 vp = NULL;
  418         } else if (!wantfreevnodes && freevnodes <= desiredvnodes) {
  419                 /* 
  420                  * XXX: this is only here to be backwards compatible
  421                  */
  422                 vp = NULL;
  423         } else {
  424                 for (vp = TAILQ_FIRST(&vnode_free_list); vp; vp = nvp) {
  425                         nvp = TAILQ_NEXT(vp, v_freelist);
  426                         if (!simple_lock_try(&vp->v_interlock)) 
  427                                 continue;
  428                         if (vp->v_usecount)
  429                                 panic("free vnode isn't");
  430 
  431                         object = vp->v_object;
  432                         if (object && (object->resident_page_count || object->ref_count)) {
  433                                 printf("object inconsistant state: RPC: %d, RC: %d\n",
  434                                         object->resident_page_count, object->ref_count);
  435                                 /* Don't recycle if it's caching some pages */
  436                                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  437                                 TAILQ_INSERT_TAIL(&vnode_tmp_list, vp, v_freelist);
  438                                 continue;
  439                         } else if (LIST_FIRST(&vp->v_cache_src)) {
  440                                 /* Don't recycle if active in the namecache */
  441                                 simple_unlock(&vp->v_interlock);
  442                                 continue;
  443                         } else {
  444                                 break;
  445                         }
  446                 }
  447         }
  448 
  449         for (tvp = TAILQ_FIRST(&vnode_tmp_list); tvp; tvp = nvp) {
  450                 nvp = TAILQ_NEXT(tvp, v_freelist);
  451                 TAILQ_REMOVE(&vnode_tmp_list, tvp, v_freelist);
  452                 TAILQ_INSERT_TAIL(&vnode_free_list, tvp, v_freelist);
  453                 simple_unlock(&tvp->v_interlock);
  454         }
  455 
  456         if (vp) {
  457                 vp->v_flag |= VDOOMED;
  458                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  459                 freevnodes--;
  460                 simple_unlock(&vnode_free_list_slock);
  461                 cache_purge(vp);
  462                 vp->v_lease = NULL;
  463                 if (vp->v_type != VBAD) {
  464                         vgonel(vp, p);
  465                 } else {
  466                         simple_unlock(&vp->v_interlock);
  467                 }
  468 
  469 #ifdef INVARIANTS
  470                 {
  471                         int s;
  472 
  473                         if (vp->v_data)
  474                                 panic("cleaned vnode isn't");
  475                         s = splbio();
  476                         if (vp->v_numoutput)
  477                                 panic("Clean vnode has pending I/O's");
  478                         splx(s);
  479                 }
  480 #endif
  481                 vp->v_flag = 0;
  482                 vp->v_lastr = 0;
  483                 vp->v_lastw = 0;
  484                 vp->v_lasta = 0;
  485                 vp->v_cstart = 0;
  486                 vp->v_clen = 0;
  487                 vp->v_socket = 0;
  488                 vp->v_writecount = 0;   /* XXX */
  489                 vp->v_maxio = 0;
  490                 vp->v_cache_dst_count = 0;
  491         } else {
  492                 simple_unlock(&vnode_free_list_slock);
  493                 vp = (struct vnode *) zalloc(vnode_zone);
  494                 bzero((char *) vp, sizeof *vp);
  495                 simple_lock_init(&vp->v_interlock);
  496                 vp->v_dd = vp;
  497                 cache_purge(vp);
  498                 LIST_INIT(&vp->v_cache_src);
  499                 TAILQ_INIT(&vp->v_cache_dst);
  500                 numvnodes++;
  501         }
  502 
  503         TAILQ_INIT(&vp->v_cleanblkhd);
  504         TAILQ_INIT(&vp->v_dirtyblkhd);
  505         vp->v_type = VNON;
  506         vp->v_tag = tag;
  507         vp->v_op = vops;
  508         insmntque(vp, mp);
  509         *vpp = vp;
  510         vp->v_usecount = 1;
  511         vp->v_data = 0;
  512         splx(s);
  513 
  514         vfs_object_create(vp, p, p->p_ucred);
  515         return (0);
  516 }
  517 
  518 /*
  519  * Move a vnode from one mount queue to another.
  520  */
  521 static void
  522 insmntque(vp, mp)
  523         register struct vnode *vp;
  524         register struct mount *mp;
  525 {
  526 
  527         simple_lock(&mntvnode_slock);
  528         /*
  529          * Delete from old mount point vnode list, if on one.
  530          */
  531         if (vp->v_mount != NULL)
  532                 LIST_REMOVE(vp, v_mntvnodes);
  533         /*
  534          * Insert into list of vnodes for the new mount point, if available.
  535          */
  536         if ((vp->v_mount = mp) == NULL) {
  537                 simple_unlock(&mntvnode_slock);
  538                 return;
  539         }
  540         LIST_INSERT_HEAD(&mp->mnt_vnodelist, vp, v_mntvnodes);
  541         simple_unlock(&mntvnode_slock);
  542 }
  543 
  544 /*
  545  * Update outstanding I/O count and do wakeup if requested.
  546  */
  547 void
  548 vwakeup(bp)
  549         register struct buf *bp;
  550 {
  551         register struct vnode *vp;
  552 
  553         bp->b_flags &= ~B_WRITEINPROG;
  554         if ((vp = bp->b_vp)) {
  555                 vp->v_numoutput--;
  556                 if (vp->v_numoutput < 0)
  557                         panic("vwakeup: neg numoutput");
  558                 if ((vp->v_numoutput == 0) && (vp->v_flag & VBWAIT)) {
  559                         vp->v_flag &= ~VBWAIT;
  560                         wakeup((caddr_t) &vp->v_numoutput);
  561                 }
  562         }
  563 }
  564 
  565 /*
  566  * Flush out and invalidate all buffers associated with a vnode.
  567  * Called with the underlying object locked.
  568  */
  569 int
  570 vinvalbuf(vp, flags, cred, p, slpflag, slptimeo)
  571         register struct vnode *vp;
  572         int flags;
  573         struct ucred *cred;
  574         struct proc *p;
  575         int slpflag, slptimeo;
  576 {
  577         register struct buf *bp;
  578         struct buf *nbp, *blist;
  579         int s, error;
  580         vm_object_t object;
  581 
  582         if (flags & V_SAVE) {
  583                 s = splbio();
  584                 while (vp->v_numoutput) {
  585                         vp->v_flag |= VBWAIT;
  586                         error = tsleep((caddr_t)&vp->v_numoutput,
  587                             slpflag | (PRIBIO + 1), "vinvlbuf", slptimeo);
  588                         if (error) {
  589                                 splx(s);
  590                                 return (error);
  591                         }
  592                 }
  593                 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
  594                         splx(s);
  595                         if ((error = VOP_FSYNC(vp, cred, MNT_WAIT, p)) != 0)
  596                                 return (error);
  597                         s = splbio();
  598                         if (vp->v_numoutput > 0 ||
  599                             !TAILQ_EMPTY(&vp->v_dirtyblkhd))
  600                                 panic("vinvalbuf: dirty bufs");
  601                 }
  602                 splx(s);
  603         }
  604         s = splbio();
  605         for (;;) {
  606                 blist = TAILQ_FIRST(&vp->v_cleanblkhd);
  607                 if (!blist)
  608                         blist = TAILQ_FIRST(&vp->v_dirtyblkhd);
  609                 if (!blist)
  610                         break;
  611 
  612                 for (bp = blist; bp; bp = nbp) {
  613                         nbp = TAILQ_NEXT(bp, b_vnbufs);
  614                         if (bp->b_flags & B_BUSY) {
  615                                 bp->b_flags |= B_WANTED;
  616                                 error = tsleep((caddr_t) bp,
  617                                     slpflag | (PRIBIO + 4), "vinvalbuf",
  618                                     slptimeo);
  619                                 if (error) {
  620                                         splx(s);
  621                                         return (error);
  622                                 }
  623                                 break;
  624                         }
  625                         /*
  626                          * XXX Since there are no node locks for NFS, I
  627                          * believe there is a slight chance that a delayed
  628                          * write will occur while sleeping just above, so
  629                          * check for it.  Note that vfs_bio_awrite expects
  630                          * buffers to reside on a queue, while VOP_BWRITE and
  631                          * brelse do not.
  632                          */
  633                         if (((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI) &&
  634                                 (flags & V_SAVE)) {
  635 
  636                                 if (bp->b_vp == vp) {
  637                                         if (bp->b_flags & B_CLUSTEROK) {
  638                                                 vfs_bio_awrite(bp);
  639                                         } else {
  640                                                 bremfree(bp);
  641                                                 bp->b_flags |= (B_BUSY | B_ASYNC);
  642                                                 VOP_BWRITE(bp);
  643                                         }
  644                                 } else {
  645                                         bremfree(bp);
  646                                         bp->b_flags |= B_BUSY;
  647                                         (void) VOP_BWRITE(bp);
  648                                 }
  649                                 break;
  650                         }
  651                         bremfree(bp);
  652                         bp->b_flags |= (B_INVAL | B_NOCACHE | B_RELBUF | B_BUSY);
  653                         bp->b_flags &= ~B_ASYNC;
  654                         brelse(bp);
  655                 }
  656         }
  657 
  658         while (vp->v_numoutput > 0) {
  659                 vp->v_flag |= VBWAIT;
  660                 tsleep(&vp->v_numoutput, PVM, "vnvlbv", 0);
  661         }
  662 
  663         splx(s);
  664 
  665         /*
  666          * Destroy the copy in the VM cache, too.
  667          */
  668         simple_lock(&vp->v_interlock);
  669         object = vp->v_object;
  670         if (object != NULL) {
  671                 vm_object_page_remove(object, 0, 0,
  672                         (flags & V_SAVE) ? TRUE : FALSE);
  673         }
  674         simple_unlock(&vp->v_interlock);
  675 
  676         if (!TAILQ_EMPTY(&vp->v_dirtyblkhd) || !TAILQ_EMPTY(&vp->v_cleanblkhd))
  677                 panic("vinvalbuf: flush failed");
  678         return (0);
  679 }
  680 
  681 /*
  682  * Truncate a file's buffer and pages to a specified length.  This
  683  * is in lieu of the old vinvalbuf mechanism, which performed unneeded
  684  * sync activity.
  685  */
  686 int
  687 vtruncbuf(vp, cred, p, length, blksize)
  688         register struct vnode *vp;
  689         struct ucred *cred;
  690         struct proc *p;
  691         off_t length;
  692         int blksize;
  693 {
  694         register struct buf *bp;
  695         struct buf *nbp;
  696         int s, anyfreed;
  697         int trunclbn;
  698 
  699         /*
  700          * Round up to the *next* lbn.
  701          */
  702         trunclbn = (length + blksize - 1) / blksize;
  703 
  704         s = splbio();
  705 restart:
  706         anyfreed = 1;
  707         for (;anyfreed;) {
  708                 anyfreed = 0;
  709                 for (bp = TAILQ_FIRST(&vp->v_cleanblkhd); bp; bp = nbp) {
  710                         nbp = TAILQ_NEXT(bp, b_vnbufs);
  711                         if (bp->b_lblkno >= trunclbn) {
  712                                 if (bp->b_flags & B_BUSY) {
  713                                         bp->b_flags |= B_WANTED;
  714                                         tsleep(bp, PRIBIO + 4, "vtrb1", 0);
  715                                         goto restart;
  716                                 } else {
  717                                         bremfree(bp);
  718                                         bp->b_flags |= (B_BUSY | B_INVAL | B_RELBUF);
  719                                         bp->b_flags &= ~B_ASYNC;
  720                                         brelse(bp);
  721                                         anyfreed = 1;
  722                                 }
  723                                 if (nbp && (((nbp->b_xflags & B_VNCLEAN) == 0)||
  724                                          (nbp->b_vp != vp) ||
  725                                          (nbp->b_flags & B_DELWRI))) {
  726                                         goto restart;
  727                                 }
  728                         }
  729                 }
  730 
  731                 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
  732                         nbp = TAILQ_NEXT(bp, b_vnbufs);
  733                         if (bp->b_lblkno >= trunclbn) {
  734                                 if (bp->b_flags & B_BUSY) {
  735                                         bp->b_flags |= B_WANTED;
  736                                         tsleep(bp, PRIBIO + 4, "vtrb2", 0);
  737                                         goto restart;
  738                                 } else {
  739                                         bremfree(bp);
  740                                         bp->b_flags |= (B_BUSY | B_INVAL | B_RELBUF);
  741                                         bp->b_flags &= ~B_ASYNC;
  742                                         brelse(bp);
  743                                         anyfreed = 1;
  744                                 }
  745                                 if (nbp && (((nbp->b_xflags & B_VNDIRTY) == 0)||
  746                                          (nbp->b_vp != vp) ||
  747                                          (nbp->b_flags & B_DELWRI) == 0)) {
  748                                         goto restart;
  749                                 }
  750                         }
  751                 }
  752         }
  753 
  754         if (length > 0) {
  755 restartsync:
  756                 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
  757                         nbp = TAILQ_NEXT(bp, b_vnbufs);
  758                         if ((bp->b_flags & B_DELWRI) && (bp->b_lblkno < 0)) {
  759                                 if (bp->b_flags & B_BUSY) {
  760                                         bp->b_flags |= B_WANTED;
  761                                         tsleep(bp, PRIBIO, "vtrb3", 0);
  762                                 } else {
  763                                         bremfree(bp);
  764                                         bp->b_flags |= B_BUSY;
  765                                         if (bp->b_vp == vp) {
  766                                                 bp->b_flags |= B_ASYNC;
  767                                         } else {
  768                                                 bp->b_flags &= ~B_ASYNC;
  769                                         }
  770                                         VOP_BWRITE(bp);
  771                                 }
  772                                 goto restartsync;
  773                         }
  774 
  775                 }
  776         }
  777 
  778         while (vp->v_numoutput > 0) {
  779                 vp->v_flag |= VBWAIT;
  780                 tsleep(&vp->v_numoutput, PVM, "vbtrunc", 0);
  781         }
  782 
  783         splx(s);
  784 
  785         vnode_pager_setsize(vp, length);
  786 
  787         return (0);
  788 }
  789 
  790 /*
  791  * Associate a buffer with a vnode.
  792  */
  793 void
  794 bgetvp(vp, bp)
  795         register struct vnode *vp;
  796         register struct buf *bp;
  797 {
  798         int s;
  799 
  800         KASSERT(bp->b_vp == NULL, ("bgetvp: not free"));
  801 
  802         vhold(vp);
  803         bp->b_vp = vp;
  804         if (vp->v_type == VBLK || vp->v_type == VCHR)
  805                 bp->b_dev = vp->v_rdev;
  806         else
  807                 bp->b_dev = NODEV;
  808         /*
  809          * Insert onto list for new vnode.
  810          */
  811         s = splbio();
  812         bp->b_xflags |= B_VNCLEAN;
  813         bp->b_xflags &= ~B_VNDIRTY;
  814         TAILQ_INSERT_TAIL(&vp->v_cleanblkhd, bp, b_vnbufs);
  815         splx(s);
  816 }
  817 
  818 /*
  819  * Disassociate a buffer from a vnode.
  820  */
  821 void
  822 brelvp(bp)
  823         register struct buf *bp;
  824 {
  825         struct vnode *vp;
  826         struct buflists *listheadp;
  827         int s;
  828 
  829         KASSERT(bp->b_vp != NULL, ("brelvp: NULL"));
  830 
  831         /*
  832          * Delete from old vnode list, if on one.
  833          */
  834         vp = bp->b_vp;
  835         s = splbio();
  836         if (bp->b_xflags & (B_VNDIRTY|B_VNCLEAN)) {
  837                 if (bp->b_xflags & B_VNDIRTY)
  838                         listheadp = &vp->v_dirtyblkhd;
  839                 else 
  840                         listheadp = &vp->v_cleanblkhd;
  841                 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
  842                 bp->b_xflags &= ~(B_VNDIRTY|B_VNCLEAN);
  843         }
  844         if ((vp->v_flag & VONWORKLST) && TAILQ_EMPTY(&vp->v_dirtyblkhd)) {
  845                 vp->v_flag &= ~VONWORKLST;
  846                 LIST_REMOVE(vp, v_synclist);
  847         }
  848         splx(s);
  849         bp->b_vp = (struct vnode *) 0;
  850         vdrop(vp);
  851 }
  852 
  853 /*
  854  * The workitem queue.
  855  * 
  856  * It is useful to delay writes of file data and filesystem metadata
  857  * for tens of seconds so that quickly created and deleted files need
  858  * not waste disk bandwidth being created and removed. To realize this,
  859  * we append vnodes to a "workitem" queue. When running with a soft
  860  * updates implementation, most pending metadata dependencies should
  861  * not wait for more than a few seconds. Thus, mounted on block devices
  862  * are delayed only about a half the time that file data is delayed.
  863  * Similarly, directory updates are more critical, so are only delayed
  864  * about a third the time that file data is delayed. Thus, there are
  865  * SYNCER_MAXDELAY queues that are processed round-robin at a rate of
  866  * one each second (driven off the filesystem syner process). The
  867  * syncer_delayno variable indicates the next queue that is to be processed.
  868  * Items that need to be processed soon are placed in this queue:
  869  *
  870  *      syncer_workitem_pending[syncer_delayno]
  871  *
  872  * A delay of fifteen seconds is done by placing the request fifteen
  873  * entries later in the queue:
  874  *
  875  *      syncer_workitem_pending[(syncer_delayno + 15) & syncer_mask]
  876  *
  877  */
  878 
  879 /*
  880  * Add an item to the syncer work queue.
  881  */
  882 void
  883 vn_syncer_add_to_worklist(vp, delay)
  884         struct vnode *vp;
  885         int delay;
  886 {
  887         int s, slot;
  888 
  889         s = splbio();
  890 
  891         if (vp->v_flag & VONWORKLST) {
  892                 LIST_REMOVE(vp, v_synclist);
  893         }
  894 
  895         if (delay > syncer_maxdelay - 2)
  896                 delay = syncer_maxdelay - 2;
  897         slot = (syncer_delayno + delay) & syncer_mask;
  898 
  899         LIST_INSERT_HEAD(&syncer_workitem_pending[slot], vp, v_synclist);
  900         vp->v_flag |= VONWORKLST;
  901         splx(s);
  902 }
  903 
  904 static void sched_sync __P((void));
  905 static struct   proc *updateproc;
  906 static struct kproc_desc up_kp = {
  907         "syncer",
  908         sched_sync,
  909         &updateproc
  910 };
  911 SYSINIT_KT(syncer, SI_SUB_KTHREAD_UPDATE, SI_ORDER_FIRST, kproc_start, &up_kp)
  912 
  913 /*
  914  * System filesystem synchronizer daemon.
  915  */
  916 void 
  917 sched_sync(void)
  918 {
  919         struct synclist *slp;
  920         struct vnode *vp;
  921         long starttime;
  922         int s;
  923         struct proc *p = updateproc;
  924 
  925         for (;;) {
  926                 starttime = time_second;
  927 
  928                 /*
  929                  * Push files whose dirty time has expired.  Be careful
  930                  * of interrupt race on slp queue
  931                  */
  932                 s = splbio();
  933                 slp = &syncer_workitem_pending[syncer_delayno];
  934                 syncer_delayno += 1;
  935                 if (syncer_delayno == syncer_maxdelay)
  936                         syncer_delayno = 0;
  937                 splx(s);
  938 
  939                 while ((vp = LIST_FIRST(slp)) != NULL) {
  940                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
  941                         (void) VOP_FSYNC(vp, p->p_ucred, MNT_LAZY, p);
  942                         VOP_UNLOCK(vp, 0, p);
  943                         s = splbio();
  944                         if (LIST_FIRST(slp) == vp) {
  945                                 if (TAILQ_EMPTY(&vp->v_dirtyblkhd) &&
  946                                     vp->v_type != VBLK)
  947                                         panic("sched_sync: fsync failed");
  948                                 /*
  949                                  * Move ourselves to the back of the sync list.
  950                                  * Put us back on the worklist.  The worklist
  951                                  * routine will remove us from our current
  952                                  * position and then add us back in at a later
  953                                  * position.
  954                                  */
  955                                 vn_syncer_add_to_worklist(vp, syncdelay);
  956                         }
  957                         splx(s);
  958                 }
  959 
  960                 /*
  961                  * Do soft update processing.
  962                  */
  963                 if (bioops.io_sync)
  964                         (*bioops.io_sync)(NULL);
  965 
  966                 /*
  967                  * The variable rushjob allows the kernel to speed up the
  968                  * processing of the filesystem syncer process. A rushjob
  969                  * value of N tells the filesystem syncer to process the next
  970                  * N seconds worth of work on its queue ASAP. Currently rushjob
  971                  * is used by the soft update code to speed up the filesystem
  972                  * syncer process when the incore state is getting so far
  973                  * ahead of the disk that the kernel memory pool is being
  974                  * threatened with exhaustion.
  975                  */
  976                 if (rushjob > 0) {
  977                         rushjob -= 1;
  978                         continue;
  979                 }
  980                 /*
  981                  * If it has taken us less than a second to process the
  982                  * current work, then wait. Otherwise start right over
  983                  * again. We can still lose time if any single round
  984                  * takes more than two seconds, but it does not really
  985                  * matter as we are just trying to generally pace the
  986                  * filesystem activity.
  987                  */
  988                 if (time_second == starttime)
  989                         tsleep(&lbolt, PPAUSE, "syncer", 0);
  990         }
  991 }
  992 
  993 /*
  994  * Associate a p-buffer with a vnode.
  995  */
  996 void
  997 pbgetvp(vp, bp)
  998         register struct vnode *vp;
  999         register struct buf *bp;
 1000 {
 1001 
 1002         KASSERT(bp->b_vp == NULL, ("pbgetvp: not free"));
 1003 
 1004         bp->b_vp = vp;
 1005         if (vp->v_type == VBLK || vp->v_type == VCHR)
 1006                 bp->b_dev = vp->v_rdev;
 1007         else
 1008                 bp->b_dev = NODEV;
 1009 }
 1010 
 1011 /*
 1012  * Disassociate a p-buffer from a vnode.
 1013  */
 1014 void
 1015 pbrelvp(bp)
 1016         register struct buf *bp;
 1017 {
 1018 
 1019         KASSERT(bp->b_vp != NULL, ("pbrelvp: NULL"));
 1020 
 1021         bp->b_vp = (struct vnode *) 0;
 1022 }
 1023 
 1024 /*
 1025  * Reassign a buffer from one vnode to another.
 1026  * Used to assign file specific control information
 1027  * (indirect blocks) to the vnode to which they belong.
 1028  */
 1029 void
 1030 reassignbuf(bp, newvp)
 1031         register struct buf *bp;
 1032         register struct vnode *newvp;
 1033 {
 1034         struct buflists *listheadp;
 1035         struct vnode *oldvp;
 1036         int delay;
 1037         int s;
 1038 
 1039         if (newvp == NULL) {
 1040                 printf("reassignbuf: NULL");
 1041                 return;
 1042         }
 1043 
 1044         s = splbio();
 1045         /*
 1046          * Delete from old vnode list, if on one.
 1047          */
 1048         if (bp->b_xflags & (B_VNDIRTY|B_VNCLEAN)) {
 1049                 oldvp = bp->b_vp;
 1050                 if (bp->b_xflags & B_VNDIRTY)
 1051                         listheadp = &oldvp->v_dirtyblkhd;
 1052                 else 
 1053                         listheadp = &oldvp->v_cleanblkhd;
 1054                 TAILQ_REMOVE(listheadp, bp, b_vnbufs);
 1055                 bp->b_xflags &= ~(B_VNDIRTY|B_VNCLEAN);
 1056                 vdrop(oldvp);
 1057         }
 1058         /*
 1059          * If dirty, put on list of dirty buffers; otherwise insert onto list
 1060          * of clean buffers.
 1061          */
 1062         if (bp->b_flags & B_DELWRI) {
 1063                 struct buf *tbp;
 1064 
 1065                 listheadp = &newvp->v_dirtyblkhd;
 1066                 if ((newvp->v_flag & VONWORKLST) == 0) {
 1067                         switch (newvp->v_type) {
 1068                         case VDIR:
 1069                                 delay = syncdelay / 3;
 1070                                 break;
 1071                         case VBLK:
 1072                                 if (newvp->v_specmountpoint != NULL) {
 1073                                         delay = syncdelay / 2;
 1074                                         break;
 1075                                 }
 1076                                 /* fall through */
 1077                         default:
 1078                                 delay = syncdelay;
 1079                         }
 1080                         vn_syncer_add_to_worklist(newvp, delay);
 1081                 }
 1082                 bp->b_xflags |= B_VNDIRTY;
 1083                 tbp = TAILQ_FIRST(listheadp);
 1084                 if (tbp == NULL ||
 1085                     (bp->b_lblkno >= 0 && tbp->b_lblkno > bp->b_lblkno)) {
 1086                         TAILQ_INSERT_HEAD(listheadp, bp, b_vnbufs);
 1087                 } else {
 1088                         if (bp->b_lblkno >= 0) {
 1089                                 struct buf *ttbp;
 1090                                 while ((ttbp = TAILQ_NEXT(tbp, b_vnbufs)) &&
 1091                                     (ttbp->b_lblkno < bp->b_lblkno)) {
 1092                                         tbp = ttbp;
 1093                                 }
 1094                                 TAILQ_INSERT_AFTER(listheadp, tbp, bp, b_vnbufs);
 1095                         } else {
 1096                                 TAILQ_INSERT_TAIL(listheadp, bp, b_vnbufs);
 1097                         }
 1098                 }
 1099         } else {
 1100                 bp->b_xflags |= B_VNCLEAN;
 1101                 TAILQ_INSERT_TAIL(&newvp->v_cleanblkhd, bp, b_vnbufs);
 1102                 if ((newvp->v_flag & VONWORKLST) &&
 1103                     TAILQ_EMPTY(&newvp->v_dirtyblkhd)) {
 1104                         newvp->v_flag &= ~VONWORKLST;
 1105                         LIST_REMOVE(newvp, v_synclist);
 1106                 }
 1107         }
 1108         bp->b_vp = newvp;
 1109         vhold(bp->b_vp);
 1110         splx(s);
 1111 }
 1112 
 1113 /*
 1114  * Create a vnode for a block device.
 1115  * Used for mounting the root file system.
 1116  */
 1117 int
 1118 bdevvp(dev, vpp)
 1119         dev_t dev;
 1120         struct vnode **vpp;
 1121 {
 1122         register struct vnode *vp;
 1123         struct vnode *nvp;
 1124         int error;
 1125 
 1126         /* XXX 255 is for mfs. */
 1127         if (dev == NODEV || (major(dev) != 255 && (major(dev) >= nblkdev ||
 1128             bdevsw[major(dev)] == NULL))) {
 1129                 *vpp = NULLVP;
 1130                 return (ENXIO);
 1131         }
 1132         error = getnewvnode(VT_NON, (struct mount *)0, spec_vnodeop_p, &nvp);
 1133         if (error) {
 1134                 *vpp = NULLVP;
 1135                 return (error);
 1136         }
 1137         vp = nvp;
 1138         vp->v_type = VBLK;
 1139         if ((nvp = checkalias(vp, dev, (struct mount *)0)) != NULL) {
 1140                 vput(vp);
 1141                 vp = nvp;
 1142         }
 1143         *vpp = vp;
 1144         return (0);
 1145 }
 1146 
 1147 /*
 1148  * Check to see if the new vnode represents a special device
 1149  * for which we already have a vnode (either because of
 1150  * bdevvp() or because of a different vnode representing
 1151  * the same block device). If such an alias exists, deallocate
 1152  * the existing contents and return the aliased vnode. The
 1153  * caller is responsible for filling it with its new contents.
 1154  */
 1155 struct vnode *
 1156 checkalias(nvp, nvp_rdev, mp)
 1157         register struct vnode *nvp;
 1158         dev_t nvp_rdev;
 1159         struct mount *mp;
 1160 {
 1161         struct proc *p = curproc;       /* XXX */
 1162         struct vnode *vp;
 1163         struct vnode **vpp;
 1164 
 1165         if (nvp->v_type != VBLK && nvp->v_type != VCHR)
 1166                 return (NULLVP);
 1167 
 1168         vpp = &speclisth[SPECHASH(nvp_rdev)];
 1169 loop:
 1170         simple_lock(&spechash_slock);
 1171         for (vp = *vpp; vp; vp = vp->v_specnext) {
 1172                 if (nvp_rdev != vp->v_rdev || nvp->v_type != vp->v_type)
 1173                         continue;
 1174                 /*
 1175                  * Alias, but not in use, so flush it out.
 1176                  * Only alias active device nodes.
 1177                  * Not sure why we don't re-use this like we do below.
 1178                  */
 1179                 simple_lock(&vp->v_interlock);
 1180                 if (vp->v_usecount == 0) {
 1181                         simple_unlock(&spechash_slock);
 1182                         vgonel(vp, p);
 1183                         goto loop;
 1184                 }
 1185                 if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, p)) {
 1186                         /*
 1187                          * It dissappeared, and we may have slept.
 1188                          * Restart from the beginning
 1189                          */
 1190                         simple_unlock(&spechash_slock);
 1191                         goto loop;
 1192                 }
 1193                 break;
 1194         }
 1195         /*
 1196          * It would be a lot clearer what is going on here if
 1197          * this had been expressed as:
 1198          * if ( vp && (vp->v_tag == VT_NULL))
 1199          * and the clauses had been swapped.
 1200          */
 1201         if (vp == NULL || vp->v_tag != VT_NON) {
 1202                 /*
 1203                  * Put the new vnode into the hash chain.
 1204                  * and if there was an alias, connect them.
 1205                  */
 1206                 MALLOC(nvp->v_specinfo, struct specinfo *,
 1207                     sizeof(struct specinfo), M_VNODE, M_WAITOK);
 1208                 nvp->v_rdev = nvp_rdev;
 1209                 nvp->v_hashchain = vpp;
 1210                 nvp->v_specnext = *vpp;
 1211                 nvp->v_specmountpoint = NULL;
 1212                 simple_unlock(&spechash_slock);
 1213                 *vpp = nvp;
 1214                 if (vp != NULLVP) {
 1215                         nvp->v_flag |= VALIASED;
 1216                         vp->v_flag |= VALIASED;
 1217                         vput(vp);
 1218                 }
 1219                 return (NULLVP);
 1220         }
 1221         /*
 1222          * if ( vp && (vp->v_tag == VT_NULL))
 1223          * We have a vnode alias, but it is a trashed.
 1224          * Make it look like it's newley allocated. (by getnewvnode())
 1225          * The caller should use this instead.
 1226          */
 1227         simple_unlock(&spechash_slock);
 1228         VOP_UNLOCK(vp, 0, p);
 1229         simple_lock(&vp->v_interlock);
 1230         vclean(vp, 0, p);
 1231         vp->v_op = nvp->v_op;
 1232         vp->v_tag = nvp->v_tag;
 1233         nvp->v_type = VNON;
 1234         insmntque(vp, mp);
 1235         return (vp);
 1236 }
 1237 
 1238 /*
 1239  * Grab a particular vnode from the free list, increment its
 1240  * reference count and lock it. The vnode lock bit is set the
 1241  * vnode is being eliminated in vgone. The process is awakened
 1242  * when the transition is completed, and an error returned to
 1243  * indicate that the vnode is no longer usable (possibly having
 1244  * been changed to a new file system type).
 1245  */
 1246 int
 1247 vget(vp, flags, p)
 1248         register struct vnode *vp;
 1249         int flags;
 1250         struct proc *p;
 1251 {
 1252         int error;
 1253 
 1254         /*
 1255          * If the vnode is in the process of being cleaned out for
 1256          * another use, we wait for the cleaning to finish and then
 1257          * return failure. Cleaning is determined by checking that
 1258          * the VXLOCK flag is set.
 1259          */
 1260         if ((flags & LK_INTERLOCK) == 0) {
 1261                 simple_lock(&vp->v_interlock);
 1262         }
 1263         if (vp->v_flag & VXLOCK) {
 1264                 vp->v_flag |= VXWANT;
 1265                 simple_unlock(&vp->v_interlock);
 1266                 tsleep((caddr_t)vp, PINOD, "vget", 0);
 1267                 return (ENOENT);
 1268         }
 1269 
 1270         vp->v_usecount++;
 1271 
 1272         if (VSHOULDBUSY(vp))
 1273                 vbusy(vp);
 1274         if (flags & LK_TYPE_MASK) {
 1275                 if ((error = vn_lock(vp, flags | LK_INTERLOCK, p)) != 0) {
 1276                         /*
 1277                          * must expand vrele here because we do not want
 1278                          * to call VOP_INACTIVE if the reference count
 1279                          * drops back to zero since it was never really
 1280                          * active. We must remove it from the free list
 1281                          * before sleeping so that multiple processes do
 1282                          * not try to recycle it.
 1283                          */
 1284                         simple_lock(&vp->v_interlock);
 1285                         vp->v_usecount--;
 1286                         if (VSHOULDFREE(vp))
 1287                                 vfree(vp);
 1288                         simple_unlock(&vp->v_interlock);
 1289                 }
 1290                 return (error);
 1291         }
 1292         simple_unlock(&vp->v_interlock);
 1293         return (0);
 1294 }
 1295 
 1296 void
 1297 vref(struct vnode *vp)
 1298 {
 1299         simple_lock(&vp->v_interlock);
 1300         vp->v_usecount++;
 1301         simple_unlock(&vp->v_interlock);
 1302 }
 1303 
 1304 /*
 1305  * Vnode put/release.
 1306  * If count drops to zero, call inactive routine and return to freelist.
 1307  */
 1308 void
 1309 vrele(vp)
 1310         struct vnode *vp;
 1311 {
 1312         struct proc *p = curproc;       /* XXX */
 1313 
 1314         KASSERT(vp != NULL, ("vrele: null vp"));
 1315 
 1316         simple_lock(&vp->v_interlock);
 1317 
 1318         if (vp->v_usecount > 1) {
 1319 
 1320                 vp->v_usecount--;
 1321                 simple_unlock(&vp->v_interlock);
 1322 
 1323                 return;
 1324         }
 1325 
 1326         if (vp->v_usecount == 1) {
 1327 
 1328                 vp->v_usecount--;
 1329                 if (VSHOULDFREE(vp))
 1330                         vfree(vp);
 1331         /*
 1332          * If we are doing a vput, the node is already locked, and we must
 1333          * call VOP_INACTIVE with the node locked.  So, in the case of
 1334          * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
 1335          */
 1336                 if (vn_lock(vp, LK_EXCLUSIVE | LK_INTERLOCK, p) == 0) {
 1337                         VOP_INACTIVE(vp, p);
 1338                 }
 1339 
 1340         } else {
 1341 #ifdef DIAGNOSTIC
 1342                 vprint("vrele: negative ref count", vp);
 1343                 simple_unlock(&vp->v_interlock);
 1344 #endif
 1345                 panic("vrele: negative ref cnt");
 1346         }
 1347 }
 1348 
 1349 void
 1350 vput(vp)
 1351         struct vnode *vp;
 1352 {
 1353         struct proc *p = curproc;       /* XXX */
 1354 
 1355         KASSERT(vp != NULL, ("vput: null vp"));
 1356 
 1357         simple_lock(&vp->v_interlock);
 1358 
 1359         if (vp->v_usecount > 1) {
 1360 
 1361                 vp->v_usecount--;
 1362                 VOP_UNLOCK(vp, LK_INTERLOCK, p);
 1363                 return;
 1364 
 1365         }
 1366 
 1367         if (vp->v_usecount == 1) {
 1368 
 1369                 vp->v_usecount--;
 1370                 if (VSHOULDFREE(vp))
 1371                         vfree(vp);
 1372         /*
 1373          * If we are doing a vput, the node is already locked, and we must
 1374          * call VOP_INACTIVE with the node locked.  So, in the case of
 1375          * vrele, we explicitly lock the vnode before calling VOP_INACTIVE.
 1376          */
 1377                 simple_unlock(&vp->v_interlock);
 1378                 VOP_INACTIVE(vp, p);
 1379 
 1380         } else {
 1381 #ifdef DIAGNOSTIC
 1382                 vprint("vput: negative ref count", vp);
 1383 #endif
 1384                 panic("vput: negative ref cnt");
 1385         }
 1386 }
 1387 
 1388 /*
 1389  * Somebody doesn't want the vnode recycled.
 1390  */
 1391 void
 1392 vhold(vp)
 1393         register struct vnode *vp;
 1394 {
 1395         int s;
 1396 
 1397         s = splbio();
 1398         vp->v_holdcnt++;
 1399         if (VSHOULDBUSY(vp))
 1400                 vbusy(vp);
 1401         splx(s);
 1402 }
 1403 
 1404 /*
 1405  * One less who cares about this vnode.
 1406  */
 1407 void
 1408 vdrop(vp)
 1409         register struct vnode *vp;
 1410 {
 1411         int s;
 1412 
 1413         s = splbio();
 1414         if (vp->v_holdcnt <= 0)
 1415                 panic("vdrop: holdcnt");
 1416         vp->v_holdcnt--;
 1417         if (VSHOULDFREE(vp))
 1418                 vfree(vp);
 1419         splx(s);
 1420 }
 1421 
 1422 /*
 1423  * Remove any vnodes in the vnode table belonging to mount point mp.
 1424  *
 1425  * If MNT_NOFORCE is specified, there should not be any active ones,
 1426  * return error if any are found (nb: this is a user error, not a
 1427  * system error). If MNT_FORCE is specified, detach any active vnodes
 1428  * that are found.
 1429  */
 1430 #ifdef DIAGNOSTIC
 1431 static int busyprt = 0;         /* print out busy vnodes */
 1432 SYSCTL_INT(_debug, OID_AUTO, busyprt, CTLFLAG_RW, &busyprt, 0, "");
 1433 #endif
 1434 
 1435 int
 1436 vflush(mp, skipvp, flags)
 1437         struct mount *mp;
 1438         struct vnode *skipvp;
 1439         int flags;
 1440 {
 1441         struct proc *p = curproc;       /* XXX */
 1442         struct vnode *vp, *nvp;
 1443         int busy = 0;
 1444 
 1445         simple_lock(&mntvnode_slock);
 1446 loop:
 1447         for (vp = mp->mnt_vnodelist.lh_first; vp; vp = nvp) {
 1448                 /*
 1449                  * Make sure this vnode wasn't reclaimed in getnewvnode().
 1450                  * Start over if it has (it won't be on the list anymore).
 1451                  */
 1452                 if (vp->v_mount != mp)
 1453                         goto loop;
 1454                 nvp = vp->v_mntvnodes.le_next;
 1455                 /*
 1456                  * Skip over a selected vnode.
 1457                  */
 1458                 if (vp == skipvp)
 1459                         continue;
 1460 
 1461                 simple_lock(&vp->v_interlock);
 1462                 /*
 1463                  * Skip over a vnodes marked VSYSTEM.
 1464                  */
 1465                 if ((flags & SKIPSYSTEM) && (vp->v_flag & VSYSTEM)) {
 1466                         simple_unlock(&vp->v_interlock);
 1467                         continue;
 1468                 }
 1469                 /*
 1470                  * If WRITECLOSE is set, only flush out regular file vnodes
 1471                  * open for writing.
 1472                  */
 1473                 if ((flags & WRITECLOSE) &&
 1474                     (vp->v_writecount == 0 || vp->v_type != VREG)) {
 1475                         simple_unlock(&vp->v_interlock);
 1476                         continue;
 1477                 }
 1478 
 1479                 /*
 1480                  * With v_usecount == 0, all we need to do is clear out the
 1481                  * vnode data structures and we are done.
 1482                  */
 1483                 if (vp->v_usecount == 0) {
 1484                         simple_unlock(&mntvnode_slock);
 1485                         vgonel(vp, p);
 1486                         simple_lock(&mntvnode_slock);
 1487                         continue;
 1488                 }
 1489 
 1490                 /*
 1491                  * If FORCECLOSE is set, forcibly close the vnode. For block
 1492                  * or character devices, revert to an anonymous device. For
 1493                  * all other files, just kill them.
 1494                  */
 1495                 if (flags & FORCECLOSE) {
 1496                         simple_unlock(&mntvnode_slock);
 1497                         if (vp->v_type != VBLK && vp->v_type != VCHR) {
 1498                                 vgonel(vp, p);
 1499                         } else {
 1500                                 vclean(vp, 0, p);
 1501                                 vp->v_op = spec_vnodeop_p;
 1502                                 insmntque(vp, (struct mount *) 0);
 1503                         }
 1504                         simple_lock(&mntvnode_slock);
 1505                         continue;
 1506                 }
 1507 #ifdef DIAGNOSTIC
 1508                 if (busyprt)
 1509                         vprint("vflush: busy vnode", vp);
 1510 #endif
 1511                 simple_unlock(&vp->v_interlock);
 1512                 busy++;
 1513         }
 1514         simple_unlock(&mntvnode_slock);
 1515         if (busy)
 1516                 return (EBUSY);
 1517         return (0);
 1518 }
 1519 
 1520 /*
 1521  * Disassociate the underlying file system from a vnode.
 1522  */
 1523 static void
 1524 vclean(vp, flags, p)
 1525         struct vnode *vp;
 1526         int flags;
 1527         struct proc *p;
 1528 {
 1529         int active;
 1530         vm_object_t obj;
 1531 
 1532         /*
 1533          * Check to see if the vnode is in use. If so we have to reference it
 1534          * before we clean it out so that its count cannot fall to zero and
 1535          * generate a race against ourselves to recycle it.
 1536          */
 1537         if ((active = vp->v_usecount))
 1538                 vp->v_usecount++;
 1539 
 1540         /*
 1541          * Prevent the vnode from being recycled or brought into use while we
 1542          * clean it out.
 1543          */
 1544         if (vp->v_flag & VXLOCK)
 1545                 panic("vclean: deadlock");
 1546         vp->v_flag |= VXLOCK;
 1547         /*
 1548          * Even if the count is zero, the VOP_INACTIVE routine may still
 1549          * have the object locked while it cleans it out. The VOP_LOCK
 1550          * ensures that the VOP_INACTIVE routine is done with its work.
 1551          * For active vnodes, it ensures that no other activity can
 1552          * occur while the underlying object is being cleaned out.
 1553          */
 1554         VOP_LOCK(vp, LK_DRAIN | LK_INTERLOCK, p);
 1555 
 1556         /*
 1557          * Clean out any buffers associated with the vnode.
 1558          */
 1559         vinvalbuf(vp, V_SAVE, NOCRED, p, 0, 0);
 1560         if (obj = vp->v_object) {
 1561                 if (obj->ref_count == 0) {
 1562                         /*
 1563                          * This is a normal way of shutting down the object/vnode
 1564                          * association.
 1565                          */
 1566                         vm_object_terminate(obj);
 1567                 } else {
 1568                         /*
 1569                          * Woe to the process that tries to page now :-).
 1570                          */
 1571                         vm_pager_deallocate(obj);
 1572                 }
 1573         }
 1574 
 1575         /*
 1576          * If purging an active vnode, it must be closed and
 1577          * deactivated before being reclaimed. Note that the
 1578          * VOP_INACTIVE will unlock the vnode.
 1579          */
 1580         if (active) {
 1581                 if (flags & DOCLOSE)
 1582                         VOP_CLOSE(vp, FNONBLOCK, NOCRED, p);
 1583                 VOP_INACTIVE(vp, p);
 1584         } else {
 1585                 /*
 1586                  * Any other processes trying to obtain this lock must first
 1587                  * wait for VXLOCK to clear, then call the new lock operation.
 1588                  */
 1589                 VOP_UNLOCK(vp, 0, p);
 1590         }
 1591         /*
 1592          * Reclaim the vnode.
 1593          */
 1594         if (VOP_RECLAIM(vp, p))
 1595                 panic("vclean: cannot reclaim");
 1596 
 1597         if (active)
 1598                 vrele(vp);
 1599 
 1600         cache_purge(vp);
 1601         if (vp->v_vnlock) {
 1602 #if 0 /* This is the only place we have LK_DRAINED in the entire kernel ??? */
 1603 #ifdef DIAGNOSTIC
 1604                 if ((vp->v_vnlock->lk_flags & LK_DRAINED) == 0)
 1605                         vprint("vclean: lock not drained", vp);
 1606 #endif
 1607 #endif
 1608                 FREE(vp->v_vnlock, M_VNODE);
 1609                 vp->v_vnlock = NULL;
 1610         }
 1611 
 1612         if (VSHOULDFREE(vp))
 1613                 vfree(vp);
 1614 
 1615         /*
 1616          * Done with purge, notify sleepers of the grim news.
 1617          */
 1618         vp->v_op = dead_vnodeop_p;
 1619         vn_pollgone(vp);
 1620         vp->v_tag = VT_NON;
 1621         vp->v_flag &= ~VXLOCK;
 1622         if (vp->v_flag & VXWANT) {
 1623                 vp->v_flag &= ~VXWANT;
 1624                 wakeup((caddr_t) vp);
 1625         }
 1626 }
 1627 
 1628 /*
 1629  * Eliminate all activity associated with the requested vnode
 1630  * and with all vnodes aliased to the requested vnode.
 1631  */
 1632 int
 1633 vop_revoke(ap)
 1634         struct vop_revoke_args /* {
 1635                 struct vnode *a_vp;
 1636                 int a_flags;
 1637         } */ *ap;
 1638 {
 1639         struct vnode *vp, *vq;
 1640         struct proc *p = curproc;       /* XXX */
 1641 
 1642         KASSERT((ap->a_flags & REVOKEALL) != 0, ("vop_revoke"));
 1643 
 1644         vp = ap->a_vp;
 1645         simple_lock(&vp->v_interlock);
 1646 
 1647         if (vp->v_flag & VALIASED) {
 1648                 /*
 1649                  * If a vgone (or vclean) is already in progress,
 1650                  * wait until it is done and return.
 1651                  */
 1652                 if (vp->v_flag & VXLOCK) {
 1653                         vp->v_flag |= VXWANT;
 1654                         simple_unlock(&vp->v_interlock);
 1655                         tsleep((caddr_t)vp, PINOD, "vop_revokeall", 0);
 1656                         return (0);
 1657                 }
 1658                 /*
 1659                  * Ensure that vp will not be vgone'd while we
 1660                  * are eliminating its aliases.
 1661                  */
 1662                 vp->v_flag |= VXLOCK;
 1663                 simple_unlock(&vp->v_interlock);
 1664                 while (vp->v_flag & VALIASED) {
 1665                         simple_lock(&spechash_slock);
 1666                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1667                                 if (vq->v_rdev != vp->v_rdev ||
 1668                                     vq->v_type != vp->v_type || vp == vq)
 1669                                         continue;
 1670                                 simple_unlock(&spechash_slock);
 1671                                 vgone(vq);
 1672                                 break;
 1673                         }
 1674                         if (vq == NULLVP) {
 1675                                 simple_unlock(&spechash_slock);
 1676                         }
 1677                 }
 1678                 /*
 1679                  * Remove the lock so that vgone below will
 1680                  * really eliminate the vnode after which time
 1681                  * vgone will awaken any sleepers.
 1682                  */
 1683                 simple_lock(&vp->v_interlock);
 1684                 vp->v_flag &= ~VXLOCK;
 1685                 if (vp->v_flag & VXWANT) {
 1686                         vp->v_flag &= ~VXWANT;
 1687                         wakeup(vp);
 1688                 }
 1689         }
 1690         vgonel(vp, p);
 1691         return (0);
 1692 }
 1693 
 1694 /*
 1695  * Recycle an unused vnode to the front of the free list.
 1696  * Release the passed interlock if the vnode will be recycled.
 1697  */
 1698 int
 1699 vrecycle(vp, inter_lkp, p)
 1700         struct vnode *vp;
 1701         struct simplelock *inter_lkp;
 1702         struct proc *p;
 1703 {
 1704 
 1705         simple_lock(&vp->v_interlock);
 1706         if (vp->v_usecount == 0) {
 1707                 if (inter_lkp) {
 1708                         simple_unlock(inter_lkp);
 1709                 }
 1710                 vgonel(vp, p);
 1711                 return (1);
 1712         }
 1713         simple_unlock(&vp->v_interlock);
 1714         return (0);
 1715 }
 1716 
 1717 /*
 1718  * Eliminate all activity associated with a vnode
 1719  * in preparation for reuse.
 1720  */
 1721 void
 1722 vgone(vp)
 1723         register struct vnode *vp;
 1724 {
 1725         struct proc *p = curproc;       /* XXX */
 1726 
 1727         simple_lock(&vp->v_interlock);
 1728         vgonel(vp, p);
 1729 }
 1730 
 1731 /*
 1732  * vgone, with the vp interlock held.
 1733  */
 1734 static void
 1735 vgonel(vp, p)
 1736         struct vnode *vp;
 1737         struct proc *p;
 1738 {
 1739         int s;
 1740         struct vnode *vq;
 1741         struct vnode *vx;
 1742 
 1743         /*
 1744          * If a vgone (or vclean) is already in progress,
 1745          * wait until it is done and return.
 1746          */
 1747         if (vp->v_flag & VXLOCK) {
 1748                 vp->v_flag |= VXWANT;
 1749                 simple_unlock(&vp->v_interlock);
 1750                 tsleep((caddr_t)vp, PINOD, "vgone", 0);
 1751                 return;
 1752         }
 1753 
 1754         /*
 1755          * Clean out the filesystem specific data.
 1756          */
 1757         vclean(vp, DOCLOSE, p);
 1758         simple_lock(&vp->v_interlock);
 1759 
 1760         /*
 1761          * Delete from old mount point vnode list, if on one.
 1762          */
 1763         if (vp->v_mount != NULL)
 1764                 insmntque(vp, (struct mount *)0);
 1765         /*
 1766          * If special device, remove it from special device alias list
 1767          * if it is on one.
 1768          */
 1769         if ((vp->v_type == VBLK || vp->v_type == VCHR) && vp->v_specinfo != 0) {
 1770                 simple_lock(&spechash_slock);
 1771                 if (*vp->v_hashchain == vp) {
 1772                         *vp->v_hashchain = vp->v_specnext;
 1773                 } else {
 1774                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1775                                 if (vq->v_specnext != vp)
 1776                                         continue;
 1777                                 vq->v_specnext = vp->v_specnext;
 1778                                 break;
 1779                         }
 1780                         if (vq == NULL)
 1781                                 panic("missing bdev");
 1782                 }
 1783                 if (vp->v_flag & VALIASED) {
 1784                         vx = NULL;
 1785                         for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 1786                                 if (vq->v_rdev != vp->v_rdev ||
 1787                                     vq->v_type != vp->v_type)
 1788                                         continue;
 1789                                 if (vx)
 1790                                         break;
 1791                                 vx = vq;
 1792                         }
 1793                         if (vx == NULL)
 1794                                 panic("missing alias");
 1795                         if (vq == NULL)
 1796                                 vx->v_flag &= ~VALIASED;
 1797                         vp->v_flag &= ~VALIASED;
 1798                 }
 1799                 simple_unlock(&spechash_slock);
 1800                 FREE(vp->v_specinfo, M_VNODE);
 1801                 vp->v_specinfo = NULL;
 1802         }
 1803 
 1804         /*
 1805          * If it is on the freelist and not already at the head,
 1806          * move it to the head of the list. The test of the back
 1807          * pointer and the reference count of zero is because
 1808          * it will be removed from the free list by getnewvnode,
 1809          * but will not have its reference count incremented until
 1810          * after calling vgone. If the reference count were
 1811          * incremented first, vgone would (incorrectly) try to
 1812          * close the previous instance of the underlying object.
 1813          */
 1814         if (vp->v_usecount == 0 && !(vp->v_flag & VDOOMED)) {
 1815                 s = splbio();
 1816                 simple_lock(&vnode_free_list_slock);
 1817                 if (vp->v_flag & VFREE) {
 1818                         TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
 1819                 } else if (vp->v_flag & VTBFREE) {
 1820                         TAILQ_REMOVE(&vnode_tobefree_list, vp, v_freelist);
 1821                         vp->v_flag &= ~VTBFREE;
 1822                         freevnodes++;
 1823                 } else
 1824                         freevnodes++;
 1825                 vp->v_flag |= VFREE;
 1826                 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
 1827                 simple_unlock(&vnode_free_list_slock);
 1828                 splx(s);
 1829         }
 1830 
 1831         vp->v_type = VBAD;
 1832         simple_unlock(&vp->v_interlock);
 1833 }
 1834 
 1835 /*
 1836  * Lookup a vnode by device number.
 1837  */
 1838 int
 1839 vfinddev(dev, type, vpp)
 1840         dev_t dev;
 1841         enum vtype type;
 1842         struct vnode **vpp;
 1843 {
 1844         register struct vnode *vp;
 1845         int rc = 0;
 1846 
 1847         simple_lock(&spechash_slock);
 1848         for (vp = speclisth[SPECHASH(dev)]; vp; vp = vp->v_specnext) {
 1849                 if (dev != vp->v_rdev || type != vp->v_type)
 1850                         continue;
 1851                 *vpp = vp;
 1852                 rc = 1;
 1853                 break;
 1854         }
 1855         simple_unlock(&spechash_slock);
 1856         return (rc);
 1857 }
 1858 
 1859 /*
 1860  * Calculate the total number of references to a special device.
 1861  */
 1862 int
 1863 vcount(vp)
 1864         register struct vnode *vp;
 1865 {
 1866         struct vnode *vq, *vnext;
 1867         int count;
 1868 
 1869 loop:
 1870         if ((vp->v_flag & VALIASED) == 0)
 1871                 return (vp->v_usecount);
 1872         simple_lock(&spechash_slock);
 1873         for (count = 0, vq = *vp->v_hashchain; vq; vq = vnext) {
 1874                 vnext = vq->v_specnext;
 1875                 if (vq->v_rdev != vp->v_rdev || vq->v_type != vp->v_type)
 1876                         continue;
 1877                 /*
 1878                  * Alias, but not in use, so flush it out.
 1879                  */
 1880                 if (vq->v_usecount == 0 && vq != vp) {
 1881                         simple_unlock(&spechash_slock);
 1882                         vgone(vq);
 1883                         goto loop;
 1884                 }
 1885                 count += vq->v_usecount;
 1886         }
 1887         simple_unlock(&spechash_slock);
 1888         return (count);
 1889 }
 1890 /*
 1891  * Print out a description of a vnode.
 1892  */
 1893 static char *typename[] =
 1894 {"VNON", "VREG", "VDIR", "VBLK", "VCHR", "VLNK", "VSOCK", "VFIFO", "VBAD"};
 1895 
 1896 void
 1897 vprint(label, vp)
 1898         char *label;
 1899         register struct vnode *vp;
 1900 {
 1901         char buf[96];
 1902 
 1903         if (label != NULL)
 1904                 printf("%s: %p: ", label, (void *)vp);
 1905         else
 1906                 printf("%p: ", (void *)vp);
 1907         printf("type %s, usecount %d, writecount %d, refcount %d,",
 1908             typename[vp->v_type], vp->v_usecount, vp->v_writecount,
 1909             vp->v_holdcnt);
 1910         buf[0] = '\0';
 1911         if (vp->v_flag & VROOT)
 1912                 strcat(buf, "|VROOT");
 1913         if (vp->v_flag & VTEXT)
 1914                 strcat(buf, "|VTEXT");
 1915         if (vp->v_flag & VSYSTEM)
 1916                 strcat(buf, "|VSYSTEM");
 1917         if (vp->v_flag & VXLOCK)
 1918                 strcat(buf, "|VXLOCK");
 1919         if (vp->v_flag & VXWANT)
 1920                 strcat(buf, "|VXWANT");
 1921         if (vp->v_flag & VBWAIT)
 1922                 strcat(buf, "|VBWAIT");
 1923         if (vp->v_flag & VALIASED)
 1924                 strcat(buf, "|VALIASED");
 1925         if (vp->v_flag & VDOOMED)
 1926                 strcat(buf, "|VDOOMED");
 1927         if (vp->v_flag & VFREE)
 1928                 strcat(buf, "|VFREE");
 1929         if (vp->v_flag & VOBJBUF)
 1930                 strcat(buf, "|VOBJBUF");
 1931         if (buf[0] != '\0')
 1932                 printf(" flags (%s)", &buf[1]);
 1933         if (vp->v_data == NULL) {
 1934                 printf("\n");
 1935         } else {
 1936                 printf("\n\t");
 1937                 VOP_PRINT(vp);
 1938         }
 1939 }
 1940 
 1941 #ifdef DDB
 1942 #include <ddb/ddb.h>
 1943 /*
 1944  * List all of the locked vnodes in the system.
 1945  * Called when debugging the kernel.
 1946  */
 1947 DB_SHOW_COMMAND(lockedvnodes, lockedvnodes)
 1948 {
 1949         struct proc *p = curproc;       /* XXX */
 1950         struct mount *mp, *nmp;
 1951         struct vnode *vp;
 1952 
 1953         printf("Locked vnodes\n");
 1954         simple_lock(&mountlist_slock);
 1955         for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
 1956                 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
 1957                         nmp = mp->mnt_list.cqe_next;
 1958                         continue;
 1959                 }
 1960                 for (vp = mp->mnt_vnodelist.lh_first;
 1961                      vp != NULL;
 1962                      vp = vp->v_mntvnodes.le_next) {
 1963                         if (VOP_ISLOCKED(vp))
 1964                                 vprint((char *)0, vp);
 1965                 }
 1966                 simple_lock(&mountlist_slock);
 1967                 nmp = mp->mnt_list.cqe_next;
 1968                 vfs_unbusy(mp, p);
 1969         }
 1970         simple_unlock(&mountlist_slock);
 1971 }
 1972 #endif
 1973 
 1974 /*
 1975  * Top level filesystem related information gathering.
 1976  */
 1977 static int      sysctl_ovfs_conf __P(SYSCTL_HANDLER_ARGS);
 1978 
 1979 static int
 1980 vfs_sysctl SYSCTL_HANDLER_ARGS
 1981 {
 1982         int *name = (int *)arg1 - 1;    /* XXX */
 1983         u_int namelen = arg2 + 1;       /* XXX */
 1984         struct vfsconf *vfsp;
 1985 
 1986 #if 1 || defined(COMPAT_PRELITE2)
 1987         /* Resolve ambiguity between VFS_VFSCONF and VFS_GENERIC. */
 1988         if (namelen == 1)
 1989                 return (sysctl_ovfs_conf(oidp, arg1, arg2, req));
 1990 #endif
 1991 
 1992 #ifdef notyet
 1993         /* all sysctl names at this level are at least name and field */
 1994         if (namelen < 2)
 1995                 return (ENOTDIR);               /* overloaded */
 1996         if (name[0] != VFS_GENERIC) {
 1997                 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
 1998                         if (vfsp->vfc_typenum == name[0])
 1999                                 break;
 2000                 if (vfsp == NULL)
 2001                         return (EOPNOTSUPP);
 2002                 return ((*vfsp->vfc_vfsops->vfs_sysctl)(&name[1], namelen - 1,
 2003                     oldp, oldlenp, newp, newlen, p));
 2004         }
 2005 #endif
 2006         switch (name[1]) {
 2007         case VFS_MAXTYPENUM:
 2008                 if (namelen != 2)
 2009                         return (ENOTDIR);
 2010                 return (SYSCTL_OUT(req, &maxvfsconf, sizeof(int)));
 2011         case VFS_CONF:
 2012                 if (namelen != 3)
 2013                         return (ENOTDIR);       /* overloaded */
 2014                 for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next)
 2015                         if (vfsp->vfc_typenum == name[2])
 2016                                 break;
 2017                 if (vfsp == NULL)
 2018                         return (EOPNOTSUPP);
 2019                 return (SYSCTL_OUT(req, vfsp, sizeof *vfsp));
 2020         }
 2021         return (EOPNOTSUPP);
 2022 }
 2023 
 2024 SYSCTL_NODE(_vfs, VFS_GENERIC, generic, CTLFLAG_RD, vfs_sysctl,
 2025         "Generic filesystem");
 2026 
 2027 #if 1 || defined(COMPAT_PRELITE2)
 2028 
 2029 static int
 2030 sysctl_ovfs_conf SYSCTL_HANDLER_ARGS
 2031 {
 2032         int error;
 2033         struct vfsconf *vfsp;
 2034         struct ovfsconf ovfs;
 2035 
 2036         for (vfsp = vfsconf; vfsp; vfsp = vfsp->vfc_next) {
 2037                 ovfs.vfc_vfsops = vfsp->vfc_vfsops;     /* XXX used as flag */
 2038                 strcpy(ovfs.vfc_name, vfsp->vfc_name);
 2039                 ovfs.vfc_index = vfsp->vfc_typenum;
 2040                 ovfs.vfc_refcount = vfsp->vfc_refcount;
 2041                 ovfs.vfc_flags = vfsp->vfc_flags;
 2042                 error = SYSCTL_OUT(req, &ovfs, sizeof ovfs);
 2043                 if (error)
 2044                         return error;
 2045         }
 2046         return 0;
 2047 }
 2048 
 2049 #endif /* 1 || COMPAT_PRELITE2 */
 2050 
 2051 #if 0
 2052 #define KINFO_VNODESLOP 10
 2053 /*
 2054  * Dump vnode list (via sysctl).
 2055  * Copyout address of vnode followed by vnode.
 2056  */
 2057 /* ARGSUSED */
 2058 static int
 2059 sysctl_vnode SYSCTL_HANDLER_ARGS
 2060 {
 2061         struct proc *p = curproc;       /* XXX */
 2062         struct mount *mp, *nmp;
 2063         struct vnode *nvp, *vp;
 2064         int error;
 2065 
 2066 #define VPTRSZ  sizeof (struct vnode *)
 2067 #define VNODESZ sizeof (struct vnode)
 2068 
 2069         req->lock = 0;
 2070         if (!req->oldptr) /* Make an estimate */
 2071                 return (SYSCTL_OUT(req, 0,
 2072                         (numvnodes + KINFO_VNODESLOP) * (VPTRSZ + VNODESZ)));
 2073 
 2074         simple_lock(&mountlist_slock);
 2075         for (mp = mountlist.cqh_first; mp != (void *)&mountlist; mp = nmp) {
 2076                 if (vfs_busy(mp, LK_NOWAIT, &mountlist_slock, p)) {
 2077                         nmp = mp->mnt_list.cqe_next;
 2078                         continue;
 2079                 }
 2080 again:
 2081                 simple_lock(&mntvnode_slock);
 2082                 for (vp = mp->mnt_vnodelist.lh_first;
 2083                      vp != NULL;
 2084                      vp = nvp) {
 2085                         /*
 2086                          * Check that the vp is still associated with
 2087                          * this filesystem.  RACE: could have been
 2088                          * recycled onto the same filesystem.
 2089                          */
 2090                         if (vp->v_mount != mp) {
 2091                                 simple_unlock(&mntvnode_slock);
 2092                                 goto again;
 2093                         }
 2094                         nvp = vp->v_mntvnodes.le_next;
 2095                         simple_unlock(&mntvnode_slock);
 2096                         if ((error = SYSCTL_OUT(req, &vp, VPTRSZ)) ||
 2097                             (error = SYSCTL_OUT(req, vp, VNODESZ)))
 2098                                 return (error);
 2099                         simple_lock(&mntvnode_slock);
 2100                 }
 2101                 simple_unlock(&mntvnode_slock);
 2102                 simple_lock(&mountlist_slock);
 2103                 nmp = mp->mnt_list.cqe_next;
 2104                 vfs_unbusy(mp, p);
 2105         }
 2106         simple_unlock(&mountlist_slock);
 2107 
 2108         return (0);
 2109 }
 2110 #endif
 2111 
 2112 /*
 2113  * XXX
 2114  * Exporting the vnode list on large systems causes them to crash.
 2115  * Exporting the vnode list on medium systems causes sysctl to coredump.
 2116  */
 2117 #if 0
 2118 SYSCTL_PROC(_kern, KERN_VNODE, vnode, CTLTYPE_OPAQUE|CTLFLAG_RD,
 2119         0, 0, sysctl_vnode, "S,vnode", "");
 2120 #endif
 2121 
 2122 /*
 2123  * Check to see if a filesystem is mounted on a block device.
 2124  */
 2125 int
 2126 vfs_mountedon(vp)
 2127         struct vnode *vp;
 2128 {
 2129         struct vnode *vq;
 2130         int error = 0;
 2131 
 2132         if (vp->v_specmountpoint != NULL)
 2133                 return (EBUSY);
 2134         if (vp->v_flag & VALIASED) {
 2135                 simple_lock(&spechash_slock);
 2136                 for (vq = *vp->v_hashchain; vq; vq = vq->v_specnext) {
 2137                         if (vq->v_rdev != vp->v_rdev ||
 2138                             vq->v_type != vp->v_type)
 2139                                 continue;
 2140                         if (vq->v_specmountpoint != NULL) {
 2141                                 error = EBUSY;
 2142                                 break;
 2143                         }
 2144                 }
 2145                 simple_unlock(&spechash_slock);
 2146         }
 2147         return (error);
 2148 }
 2149 
 2150 /*
 2151  * Unmount all filesystems. The list is traversed in reverse order
 2152  * of mounting to avoid dependencies.
 2153  */
 2154 void
 2155 vfs_unmountall()
 2156 {
 2157         struct mount *mp, *nmp;
 2158         struct proc *p;
 2159         int error;
 2160 
 2161         if (curproc != NULL)
 2162                 p = curproc;
 2163         else
 2164                 p = initproc;   /* XXX XXX should this be proc0? */
 2165         /*
 2166          * Since this only runs when rebooting, it is not interlocked.
 2167          */
 2168         for (mp = mountlist.cqh_last; mp != (void *)&mountlist; mp = nmp) {
 2169                 nmp = mp->mnt_list.cqe_prev;
 2170                 error = dounmount(mp, MNT_FORCE, p);
 2171                 if (error) {
 2172                         printf("unmount of %s failed (",
 2173                             mp->mnt_stat.f_mntonname);
 2174                         if (error == EBUSY)
 2175                                 printf("BUSY)\n");
 2176                         else
 2177                                 printf("%d)\n", error);
 2178                 }
 2179         }
 2180 }
 2181 
 2182 /*
 2183  * Build hash lists of net addresses and hang them off the mount point.
 2184  * Called by ufs_mount() to set up the lists of export addresses.
 2185  */
 2186 static int
 2187 vfs_hang_addrlist(mp, nep, argp)
 2188         struct mount *mp;
 2189         struct netexport *nep;
 2190         struct export_args *argp;
 2191 {
 2192         register struct netcred *np;
 2193         register struct radix_node_head *rnh;
 2194         register int i;
 2195         struct radix_node *rn;
 2196         struct sockaddr *saddr, *smask = 0;
 2197         struct domain *dom;
 2198         int error;
 2199 
 2200         if (argp->ex_addrlen == 0) {
 2201                 if (mp->mnt_flag & MNT_DEFEXPORTED)
 2202                         return (EPERM);
 2203                 np = &nep->ne_defexported;
 2204                 np->netc_exflags = argp->ex_flags;
 2205                 np->netc_anon = argp->ex_anon;
 2206                 np->netc_anon.cr_ref = 1;
 2207                 mp->mnt_flag |= MNT_DEFEXPORTED;
 2208                 return (0);
 2209         }
 2210         i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
 2211         np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK);
 2212         bzero((caddr_t) np, i);
 2213         saddr = (struct sockaddr *) (np + 1);
 2214         if ((error = copyin(argp->ex_addr, (caddr_t) saddr, argp->ex_addrlen)))
 2215                 goto out;
 2216         if (saddr->sa_len > argp->ex_addrlen)
 2217                 saddr->sa_len = argp->ex_addrlen;
 2218         if (argp->ex_masklen) {
 2219                 smask = (struct sockaddr *) ((caddr_t) saddr + argp->ex_addrlen);
 2220                 error = copyin(argp->ex_mask, (caddr_t) smask, argp->ex_masklen);
 2221                 if (error)
 2222                         goto out;
 2223                 if (smask->sa_len > argp->ex_masklen)
 2224                         smask->sa_len = argp->ex_masklen;
 2225         }
 2226         i = saddr->sa_family;
 2227         if ((rnh = nep->ne_rtable[i]) == 0) {
 2228                 /*
 2229                  * Seems silly to initialize every AF when most are not used,
 2230                  * do so on demand here
 2231                  */
 2232                 for (dom = domains; dom; dom = dom->dom_next)
 2233                         if (dom->dom_family == i && dom->dom_rtattach) {
 2234                                 dom->dom_rtattach((void **) &nep->ne_rtable[i],
 2235                                     dom->dom_rtoffset);
 2236                                 break;
 2237                         }
 2238                 if ((rnh = nep->ne_rtable[i]) == 0) {
 2239                         error = ENOBUFS;
 2240                         goto out;
 2241                 }
 2242         }
 2243         rn = (*rnh->rnh_addaddr) ((caddr_t) saddr, (caddr_t) smask, rnh,
 2244             np->netc_rnodes);
 2245         if (rn == 0 || np != (struct netcred *) rn) {   /* already exists */
 2246                 error = EPERM;
 2247                 goto out;
 2248         }
 2249         np->netc_exflags = argp->ex_flags;
 2250         np->netc_anon = argp->ex_anon;
 2251         np->netc_anon.cr_ref = 1;
 2252         return (0);
 2253 out:
 2254         free(np, M_NETADDR);
 2255         return (error);
 2256 }
 2257 
 2258 /* ARGSUSED */
 2259 static int
 2260 vfs_free_netcred(rn, w)
 2261         struct radix_node *rn;
 2262         void *w;
 2263 {
 2264         register struct radix_node_head *rnh = (struct radix_node_head *) w;
 2265 
 2266         (*rnh->rnh_deladdr) (rn->rn_key, rn->rn_mask, rnh);
 2267         free((caddr_t) rn, M_NETADDR);
 2268         return (0);
 2269 }
 2270 
 2271 /*
 2272  * Free the net address hash lists that are hanging off the mount points.
 2273  */
 2274 static void
 2275 vfs_free_addrlist(nep)
 2276         struct netexport *nep;
 2277 {
 2278         register int i;
 2279         register struct radix_node_head *rnh;
 2280 
 2281         for (i = 0; i <= AF_MAX; i++)
 2282                 if ((rnh = nep->ne_rtable[i])) {
 2283                         (*rnh->rnh_walktree) (rnh, vfs_free_netcred,
 2284                             (caddr_t) rnh);
 2285                         free((caddr_t) rnh, M_RTABLE);
 2286                         nep->ne_rtable[i] = 0;
 2287                 }
 2288 }
 2289 
 2290 int
 2291 vfs_export(mp, nep, argp)
 2292         struct mount *mp;
 2293         struct netexport *nep;
 2294         struct export_args *argp;
 2295 {
 2296         int error;
 2297 
 2298         if (argp->ex_flags & MNT_DELEXPORT) {
 2299                 if (mp->mnt_flag & MNT_EXPUBLIC) {
 2300                         vfs_setpublicfs(NULL, NULL, NULL);
 2301                         mp->mnt_flag &= ~MNT_EXPUBLIC;
 2302                 }
 2303                 vfs_free_addrlist(nep);
 2304                 mp->mnt_flag &= ~(MNT_EXPORTED | MNT_DEFEXPORTED);
 2305         }
 2306         if (argp->ex_flags & MNT_EXPORTED) {
 2307                 if (argp->ex_flags & MNT_EXPUBLIC) {
 2308                         if ((error = vfs_setpublicfs(mp, nep, argp)) != 0)
 2309                                 return (error);
 2310                         mp->mnt_flag |= MNT_EXPUBLIC;
 2311                 }
 2312                 if ((error = vfs_hang_addrlist(mp, nep, argp)))
 2313                         return (error);
 2314                 mp->mnt_flag |= MNT_EXPORTED;
 2315         }
 2316         return (0);
 2317 }
 2318 
 2319 
 2320 /*
 2321  * Set the publicly exported filesystem (WebNFS). Currently, only
 2322  * one public filesystem is possible in the spec (RFC 2054 and 2055)
 2323  */
 2324 int
 2325 vfs_setpublicfs(mp, nep, argp)
 2326         struct mount *mp;
 2327         struct netexport *nep;
 2328         struct export_args *argp;
 2329 {
 2330         int error;
 2331         struct vnode *rvp;
 2332         char *cp;
 2333 
 2334         /*
 2335          * mp == NULL -> invalidate the current info, the FS is
 2336          * no longer exported. May be called from either vfs_export
 2337          * or unmount, so check if it hasn't already been done.
 2338          */
 2339         if (mp == NULL) {
 2340                 if (nfs_pub.np_valid) {
 2341                         nfs_pub.np_valid = 0;
 2342                         if (nfs_pub.np_index != NULL) {
 2343                                 FREE(nfs_pub.np_index, M_TEMP);
 2344                                 nfs_pub.np_index = NULL;
 2345                         }
 2346                 }
 2347                 return (0);
 2348         }
 2349 
 2350         /*
 2351          * Only one allowed at a time.
 2352          */
 2353         if (nfs_pub.np_valid != 0 && mp != nfs_pub.np_mount)
 2354                 return (EBUSY);
 2355 
 2356         /*
 2357          * Get real filehandle for root of exported FS.
 2358          */
 2359         bzero((caddr_t)&nfs_pub.np_handle, sizeof(nfs_pub.np_handle));
 2360         nfs_pub.np_handle.fh_fsid = mp->mnt_stat.f_fsid;
 2361 
 2362         if ((error = VFS_ROOT(mp, &rvp)))
 2363                 return (error);
 2364 
 2365         if ((error = VFS_VPTOFH(rvp, &nfs_pub.np_handle.fh_fid)))
 2366                 return (error);
 2367 
 2368         vput(rvp);
 2369 
 2370         /*
 2371          * If an indexfile was specified, pull it in.
 2372          */
 2373         if (argp->ex_indexfile != NULL) {
 2374                 MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP,
 2375                     M_WAITOK);
 2376                 error = copyinstr(argp->ex_indexfile, nfs_pub.np_index,
 2377                     MAXNAMLEN, (size_t *)0);
 2378                 if (!error) {
 2379                         /*
 2380                          * Check for illegal filenames.
 2381                          */
 2382                         for (cp = nfs_pub.np_index; *cp; cp++) {
 2383                                 if (*cp == '/') {
 2384                                         error = EINVAL;
 2385                                         break;
 2386                                 }
 2387                         }
 2388                 }
 2389                 if (error) {
 2390                         FREE(nfs_pub.np_index, M_TEMP);
 2391                         return (error);
 2392                 }
 2393         }
 2394 
 2395         nfs_pub.np_mount = mp;
 2396         nfs_pub.np_valid = 1;
 2397         return (0);
 2398 }
 2399 
 2400 struct netcred *
 2401 vfs_export_lookup(mp, nep, nam)
 2402         register struct mount *mp;
 2403         struct netexport *nep;
 2404         struct sockaddr *nam;
 2405 {
 2406         register struct netcred *np;
 2407         register struct radix_node_head *rnh;
 2408         struct sockaddr *saddr;
 2409 
 2410         np = NULL;
 2411         if (mp->mnt_flag & MNT_EXPORTED) {
 2412                 /*
 2413                  * Lookup in the export list first.
 2414                  */
 2415                 if (nam != NULL) {
 2416                         saddr = nam;
 2417                         rnh = nep->ne_rtable[saddr->sa_family];
 2418                         if (rnh != NULL) {
 2419                                 np = (struct netcred *)
 2420                                         (*rnh->rnh_matchaddr)((caddr_t)saddr,
 2421                                                               rnh);
 2422                                 if (np && np->netc_rnodes->rn_flags & RNF_ROOT)
 2423                                         np = NULL;
 2424                         }
 2425                 }
 2426                 /*
 2427                  * If no address match, use the default if it exists.
 2428                  */
 2429                 if (np == NULL && mp->mnt_flag & MNT_DEFEXPORTED)
 2430                         np = &nep->ne_defexported;
 2431         }
 2432         return (np);
 2433 }
 2434 
 2435 /*
 2436  * perform msync on all vnodes under a mount point
 2437  * the mount point must be locked.
 2438  */
 2439 void
 2440 vfs_msync(struct mount *mp, int flags) {
 2441         struct vnode *vp, *nvp;
 2442         struct vm_object *obj;
 2443         int anyio, tries;
 2444 
 2445         tries = 5;
 2446 loop:
 2447         anyio = 0;
 2448         for (vp = mp->mnt_vnodelist.lh_first; vp != NULL; vp = nvp) {
 2449 
 2450                 nvp = vp->v_mntvnodes.le_next;
 2451 
 2452                 if (vp->v_mount != mp) {
 2453                         goto loop;
 2454                 }
 2455 
 2456                 if (vp->v_flag & VXLOCK)        /* XXX: what if MNT_WAIT? */
 2457                         continue;
 2458 
 2459                 if (flags != MNT_WAIT) {
 2460                         obj = vp->v_object;
 2461                         if (obj == NULL || (obj->flags & OBJ_MIGHTBEDIRTY) == 0)
 2462                                 continue;
 2463                         if (VOP_ISLOCKED(vp))
 2464                                 continue;
 2465                 }
 2466 
 2467                 simple_lock(&vp->v_interlock);
 2468                 if (vp->v_object &&
 2469                    (vp->v_object->flags & OBJ_MIGHTBEDIRTY)) {
 2470                         if (!vget(vp,
 2471                                 LK_INTERLOCK | LK_EXCLUSIVE | LK_RETRY | LK_NOOBJ, curproc)) {
 2472                                 if (vp->v_object) {
 2473                                         vm_object_page_clean(vp->v_object, 0, 0, flags == MNT_WAIT ? OBJPC_SYNC : 0);
 2474                                         anyio = 1;
 2475                                 }
 2476                                 vput(vp);
 2477                         }
 2478                 } else {
 2479                         simple_unlock(&vp->v_interlock);
 2480                 }
 2481         }
 2482         if (anyio && (--tries > 0))
 2483                 goto loop;
 2484 }
 2485 
 2486 /*
 2487  * Create the VM object needed for VMIO and mmap support.  This
 2488  * is done for all VREG files in the system.  Some filesystems might
 2489  * afford the additional metadata buffering capability of the
 2490  * VMIO code by making the device node be VMIO mode also.
 2491  *
 2492  * vp must be locked when vfs_object_create is called.
 2493  */
 2494 int
 2495 vfs_object_create(vp, p, cred)
 2496         struct vnode *vp;
 2497         struct proc *p;
 2498         struct ucred *cred;
 2499 {
 2500         struct vattr vat;
 2501         vm_object_t object;
 2502         int error = 0;
 2503 
 2504         if ((vp->v_type != VREG) && (vp->v_type != VBLK))
 2505                 return 0;
 2506 
 2507 retry:
 2508         if ((object = vp->v_object) == NULL) {
 2509                 if (vp->v_type == VREG) {
 2510                         if ((error = VOP_GETATTR(vp, &vat, cred, p)) != 0)
 2511                                 goto retn;
 2512                         object = vnode_pager_alloc(vp, vat.va_size, 0, 0);
 2513                 } else if (major(vp->v_rdev) < nblkdev &&
 2514                     bdevsw[major(vp->v_rdev)] != NULL) {
 2515                         /*
 2516                          * This simply allocates the biggest object possible
 2517                          * for a VBLK vnode.  This should be fixed, but doesn't
 2518                          * cause any problems (yet).
 2519                          */
 2520                         object = vnode_pager_alloc(vp, IDX_TO_OFF(INT_MAX), 0, 0);
 2521                 }
 2522                 object->ref_count--;
 2523                 vp->v_usecount--;
 2524         } else {
 2525                 if (object->flags & OBJ_DEAD) {
 2526                         VOP_UNLOCK(vp, 0, p);
 2527                         tsleep(object, PVM, "vodead", 0);
 2528                         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
 2529                         goto retry;
 2530                 }
 2531         }
 2532 
 2533         if (vp->v_object)
 2534                 vp->v_flag |= VOBJBUF;
 2535 
 2536 retn:
 2537         return error;
 2538 }
 2539 
 2540 static void
 2541 vfree(vp)
 2542         struct vnode *vp;
 2543 {
 2544         int s;
 2545 
 2546         s = splbio();
 2547         simple_lock(&vnode_free_list_slock);
 2548         if (vp->v_flag & VTBFREE) {
 2549                 TAILQ_REMOVE(&vnode_tobefree_list, vp, v_freelist);
 2550                 vp->v_flag &= ~VTBFREE;
 2551         }
 2552         if (vp->v_flag & VAGE) {
 2553                 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
 2554         } else {
 2555                 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
 2556         }
 2557         freevnodes++;
 2558         simple_unlock(&vnode_free_list_slock);
 2559         vp->v_flag &= ~VAGE;
 2560         vp->v_flag |= VFREE;
 2561         splx(s);
 2562 }
 2563 
 2564 void
 2565 vbusy(vp)
 2566         struct vnode *vp;
 2567 {
 2568         int s;
 2569 
 2570         s = splbio();
 2571         simple_lock(&vnode_free_list_slock);
 2572         if (vp->v_flag & VTBFREE) {
 2573                 TAILQ_REMOVE(&vnode_tobefree_list, vp, v_freelist);
 2574                 vp->v_flag &= ~VTBFREE;
 2575         } else {
 2576                 TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
 2577                 freevnodes--;
 2578         }
 2579         simple_unlock(&vnode_free_list_slock);
 2580         vp->v_flag &= ~(VFREE|VAGE);
 2581         splx(s);
 2582 }
 2583 
 2584 /*
 2585  * Record a process's interest in events which might happen to
 2586  * a vnode.  Because poll uses the historic select-style interface
 2587  * internally, this routine serves as both the ``check for any
 2588  * pending events'' and the ``record my interest in future events''
 2589  * functions.  (These are done together, while the lock is held,
 2590  * to avoid race conditions.)
 2591  */
 2592 int
 2593 vn_pollrecord(vp, p, events)
 2594         struct vnode *vp;
 2595         struct proc *p;
 2596         short events;
 2597 {
 2598         simple_lock(&vp->v_pollinfo.vpi_lock);
 2599         if (vp->v_pollinfo.vpi_revents & events) {
 2600                 /*
 2601                  * This leaves events we are not interested
 2602                  * in available for the other process which
 2603                  * which presumably had requested them
 2604                  * (otherwise they would never have been
 2605                  * recorded).
 2606                  */
 2607                 events &= vp->v_pollinfo.vpi_revents;
 2608                 vp->v_pollinfo.vpi_revents &= ~events;
 2609 
 2610                 simple_unlock(&vp->v_pollinfo.vpi_lock);
 2611                 return events;
 2612         }
 2613         vp->v_pollinfo.vpi_events |= events;
 2614         selrecord(p, &vp->v_pollinfo.vpi_selinfo);
 2615         simple_unlock(&vp->v_pollinfo.vpi_lock);
 2616         return 0;
 2617 }
 2618 
 2619 /*
 2620  * Note the occurrence of an event.  If the VN_POLLEVENT macro is used,
 2621  * it is possible for us to miss an event due to race conditions, but
 2622  * that condition is expected to be rare, so for the moment it is the
 2623  * preferred interface.
 2624  */
 2625 void
 2626 vn_pollevent(vp, events)
 2627         struct vnode *vp;
 2628         short events;
 2629 {
 2630         simple_lock(&vp->v_pollinfo.vpi_lock);
 2631         if (vp->v_pollinfo.vpi_events & events) {
 2632                 /*
 2633                  * We clear vpi_events so that we don't
 2634                  * call selwakeup() twice if two events are
 2635                  * posted before the polling process(es) is
 2636                  * awakened.  This also ensures that we take at
 2637                  * most one selwakeup() if the polling process
 2638                  * is no longer interested.  However, it does
 2639                  * mean that only one event can be noticed at
 2640                  * a time.  (Perhaps we should only clear those
 2641                  * event bits which we note?) XXX
 2642                  */
 2643                 vp->v_pollinfo.vpi_events = 0;  /* &= ~events ??? */
 2644                 vp->v_pollinfo.vpi_revents |= events;
 2645                 selwakeup(&vp->v_pollinfo.vpi_selinfo);
 2646         }
 2647         simple_unlock(&vp->v_pollinfo.vpi_lock);
 2648 }
 2649 
 2650 /*
 2651  * Wake up anyone polling on vp because it is being revoked.
 2652  * This depends on dead_poll() returning POLLHUP for correct
 2653  * behavior.
 2654  */
 2655 void
 2656 vn_pollgone(vp)
 2657         struct vnode *vp;
 2658 {
 2659         simple_lock(&vp->v_pollinfo.vpi_lock);
 2660         if (vp->v_pollinfo.vpi_events) {
 2661                 vp->v_pollinfo.vpi_events = 0;
 2662                 selwakeup(&vp->v_pollinfo.vpi_selinfo);
 2663         }
 2664         simple_unlock(&vp->v_pollinfo.vpi_lock);
 2665 }
 2666 
 2667 
 2668 
 2669 /*
 2670  * Routine to create and manage a filesystem syncer vnode.
 2671  */
 2672 #define sync_close ((int (*) __P((struct  vop_close_args *)))nullop)
 2673 static int      sync_fsync __P((struct  vop_fsync_args *));
 2674 static int      sync_inactive __P((struct  vop_inactive_args *));
 2675 static int      sync_reclaim  __P((struct  vop_reclaim_args *));
 2676 #define sync_lock ((int (*) __P((struct  vop_lock_args *)))vop_nolock)
 2677 #define sync_unlock ((int (*) __P((struct  vop_unlock_args *)))vop_nounlock)
 2678 static int      sync_print __P((struct vop_print_args *));
 2679 #define sync_islocked ((int(*) __P((struct vop_islocked_args *)))vop_noislocked)
 2680 
 2681 static vop_t **sync_vnodeop_p;
 2682 static struct vnodeopv_entry_desc sync_vnodeop_entries[] = {
 2683         { &vop_default_desc,    (vop_t *) vop_eopnotsupp },
 2684         { &vop_close_desc,      (vop_t *) sync_close },         /* close */
 2685         { &vop_fsync_desc,      (vop_t *) sync_fsync },         /* fsync */
 2686         { &vop_inactive_desc,   (vop_t *) sync_inactive },      /* inactive */
 2687         { &vop_reclaim_desc,    (vop_t *) sync_reclaim },       /* reclaim */
 2688         { &vop_lock_desc,       (vop_t *) sync_lock },          /* lock */
 2689         { &vop_unlock_desc,     (vop_t *) sync_unlock },        /* unlock */
 2690         { &vop_print_desc,      (vop_t *) sync_print },         /* print */
 2691         { &vop_islocked_desc,   (vop_t *) sync_islocked },      /* islocked */
 2692         { NULL, NULL }
 2693 };
 2694 static struct vnodeopv_desc sync_vnodeop_opv_desc =
 2695         { &sync_vnodeop_p, sync_vnodeop_entries };
 2696 
 2697 VNODEOP_SET(sync_vnodeop_opv_desc);
 2698 
 2699 /*
 2700  * Create a new filesystem syncer vnode for the specified mount point.
 2701  */
 2702 int
 2703 vfs_allocate_syncvnode(mp)
 2704         struct mount *mp;
 2705 {
 2706         struct vnode *vp;
 2707         static long start, incr, next;
 2708         int error;
 2709 
 2710         /* Allocate a new vnode */
 2711         if ((error = getnewvnode(VT_VFS, mp, sync_vnodeop_p, &vp)) != 0) {
 2712                 mp->mnt_syncer = NULL;
 2713                 return (error);
 2714         }
 2715         vp->v_type = VNON;
 2716         /*
 2717          * Place the vnode onto the syncer worklist. We attempt to
 2718          * scatter them about on the list so that they will go off
 2719          * at evenly distributed times even if all the filesystems
 2720          * are mounted at once.
 2721          */
 2722         next += incr;
 2723         if (next == 0 || next > syncer_maxdelay) {
 2724                 start /= 2;
 2725                 incr /= 2;
 2726                 if (start == 0) {
 2727                         start = syncer_maxdelay / 2;
 2728                         incr = syncer_maxdelay;
 2729                 }
 2730                 next = start;
 2731         }
 2732         vn_syncer_add_to_worklist(vp, syncdelay > 0 ? next % syncdelay : 0);
 2733         mp->mnt_syncer = vp;
 2734         return (0);
 2735 }
 2736 
 2737 /*
 2738  * Do a lazy sync of the filesystem.
 2739  */
 2740 static int
 2741 sync_fsync(ap)
 2742         struct vop_fsync_args /* {
 2743                 struct vnode *a_vp;
 2744                 struct ucred *a_cred;
 2745                 int a_waitfor;
 2746                 struct proc *a_p;
 2747         } */ *ap;
 2748 {
 2749         struct vnode *syncvp = ap->a_vp;
 2750         struct mount *mp = syncvp->v_mount;
 2751         struct proc *p = ap->a_p;
 2752         int asyncflag;
 2753 
 2754         /*
 2755          * We only need to do something if this is a lazy evaluation.
 2756          */
 2757         if (ap->a_waitfor != MNT_LAZY)
 2758                 return (0);
 2759 
 2760         /*
 2761          * Move ourselves to the back of the sync list.
 2762          */
 2763         vn_syncer_add_to_worklist(syncvp, syncdelay);
 2764 
 2765         /*
 2766          * Walk the list of vnodes pushing all that are dirty and
 2767          * not already on the sync list.
 2768          */
 2769         simple_lock(&mountlist_slock);
 2770         if (vfs_busy(mp, LK_EXCLUSIVE | LK_NOWAIT, &mountlist_slock, p) != 0) {
 2771                 simple_unlock(&mountlist_slock);
 2772                 return (0);
 2773         }
 2774         asyncflag = mp->mnt_flag & MNT_ASYNC;
 2775         mp->mnt_flag &= ~MNT_ASYNC;
 2776         vfs_msync(mp, MNT_NOWAIT);
 2777         VFS_SYNC(mp, MNT_LAZY, ap->a_cred, p);
 2778         if (asyncflag)
 2779                 mp->mnt_flag |= MNT_ASYNC;
 2780         vfs_unbusy(mp, p);
 2781         return (0);
 2782 }
 2783 
 2784 /*
 2785  * The syncer vnode is no referenced.
 2786  */
 2787 static int
 2788 sync_inactive(ap)
 2789         struct vop_inactive_args /* {
 2790                 struct vnode *a_vp;
 2791                 struct proc *a_p;
 2792         } */ *ap;
 2793 {
 2794 
 2795         vgone(ap->a_vp);
 2796         return (0);
 2797 }
 2798 
 2799 /*
 2800  * The syncer vnode is no longer needed and is being decommissioned.
 2801  *
 2802  * Modifications to the worklist must be protected at splbio().
 2803  */
 2804 static int
 2805 sync_reclaim(ap)
 2806         struct vop_reclaim_args /* {
 2807                 struct vnode *a_vp;
 2808         } */ *ap;
 2809 {
 2810         struct vnode *vp = ap->a_vp;
 2811         int s;
 2812 
 2813         s = splbio();
 2814         vp->v_mount->mnt_syncer = NULL;
 2815         if (vp->v_flag & VONWORKLST) {
 2816                 LIST_REMOVE(vp, v_synclist);
 2817                 vp->v_flag &= ~VONWORKLST;
 2818         }
 2819         splx(s);
 2820 
 2821         return (0);
 2822 }
 2823 
 2824 /*
 2825  * Print out a syncer vnode.
 2826  */
 2827 static int
 2828 sync_print(ap)
 2829         struct vop_print_args /* {
 2830                 struct vnode *a_vp;
 2831         } */ *ap;
 2832 {
 2833         struct vnode *vp = ap->a_vp;
 2834 
 2835         printf("syncer vnode");
 2836         if (vp->v_vnlock != NULL)
 2837                 lockmgr_printinfo(vp->v_vnlock);
 2838         printf("\n");
 2839         return (0);
 2840 }

Cache object: 812a3518dfb04fb21f75765b5abbd107


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